From b22064035aa980a5008872c89b6eda0269686bd6 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 8 Dec 2023 14:11:48 +0100 Subject: [PATCH 01/14] adding xmake support and windows workflow --- .github/workflows/windows.yml | 75 + .gitignore | 5 + includes/mlx.h | 68 +- .../__cpp_application.cpp-33125923.cpp.tmp | 27194 +++++++++++ .../core/__cpp_bridge.cpp-eb644723.cpp.tmp | 6401 +++ .../__cpp_inputs.cpp-7e53d83f.cpp.tmp | 38940 ++++++++++++++++ .../__cpp_text_pipeline.cpp-cd270745.cpp.tmp | 37918 +++++++++++++++ ...cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp | 34132 ++++++++++++++ .../__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp | 18406 ++++++++ src/core/application.cpp | 2 +- xmake.lua | 74 + 11 files changed, 163187 insertions(+), 28 deletions(-) create mode 100644 .github/workflows/windows.yml create mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_application.cpp-33125923.cpp.tmp create mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_bridge.cpp-eb644723.cpp.tmp create mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/platform/__cpp_inputs.cpp-7e53d83f.cpp.tmp create mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/__cpp_text_pipeline.cpp-cd270745.cpp.tmp create mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/descriptors/__cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp create mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/swapchain/__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp create mode 100644 xmake.lua diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml new file mode 100644 index 0000000..5f94576 --- /dev/null +++ b/.github/workflows/windows.yml @@ -0,0 +1,75 @@ +name: Windows (xmake) + +on: + pull_request: + push: + paths-ignore: + - '.gitignore + - 'LICENSE' + - 'README.md' + +jobs: + build: + strategy: + fail-fast: false + matrix: + os: [windows-latest] + arch: [x64] + mode: [release] + + runs-on: ${{ matrix.os }} + if: "!contains(github.event.head_commit.message, 'ci skip')" + + steps: + - name: Get current date as package key + id: cache_key + run: echo "key=$(date +'%W')" >> $GITHUB_OUTPUT + + - name: Checkout repository + uses: actions/checkout@v4 + + # Install system dependencies + - name: Install Vulkan SDK + uses: humbletim/install-vulkan-sdk@v1.1.1 + with: + version: 1.3.204.1 + cache: true + + # Force xmake to a specific folder (for cache) + - name: Set xmake env + run: echo "XMAKE_GLOBALDIR=${{ runner.workspace }}/xmake-global" >> $GITHUB_ENV + + # Install xmake + - name: Setup xmake + uses: xmake-io/github-action-setup-xmake@v1 + with: + xmake-version: branch@master + actions-cache-folder: .xmake-cache-W${{ steps.cache_key.outputs.key }} + + # Update xmake repository (in order to have the file that will be cached) + - name: Update xmake repository + run: xmake repo --update + + # Fetch xmake dephash + - name: Retrieve dependencies hash + id: dep_hash + run: echo "hash=$(xmake l utils.ci.packageskey)" >> $GITHUB_OUTPUT + + # Cache xmake dependencies + - name: Retrieve cached xmake dependencies + uses: actions/cache@v3 + with: + path: ${{ env.XMAKE_GLOBALDIR }}/.xmake/packages + key: Windows-${{ matrix.arch }}-${{ matrix.mode }}-${{ steps.dep_hash.outputs.hash }}-W${{ steps.cache_key.outputs.key }} + + # Setup compilation mode and install project dependencies + - name: Configure xmake and install dependencies + run: xmake config --arch=${{ matrix.arch }} --mode=${{ matrix.mode }} --yes + + # Build the mlx + - name: Build MacroLibX + run: xmake --yes + + # Build the test + - name: Build Test + run: xmake build --yes Test diff --git a/.gitignore b/.gitignore index 50cb388..c620972 100644 --- a/.gitignore +++ b/.gitignore @@ -4,5 +4,10 @@ *.a *.so *.out +*.dll +*.json +.xmake/ .cache/ +build/ test/.gdb_history +test/Test diff --git a/includes/mlx.h b/includes/mlx.h index 7c10776..09e7a15 100644 --- a/includes/mlx.h +++ b/includes/mlx.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 16:56:35 by maldavid #+# #+# */ -/* Updated: 2023/12/08 12:14:31 by kbz_8 ### ########.fr */ +/* Updated: 2023/12/08 14:09:31 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -19,6 +19,20 @@ extern "C" { #endif +#if defined(_WIN32) || defined(_WIN64) + #define MLX_EXPORT __declspec(dllexport) + #define MLX_IMPORT __declspec(dllexport) +#else + #define MLX_EXPORT + #define MLX_IMPORT +#endif + +#ifdef MLX_BUILD + #define MLX_API MLX_EXPORT +#else + #define MLX_API MLX_IMPORT +#endif + typedef enum { MLX_KEYDOWN = 0, @@ -34,7 +48,7 @@ typedef enum * * @return (void*) An opaque pointer to the internal MLX application or NULL (0x0) in case of error */ -void* mlx_init(); +MLX_API void* mlx_init(); /** * @brief Creates a new window @@ -46,7 +60,7 @@ void* mlx_init(); * * @return (void*) An opaque pointer to the internal MLX window or NULL (0x0) in case of error */ -void* mlx_new_window(void* mlx, int w, int h, const char* title); +MLX_API void* mlx_new_window(void* mlx, int w, int h, const char* title); /** * @brief Gives a function to be executed at each loop turn @@ -58,7 +72,7 @@ void* mlx_new_window(void* mlx, int w, int h, const char* title); * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_loop_hook(void* mlx, int (*f)(), void* param); +MLX_API int mlx_loop_hook(void* mlx, int (*f)(), void* param); /** * @brief Starts the internal main loop @@ -67,7 +81,7 @@ int mlx_loop_hook(void* mlx, int (*f)(), void* param); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_loop(void* mlx); +MLX_API int mlx_loop(void* mlx); /** * @brief Ends the internal main loop @@ -76,21 +90,21 @@ int mlx_loop(void* mlx); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_loop_end(void* mlx); +MLX_API int mlx_loop_end(void* mlx); /** * @brief Shows mouse cursor * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_mouse_show(); +MLX_API int mlx_mouse_show(); /** * @brief Hides mouse cursor * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_mouse_hide(); +MLX_API int mlx_mouse_hide(); /** * @brief Moves cursor to givent position @@ -102,7 +116,7 @@ int mlx_mouse_hide(); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_mouse_move(void* mlx, void* win, int x, int y); +MLX_API int mlx_mouse_move(void* mlx, void* win, int x, int y); /** * @brief Get cursor's position @@ -113,7 +127,7 @@ int mlx_mouse_move(void* mlx, void* win, int x, int y); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_mouse_get_pos(void* mlx, int* x, int* y); +MLX_API int mlx_mouse_get_pos(void* mlx, int* x, int* y); /** @@ -127,7 +141,7 @@ int mlx_mouse_get_pos(void* mlx, int* x, int* y); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_on_event(void* mlx, void* win, mlx_event_type event, int (*f)(), void* param); +MLX_API int mlx_on_event(void* mlx, void* win, mlx_event_type event, int (*f)(), void* param); /** @@ -144,7 +158,7 @@ int mlx_on_event(void* mlx, void* win, mlx_event_type event, int (*f)(), void* p * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_pixel_put(void* mlx, void* win, int x, int y, int color); +MLX_API int mlx_pixel_put(void* mlx, void* win, int x, int y, int color); /** @@ -156,7 +170,7 @@ int mlx_pixel_put(void* mlx, void* win, int x, int y, int color); * * @return (void*) An opaque pointer to the internal image or NULL (0x0) in case of error */ -void* mlx_new_image(void* mlx, int width, int height); +MLX_API void* mlx_new_image(void* mlx, int width, int height); /** * @brief Get image pixel data @@ -176,7 +190,7 @@ void* mlx_new_image(void* mlx, int width, int height); * ~ make IMAGES_OPTIMIZED=false * ``` */ -int mlx_get_image_pixel(void* mlx, void* img, int x, int y); +MLX_API int mlx_get_image_pixel(void* mlx, void* img, int x, int y); /** * @brief Set image pixel data @@ -197,7 +211,7 @@ int mlx_get_image_pixel(void* mlx, void* img, int x, int y); * ~ make IMAGES_OPTIMIZED=false * ``` */ -void mlx_set_image_pixel(void* mlx, void* img, int x, int y, int color); +MLX_API void mlx_set_image_pixel(void* mlx, void* img, int x, int y, int color); /** * @brief Put image to the given window @@ -210,7 +224,7 @@ void mlx_set_image_pixel(void* mlx, void* img, int x, int y, int color); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_put_image_to_window(void* mlx, void* win, void* img, int x, int y); +MLX_API int mlx_put_image_to_window(void* mlx, void* win, void* img, int x, int y); /** * @brief Destroys internal image @@ -220,7 +234,7 @@ int mlx_put_image_to_window(void* mlx, void* win, void* img, int x, int y); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_destroy_image(void* mlx, void* img); +MLX_API int mlx_destroy_image(void* mlx, void* img); /** @@ -233,7 +247,7 @@ int mlx_destroy_image(void* mlx, void* img); * * @return (void*) An opaque pointer to the internal image or NULL (0x0) in case of error */ -void* mlx_png_file_to_image(void* mlx, char* filename, int* width, int* height); +MLX_API void* mlx_png_file_to_image(void* mlx, char* filename, int* width, int* height); /** * @brief Create a new image from a jpg file @@ -245,7 +259,7 @@ void* mlx_png_file_to_image(void* mlx, char* filename, int* width, int* height); * * @return (void*) An opaque pointer to the internal image or NULL (0x0) in case of error */ -void* mlx_jpg_file_to_image(void* mlx, char* filename, int* width, int* height); +MLX_API void* mlx_jpg_file_to_image(void* mlx, char* filename, int* width, int* height); /** * @brief Create a new image from a bmp file @@ -257,7 +271,7 @@ void* mlx_jpg_file_to_image(void* mlx, char* filename, int* width, int* height); * * @return (void*) An opaque pointer to the internal image or NULL (0x0) in case of error */ -void* mlx_bmp_file_to_image(void* mlx, char* filename, int* width, int* height); +MLX_API void* mlx_bmp_file_to_image(void* mlx, char* filename, int* width, int* height); /** @@ -272,7 +286,7 @@ void* mlx_bmp_file_to_image(void* mlx, char* filename, int* width, int* height); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_string_put(void* mlx, void* win, int x, int y, int color, char* str); +MLX_API int mlx_string_put(void* mlx, void* win, int x, int y, int color, char* str); /** @@ -284,7 +298,7 @@ int mlx_string_put(void* mlx, void* win, int x, int y, int color, char* str); * * @return (void) */ -void mlx_set_font(void* mlx, void* win, char* filepath); +MLX_API void mlx_set_font(void* mlx, void* win, char* filepath); /** * @brief Loads a font to be used by `mlx_string_put` and scales it @@ -296,7 +310,7 @@ void mlx_set_font(void* mlx, void* win, char* filepath); * * @return (void) */ -void mlx_set_font_scale(void* mlx, void* win, char* filepath, float scale); +MLX_API void mlx_set_font_scale(void* mlx, void* win, char* filepath, float scale); /** @@ -307,7 +321,7 @@ void mlx_set_font_scale(void* mlx, void* win, char* filepath, float scale); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_clear_window(void* mlx, void* win); +MLX_API int mlx_clear_window(void* mlx, void* win); /** @@ -318,7 +332,7 @@ int mlx_clear_window(void* mlx, void* win); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_destroy_window(void* mlx, void* win); +MLX_API int mlx_destroy_window(void* mlx, void* win); /** * @brief Destroy internal MLX application @@ -327,7 +341,7 @@ int mlx_destroy_window(void* mlx, void* win); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_destroy_display(void* mlx); +MLX_API int mlx_destroy_display(void* mlx); /** @@ -339,7 +353,7 @@ int mlx_destroy_display(void* mlx); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -int mlx_get_screens_size(void* mlx, int* w, int* h); +MLX_API int mlx_get_screens_size(void* mlx, int* w, int* h); #ifdef __cplusplus } diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_application.cpp-33125923.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_application.cpp-33125923.cpp.tmp new file mode 100644 index 0000000..99c2c57 --- /dev/null +++ b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_application.cpp-33125923.cpp.tmp @@ -0,0 +1,27194 @@ +# 1 "src/core/application.cpp" +# 1 "" 1 +# 1 "" 3 +# 433 "" 3 +# 1 "" 1 +# 1 "" 2 +# 1 "src/core/application.cpp" 2 +# 13 "src/core/application.cpp" +# 1 "src/core/application.h" 1 +# 16 "src/core/application.h" +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 1 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 +# 31 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__)); + terminate(); + } +#pragma GCC visibility pop +} +# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 3 +# 1 "/usr/include/features.h" 1 3 4 +# 394 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 395 "/usr/include/features.h" 2 3 4 +# 481 "/usr/include/features.h" 3 4 +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 482 "/usr/include/features.h" 2 3 4 +# 503 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 576 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 577 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 578 "/usr/include/sys/cdefs.h" 2 3 4 +# 504 "/usr/include/features.h" 2 3 4 +# 527 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 528 "/usr/include/features.h" 2 3 4 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3 +# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 2 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); +# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +} +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; + }; +# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 +} +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; + + + + + + + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 +} +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } + + }; + + + + + + + + using true_type = integral_constant; + + + using false_type = integral_constant; + + + + template + using __bool_constant = integral_constant; + + + + + + + template + using bool_constant = integral_constant; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + template + struct is_reference + : public false_type + { }; + + template + struct is_reference<_Tp&> + : public true_type + { }; + + template + struct is_reference<_Tp&&> + : public true_type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long +# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long +# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __is_nothrow_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + template + struct is_same + + : public integral_constant + + + + { }; +# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; +# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_reference + { using type = _Tp; }; + + template + struct remove_reference<_Tp&> + { using type = _Tp; }; + + template + struct remove_reference<_Tp&&> + { using type = _Tp; }; + + + + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { 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; }; +# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; +# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __type; + }; + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; +# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template::value> + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + + template using void_t = void; +# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + + + bool _Dangle = false + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + +template + inline constexpr bool is_array_v = false; +template + inline constexpr bool is_array_v<_Tp[]> = true; +template + inline constexpr bool is_array_v<_Tp[_Num]> = true; + +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; +template + inline constexpr bool is_member_object_pointer_v = + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v = + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); +template + inline constexpr bool is_function_v = is_function<_Tp>::value; +template + inline constexpr bool is_reference_v = false; +template + inline constexpr bool is_reference_v<_Tp&> = true; +template + inline constexpr bool is_reference_v<_Tp&&> = true; +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; +template + inline constexpr bool is_object_v = is_object<_Tp>::value; +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +} +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + + inline + + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + + + + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + + + + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { + + template + using _IdxTuple = _Index_tuple<_Indices...>; + + + using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; + + + + + }; + + + + + + + template + struct integer_sequence + { + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + = __make_integer_seq; + + + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + + + + template + struct _Nth_type + { }; + + template + struct _Nth_type<0, _Tp0, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Rest...> + { using type = _Tp1; }; + + template + struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp2; }; + + template + + + + struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> + : _Nth_type<_Np - 3, _Rest...> + { }; + + + template + struct _Nth_type<0, _Tp0, _Tp1, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp1; }; + + + + + + + +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + class tuple; + + template + struct _Index_tuple; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; + + + + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } +# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } +# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iterator_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 +# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 +# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + namespace __detail + { +# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + } +# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } +# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + typename iterator_traits<_InputIterator>::value_type::first_type>; + + template + using __iter_val_t + = typename iterator_traits<_InputIterator>::value_type::second_type; + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +} +# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__res - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } +# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + } +# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { +# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template + + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 1 3 +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 + class exception + { + public: + exception() noexcept { } + virtual ~exception() noexcept; + + exception(const exception&) = default; + exception& operator=(const exception&) = default; + exception(exception&&) = default; + exception& operator=(exception&&) = default; + + + + + virtual const char* + what() const noexcept; + }; + + + +} + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 2 3 + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace std +{ + + + + + + + class bad_alloc : public exception + { + public: + bad_alloc() throw() { } + + + bad_alloc(const bad_alloc&) = default; + bad_alloc& operator=(const bad_alloc&) = default; + + + + + virtual ~bad_alloc() throw(); + + + virtual const char* what() const throw(); + }; + + + class bad_array_new_length : public bad_alloc + { + public: + bad_array_new_length() throw() { } + + + + virtual ~bad_array_new_length() throw(); + + + virtual const char* what() const throw(); + }; + + + + enum class align_val_t: size_t {}; + + + struct nothrow_t + { + + explicit nothrow_t() = default; + + }; + + extern const nothrow_t nothrow; + + + + typedef void (*new_handler)(); + + + + new_handler set_new_handler(new_handler) throw(); + + + + new_handler get_new_handler() noexcept; + +} +# 126 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +[[__nodiscard__]] void* operator new(std::size_t) + __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t) + __attribute__((__externally_visible__)); +void operator delete(void*) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*) noexcept + __attribute__((__externally_visible__)); + + + + + + +[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); + +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete(void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete[](void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete[](void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept +{ return __p; } +[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept +{ return __p; } + + +inline void operator delete (void*, void*) noexcept { } +inline void operator delete[](void*, void*) noexcept { } + +} + + +namespace std +{ + + + + template + [[nodiscard]] constexpr _Tp* + launder(_Tp* __p) noexcept + { return __builtin_launder(__p); } + + + + + template + void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; + template + void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; + + void launder(void*) = delete; + void launder(const void*) = delete; + void launder(volatile void*) = delete; + void launder(const volatile void*) = delete; + + + + + + + +} +# 236 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +#pragma GCC visibility pop +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + template + class __new_allocator + { + public: + typedef _Tp value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + + template + struct rebind + { typedef __new_allocator<_Tp1> other; }; + + + + + + typedef std::true_type propagate_on_container_move_assignment; + + + __attribute__((__always_inline__)) + + __new_allocator() noexcept { } + + __attribute__((__always_inline__)) + + __new_allocator(const __new_allocator&) noexcept { } + + template + __attribute__((__always_inline__)) + + __new_allocator(const __new_allocator<_Tp1>&) noexcept { } + + + ~__new_allocator() noexcept { } + + pointer + address(reference __x) const noexcept + { return std::__addressof(__x); } + + const_pointer + address(const_reference __x) const noexcept + { return std::__addressof(__x); } +# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + [[__nodiscard__]] _Tp* + allocate(size_type __n, const void* = static_cast(0)) + { + + + + static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); + + + if (__builtin_expect(__n > this->_M_max_size(), false)) + { + + + if (__n > (std::size_t(-1) / sizeof(_Tp))) + std::__throw_bad_array_new_length(); + std::__throw_bad_alloc(); + } + + + if (alignof(_Tp) > 16UL) + { + std::align_val_t __al = std::align_val_t(alignof(_Tp)); + return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp), + __al)); + } + + return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp))); + } + + + void + deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) + { + + + + + + + + if (alignof(_Tp) > 16UL) + { + __builtin_operator_delete((__p), + std::align_val_t(alignof(_Tp))); + return; + } + + __builtin_operator_delete((__p)); + } + + + + + + + __attribute__((__always_inline__)) + size_type + max_size() const noexcept + { return _M_max_size(); } + + + template + __attribute__((__always_inline__)) + void + construct(_Up* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + __attribute__((__always_inline__)) + void + destroy(_Up* __p) + noexcept(std::is_nothrow_destructible<_Up>::value) + { __p->~_Up(); } +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + template + friend __attribute__((__always_inline__)) bool + operator==(const __new_allocator&, const __new_allocator<_Up>&) + noexcept + { return true; } + + + template + friend __attribute__((__always_inline__)) bool + operator!=(const __new_allocator&, const __new_allocator<_Up>&) + noexcept + { return false; } + + + private: + __attribute__((__always_inline__)) + constexpr size_type + _M_max_size() const noexcept + { + + return std::size_t(9223372036854775807L) / sizeof(_Tp); + + + + } + }; + + +} +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3 + + +namespace std +{ +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 + template + using __allocator_base = __new_allocator<_Tp>; +} +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 1 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 + template + class allocator; + + template<> + class allocator; + + + + + template + struct uses_allocator; + + template + struct allocator_traits; + + + + + +} +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + template<> + class allocator + { + public: + typedef void value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + + + typedef void* pointer; + typedef const void* const_pointer; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + using propagate_on_container_move_assignment = true_type; + + using is_always_equal + + = true_type; +# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + }; +# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + template + class allocator : public __allocator_base<_Tp> + { + public: + typedef _Tp value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + + + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + using propagate_on_container_move_assignment = true_type; + + using is_always_equal + + = true_type; + + + + + __attribute__((__always_inline__)) + + allocator() noexcept { } + + __attribute__((__always_inline__)) + + allocator(const allocator& __a) noexcept + : __allocator_base<_Tp>(__a) { } + + + + allocator& operator=(const allocator&) = default; + + + template + __attribute__((__always_inline__)) + + allocator(const allocator<_Tp1>&) noexcept { } + + __attribute__((__always_inline__)) + + + + ~allocator() noexcept { } +# 214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + friend __attribute__((__always_inline__)) + bool + operator==(const allocator&, const allocator&) noexcept + { return true; } + + + friend __attribute__((__always_inline__)) + bool + operator!=(const allocator&, const allocator&) noexcept + { return false; } + + + + }; + + + + + + + template + __attribute__((__always_inline__)) + inline bool + operator==(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return true; } + + + template + __attribute__((__always_inline__)) + inline bool + operator!=(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return false; } + + + + + + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + + + + + + + extern template class allocator; + extern template class allocator; + + + + + + +} +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(_Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(const _Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(_Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(const _Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr _Tp* + begin(_Tp (&__arr)[_Nm]) noexcept + { return __arr; } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr _Tp* + end(_Tp (&__arr)[_Nm]) noexcept + { return __arr + _Nm; } + + + + template class valarray; + + template _Tp* begin(valarray<_Tp>&) noexcept; + template const _Tp* begin(const valarray<_Tp>&) noexcept; + template _Tp* end(valarray<_Tp>&) noexcept; + template const _Tp* end(const valarray<_Tp>&) noexcept; + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + constexpr auto + cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) + -> decltype(std::begin(__cont)) + { return std::begin(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + constexpr auto + cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) + -> decltype(std::end(__cont)) + { return std::end(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rbegin(_Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(_Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(const _Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Tp*> + rbegin(_Tp (&__arr)[_Nm]) noexcept + { return reverse_iterator<_Tp*>(__arr + _Nm); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Tp*> + rend(_Tp (&__arr)[_Nm]) noexcept + { return reverse_iterator<_Tp*>(__arr); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator + rbegin(initializer_list<_Tp> __il) noexcept + { return reverse_iterator(__il.end()); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator + rend(initializer_list<_Tp> __il) noexcept + { return reverse_iterator(__il.begin()); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) + { return std::rbegin(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + crend(const _Container& __cont) -> decltype(std::rend(__cont)) + { return std::rend(__cont); } +# 261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + size(const _Container& __cont) noexcept(noexcept(__cont.size())) + -> decltype(__cont.size()) + { return __cont.size(); } + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr size_t + size(const _Tp (&)[_Nm]) noexcept + { return _Nm; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) + -> decltype(__cont.empty()) + { return __cont.empty(); } + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr bool + empty(const _Tp (&)[_Nm]) noexcept + { return false; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr bool + empty(initializer_list<_Tp> __il) noexcept + { return __il.size() == 0;} + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + data(_Container& __cont) noexcept(noexcept(__cont.data())) + -> decltype(__cont.data()) + { return __cont.data(); } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + data(const _Container& __cont) noexcept(noexcept(__cont.data())) + -> decltype(__cont.data()) + { return __cont.data(); } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr _Tp* + data(_Tp (&__array)[_Nm]) noexcept + { return __array; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr const _Tp* + data(initializer_list<_Tp> __il) noexcept + { return __il.begin(); } +# 371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 1 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 1 3 +# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + inline void + destroy_at(_Tp* __location) + { + if constexpr (201703L > 201703L && is_array_v<_Tp>) + { + for (auto& __x : *__location) + std::destroy_at(std::__addressof(__x)); + } + else + __location->~_Tp(); + } +# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + template + + inline void + _Construct(_Tp* __p, _Args&&... __args) + { +# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + } +# 132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + template + inline void + _Construct_novalue(_T1* __p) + { ::new((void*)__p) _T1; } + + template + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last); + + + + + template + constexpr inline void + _Destroy(_Tp* __pointer) + { + + + + __pointer->~_Tp(); + + } + + template + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator __first, _ForwardIterator __last) + { + for (; __first != __last; ++__first) + std::_Destroy(std::__addressof(*__first)); + } + }; + + template<> + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator, _ForwardIterator) { } + }; + + + + + + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: + __destroy(__first, __last); + } + + template + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + for (; __count > 0; (void)++__first, --__count) + std::_Destroy(std::__addressof(*__first)); + return __first; + } + }; + + template<> + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + std::advance(__first, __count); + return __first; + } + }; + + + + + + + template + inline _ForwardIterator + _Destroy_n(_ForwardIterator __first, _Size __count) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: + __destroy_n(__first, __count); + } + + + template + inline void + destroy(_ForwardIterator __first, _ForwardIterator __last) + { + std::_Destroy(__first, __last); + } + + template + inline _ForwardIterator + destroy_n(_ForwardIterator __first, _Size __count) + { + return std::_Destroy_n(__first, __count); + } + + + +} +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 2 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + struct __allocator_traits_base + { + template + struct __rebind : __replace_first_arg<_Tp, _Up> + { + static_assert(is_same< + typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, + _Tp>::value, + "allocator_traits::rebind_alloc must be A"); + }; + + template + struct __rebind<_Tp, _Up, + __void_t::other>> + { + using type = typename _Tp::template rebind<_Up>::other; + + static_assert(is_same< + typename _Tp::template rebind::other, + _Tp>::value, + "allocator_traits::rebind_alloc must be A"); + }; + + protected: + template + using __pointer = typename _Tp::pointer; + template + using __c_pointer = typename _Tp::const_pointer; + template + using __v_pointer = typename _Tp::void_pointer; + template + using __cv_pointer = typename _Tp::const_void_pointer; + template + using __pocca = typename _Tp::propagate_on_container_copy_assignment; + template + using __pocma = typename _Tp::propagate_on_container_move_assignment; + template + using __pocs = typename _Tp::propagate_on_container_swap; + template + using __equal = __type_identity; + }; + + template + using __alloc_rebind + = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; +# 104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct allocator_traits : __allocator_traits_base + { + + typedef _Alloc allocator_type; + + typedef typename _Alloc::value_type value_type; + + + + + + + using pointer = __detected_or_t; + + private: + + template class _Func, typename _Tp, typename = void> + struct _Ptr + { + using type = typename pointer_traits::template rebind<_Tp>; + }; + + template class _Func, typename _Tp> + struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> + { + using type = _Func<_Alloc>; + }; + + + template + struct _Diff + { using type = typename pointer_traits<_PtrT>::difference_type; }; + + template + struct _Diff<_A2, _PtrT, __void_t> + { using type = typename _A2::difference_type; }; + + + template + struct _Size : make_unsigned<_DiffT> { }; + + template + struct _Size<_A2, _DiffT, __void_t> + { using type = typename _A2::size_type; }; + + public: + + + + + + + using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; + + + + + + + + using void_pointer = typename _Ptr<__v_pointer, void>::type; + + + + + + + + using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; + + + + + + + + using difference_type = typename _Diff<_Alloc, pointer>::type; + + + + + + + + using size_type = typename _Size<_Alloc, difference_type>::type; + + + + + + + + using propagate_on_container_copy_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_move_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_swap + = __detected_or_t; + + + + + + + + using is_always_equal + = typename __detected_or_t, __equal, _Alloc>::type; + + template + using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; + template + using rebind_traits = allocator_traits>; + + private: + template + static constexpr auto + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) + -> decltype(__a.allocate(__n, __hint)) + { return __a.allocate(__n, __hint); } + + template + static constexpr pointer + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) + { return __a.allocate(__n); } + + template + struct __construct_helper + { + template()->construct( + std::declval<_Tp*>(), std::declval<_Args>()...))> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc>(0)); + }; + + template + using __has_construct + = typename __construct_helper<_Tp, _Args...>::type; + + template + static constexpr _Require<__has_construct<_Tp, _Args...>> + _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) + { __a.construct(__p, std::forward<_Args>(__args)...); } + + template + static constexpr + _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, + is_constructible<_Tp, _Args...>>> + _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) + { + + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + + + + } + + template + static constexpr auto + _S_destroy(_Alloc2& __a, _Tp* __p, int) + noexcept(noexcept(__a.destroy(__p))) + -> decltype(__a.destroy(__p)) + { __a.destroy(__p); } + + template + static constexpr void + _S_destroy(_Alloc2&, _Tp* __p, ...) + noexcept(std::is_nothrow_destructible<_Tp>::value) + { std::_Destroy(__p); } + + template + static constexpr auto + _S_max_size(_Alloc2& __a, int) + -> decltype(__a.max_size()) + { return __a.max_size(); } + + template + static constexpr size_type + _S_max_size(_Alloc2&, ...) + { + + + return __gnu_cxx::__numeric_traits::__max + / sizeof(value_type); + } + + template + static constexpr auto + _S_select(_Alloc2& __a, int) + -> decltype(__a.select_on_container_copy_construction()) + { return __a.select_on_container_copy_construction(); } + + template + static constexpr _Alloc2 + _S_select(_Alloc2& __a, ...) + { return __a; } + + public: +# 331 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n) + { return __a.allocate(__n); } +# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) + { return _S_allocate(__a, __n, __hint, 0); } +# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static void + deallocate(_Alloc& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 373 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + static auto + construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(_S_construct(__a, __p, + std::forward<_Args>(__args)...))) + -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) + { _S_construct(__a, __p, std::forward<_Args>(__args)...); } +# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + static void + destroy(_Alloc& __a, _Tp* __p) + noexcept(noexcept(_S_destroy(__a, __p, 0))) + { _S_destroy(__a, __p, 0); } +# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static size_type + max_size(const _Alloc& __a) noexcept + { return _S_max_size(__a, 0); } +# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static _Alloc + select_on_container_copy_construction(const _Alloc& __rhs) + { return _S_select(__rhs, 0); } + }; +# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct allocator_traits> + { + + using allocator_type = allocator<_Tp>; + + + using value_type = _Tp; + + + using pointer = _Tp*; + + + using const_pointer = const _Tp*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + using propagate_on_container_copy_assignment = false_type; + + + using propagate_on_container_move_assignment = true_type; + + + using propagate_on_container_swap = false_type; + + + using is_always_equal = true_type; + + template + using rebind_alloc = allocator<_Up>; + + template + using rebind_traits = allocator_traits>; +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) + { + + return __a.allocate(__n, __hint); + + + + } +# 513 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__gnu__::__always_inline__]] + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, + _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { + + __a.construct(__p, std::forward<_Args>(__args)...); + + + + } +# 550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { + + __a.destroy(__p); + + + + } + + + + + + + [[__gnu__::__always_inline__]] + static size_type + max_size(const allocator_type& __a __attribute__((__unused__))) noexcept + { + + return __a.max_size(); + + + + } + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; + + + template<> + struct allocator_traits> + { + + using allocator_type = allocator; + + + using value_type = void; + + + using pointer = void*; + + + using const_pointer = const void*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + using propagate_on_container_copy_assignment = false_type; + + + using propagate_on_container_move_assignment = true_type; + + + using propagate_on_container_swap = false_type; + + + using is_always_equal = true_type; + + template + using rebind_alloc = allocator<_Up>; + + template + using rebind_traits = allocator_traits>; + + + static void* + allocate(allocator_type&, size_type, const void* = nullptr) = delete; + + + static void + deallocate(allocator_type&, void*, size_type) = delete; +# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type&, _Up* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { std::_Construct(__p, std::forward<_Args>(__args)...); } +# 669 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + destroy(allocator_type&, _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { std::_Destroy(__p); } + + + static size_type + max_size(const allocator_type&) = delete; + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; +# 707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_copy(_Alloc& __one, const _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocca = + typename __traits::propagate_on_container_copy_assignment::type; + + if constexpr (__pocca::value) + __one = __two; + + + + } + + template + [[__gnu__::__always_inline__]] + constexpr _Alloc + __alloc_on_copy(const _Alloc& __a) + { + typedef allocator_traits<_Alloc> __traits; + return __traits::select_on_container_copy_construction(__a); + } +# 744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_move(_Alloc& __one, _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocma + = typename __traits::propagate_on_container_move_assignment::type; + + if constexpr (__pocma::value) + __one = std::move(__two); + + + + } +# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_swap(_Alloc& __one, _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocs = typename __traits::propagate_on_container_swap::type; + + if constexpr (__pocs::value) + { + using std::swap; + swap(__one, __two); + } + + + + } + + template, + typename = void> + struct __is_alloc_insertable_impl + : false_type + { }; + + template + struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, + __void_t::construct( + std::declval<_Alloc&>(), std::declval<_ValueT*>(), + std::declval<_Tp>()))>> + : true_type + { }; + + + + + template + struct __is_copy_insertable + : __is_alloc_insertable_impl<_Alloc, + typename _Alloc::value_type const&>::type + { }; + + + + template + struct __is_copy_insertable> + : is_copy_constructible<_Tp> + { }; + + + + + + template + struct __is_move_insertable + : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type + { }; + + + + template + struct __is_move_insertable> + : is_move_constructible<_Tp> + { }; + + + + template + struct __is_allocator : false_type { }; + + template + struct __is_allocator<_Alloc, + __void_t().allocate(size_t{}))>> + : true_type { }; + + template + using _RequireAllocator + = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; + + template + using _RequireNotAllocator + = typename enable_if::value, _Alloc>::type; +# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct __alloc_swap + { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; + + template + struct __alloc_swap<_Alloc, false> + { + static void + _S_do_it(_Alloc& __one, _Alloc& __two) noexcept + { + + if (__one != __two) + swap(__one, __two); + } + }; + + + template, + is_nothrow_move_constructible>::value> + struct __shrink_to_fit_aux + { static bool _S_do_it(_Tp&) noexcept { return false; } }; + + template + struct __shrink_to_fit_aux<_Tp, true> + { + + static bool + _S_do_it(_Tp& __c) noexcept + { + + try + { + _Tp(__make_move_if_noexcept_iterator(__c.begin()), + __make_move_if_noexcept_iterator(__c.end()), + __c.get_allocator()).swap(__c); + return true; + } + catch(...) + { return false; } + + + + } + }; +# 925 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + _Allocator& __alloc) + { + for (; __first != __last; ++__first) + + + + allocator_traits<_Allocator>::destroy(__alloc, + std::__addressof(*__first)); + + } + + + template + __attribute__((__always_inline__)) + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + allocator<_Tp>&) + { + std::_Destroy(__first, __last); + } + + + + +} +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + + + +template + struct __alloc_traits + + : std::allocator_traits<_Alloc> + + { + typedef _Alloc allocator_type; + + typedef std::allocator_traits<_Alloc> _Base_type; + typedef typename _Base_type::value_type value_type; + typedef typename _Base_type::pointer pointer; + typedef typename _Base_type::const_pointer const_pointer; + typedef typename _Base_type::size_type size_type; + typedef typename _Base_type::difference_type difference_type; + + typedef value_type& reference; + typedef const value_type& const_reference; + using _Base_type::allocate; + using _Base_type::deallocate; + using _Base_type::construct; + using _Base_type::destroy; + using _Base_type::max_size; + + private: + template + using __is_custom_pointer + = std::__and_, + std::__not_>>; + + public: + + template + [[__gnu__::__always_inline__]] + static constexpr + std::__enable_if_t<__is_custom_pointer<_Ptr>::value> + construct(_Alloc& __a, _Ptr __p, _Args&&... __args) + noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), + std::forward<_Args>(__args)...))) + { + _Base_type::construct(__a, std::__to_address(__p), + std::forward<_Args>(__args)...); + } + + + template + [[__gnu__::__always_inline__]] + static constexpr + std::__enable_if_t<__is_custom_pointer<_Ptr>::value> + destroy(_Alloc& __a, _Ptr __p) + noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) + { _Base_type::destroy(__a, std::__to_address(__p)); } + + [[__gnu__::__always_inline__]] + static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) + { return _Base_type::select_on_container_copy_construction(__a); } + + [[__gnu__::__always_inline__]] + static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) + { std::__alloc_on_swap(__a, __b); } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_copy_assign() + { return _Base_type::propagate_on_container_copy_assignment::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_move_assign() + { return _Base_type::propagate_on_container_move_assignment::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_swap() + { return _Base_type::propagate_on_container_swap::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_always_equal() + { return _Base_type::is_always_equal::value; } + + __attribute__((__always_inline__)) + static constexpr bool _S_nothrow_move() + { return _S_propagate_on_move_assign() || _S_always_equal(); } + + template + struct rebind + { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; +# 180 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 + }; + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocated_ptr.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocated_ptr.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + struct __allocated_ptr + { + using pointer = typename allocator_traits<_Alloc>::pointer; + using value_type = typename allocator_traits<_Alloc>::value_type; + + + __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept + : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr) + { } + + + template>> + __allocated_ptr(_Alloc& __a, _Ptr __ptr) + : _M_alloc(std::__addressof(__a)), + _M_ptr(pointer_traits::pointer_to(*__ptr)) + { } + + + __allocated_ptr(__allocated_ptr&& __gd) noexcept + : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr) + { __gd._M_ptr = nullptr; } + + + ~__allocated_ptr() + { + if (_M_ptr != nullptr) + std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1); + } + + + __allocated_ptr& + operator=(std::nullptr_t) noexcept + { + _M_ptr = nullptr; + return *this; + } + + + value_type* get() { return std::__to_address(_M_ptr); } + + private: + _Alloc* _M_alloc; + pointer _M_ptr; + }; + + + template + __allocated_ptr<_Alloc> + __allocate_guarded(_Alloc& __a) + { + return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) }; + } + + + +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/aligned_buffer.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/aligned_buffer.h" 3 + + + + + + + +namespace __gnu_cxx +{ + + + + + template + struct __aligned_membuf + { + + + + + + struct _Tp2 { _Tp _M_t; }; + + alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)]; + + __aligned_membuf() = default; + + + __aligned_membuf(std::nullptr_t) { } + + void* + _M_addr() noexcept + { return static_cast(&_M_storage); } + + const void* + _M_addr() const noexcept + { return static_cast(&_M_storage); } + + _Tp* + _M_ptr() noexcept + { return static_cast<_Tp*>(_M_addr()); } + + const _Tp* + _M_ptr() const noexcept + { return static_cast(_M_addr()); } + }; + + + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + + + template + struct __aligned_buffer + : std::aligned_storage + { + typename + std::aligned_storage::type _M_storage; + + __aligned_buffer() = default; + + + __aligned_buffer(std::nullptr_t) { } + + void* + _M_addr() noexcept + { + return static_cast(&_M_storage); + } + + const void* + _M_addr() const noexcept + { + return static_cast(&_M_storage); + } + + _Tp* + _M_ptr() noexcept + { return static_cast<_Tp*>(_M_addr()); } + + const _Tp* + _M_ptr() const noexcept + { return static_cast(_M_addr()); } + }; +#pragma GCC diagnostic pop + + +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace __detail + { + + + + + + + + struct _List_node_base + { + _List_node_base* _M_next; + _List_node_base* _M_prev; + + static void + swap(_List_node_base& __x, _List_node_base& __y) noexcept; + + void + _M_transfer(_List_node_base* const __first, + _List_node_base* const __last) noexcept; + + void + _M_reverse() noexcept; + + void + _M_hook(_List_node_base* const __position) noexcept; + + void + _M_unhook() noexcept; + }; + + + struct _List_node_header : public _List_node_base + { + + std::size_t _M_size; + + + _List_node_header() noexcept + { _M_init(); } + + + _List_node_header(_List_node_header&& __x) noexcept + : _List_node_base{ __x._M_next, __x._M_prev } + + , _M_size(__x._M_size) + + { + if (__x._M_base()->_M_next == __x._M_base()) + this->_M_next = this->_M_prev = this; + else + { + this->_M_next->_M_prev = this->_M_prev->_M_next = this->_M_base(); + __x._M_init(); + } + } + + void + _M_move_nodes(_List_node_header&& __x) + { + _List_node_base* const __xnode = __x._M_base(); + if (__xnode->_M_next == __xnode) + _M_init(); + else + { + _List_node_base* const __node = this->_M_base(); + __node->_M_next = __xnode->_M_next; + __node->_M_prev = __xnode->_M_prev; + __node->_M_next->_M_prev = __node->_M_prev->_M_next = __node; + + _M_size = __x._M_size; + + __x._M_init(); + } + } + + + void + _M_init() noexcept + { + this->_M_next = this->_M_prev = this; + + this->_M_size = 0; + + } + + private: + _List_node_base* _M_base() { return this; } + }; + + + struct _Scratch_list : _List_node_base + { + _Scratch_list() { _M_next = _M_prev = this; } + + bool empty() const { return _M_next == this; } + + void swap(_List_node_base& __l) { _List_node_base::swap(*this, __l); } + + template + struct _Ptr_cmp + { + _Cmp _M_cmp; + + bool + operator()(__detail::_List_node_base* __lhs, + __detail::_List_node_base* __rhs) + { return _M_cmp(*_Iter(__lhs), *_Iter(__rhs)); } + }; + + template + struct _Ptr_cmp<_Iter, void> + { + bool + operator()(__detail::_List_node_base* __lhs, + __detail::_List_node_base* __rhs) const + { return *_Iter(__lhs) < *_Iter(__rhs); } + }; + + + template + void + merge(_List_node_base& __x, _Cmp __comp) + { + _List_node_base* __first1 = _M_next; + _List_node_base* const __last1 = this; + _List_node_base* __first2 = __x._M_next; + _List_node_base* const __last2 = std::__addressof(__x); + + while (__first1 != __last1 && __first2 != __last2) + { + if (__comp(__first2, __first1)) + { + _List_node_base* __next = __first2->_M_next; + __first1->_M_transfer(__first2, __next); + __first2 = __next; + } + else + __first1 = __first1->_M_next; + } + if (__first2 != __last2) + this->_M_transfer(__first2, __last2); + } + + + void _M_take_one(_List_node_base* __i) + { this->_M_transfer(__i, __i->_M_next); } + + + void _M_put_all(_List_node_base* __i) + { + if (!empty()) + __i->_M_transfer(_M_next, this); + } + }; + + } + + + + + template + struct _List_node : public __detail::_List_node_base + { + + __gnu_cxx::__aligned_membuf<_Tp> _M_storage; + _Tp* _M_valptr() { return _M_storage._M_ptr(); } + _Tp const* _M_valptr() const { return _M_storage._M_ptr(); } + + + + + + }; + + + + + + + template + struct _List_iterator + { + typedef _List_iterator<_Tp> _Self; + typedef _List_node<_Tp> _Node; + + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef _Tp value_type; + typedef _Tp* pointer; + typedef _Tp& reference; + + _List_iterator() noexcept + : _M_node() { } + + explicit + _List_iterator(__detail::_List_node_base* __x) noexcept + : _M_node(__x) { } + + _Self + _M_const_cast() const noexcept + { return *this; } + + + [[__nodiscard__]] + reference + operator*() const noexcept + { return *static_cast<_Node*>(_M_node)->_M_valptr(); } + + [[__nodiscard__]] + pointer + operator->() const noexcept + { return static_cast<_Node*>(_M_node)->_M_valptr(); } + + _Self& + operator++() noexcept + { + _M_node = _M_node->_M_next; + return *this; + } + + _Self + operator++(int) noexcept + { + _Self __tmp = *this; + _M_node = _M_node->_M_next; + return __tmp; + } + + _Self& + operator--() noexcept + { + _M_node = _M_node->_M_prev; + return *this; + } + + _Self + operator--(int) noexcept + { + _Self __tmp = *this; + _M_node = _M_node->_M_prev; + return __tmp; + } + + [[__nodiscard__]] + friend bool + operator==(const _Self& __x, const _Self& __y) noexcept + { return __x._M_node == __y._M_node; } + + + [[__nodiscard__]] + friend bool + operator!=(const _Self& __x, const _Self& __y) noexcept + { return __x._M_node != __y._M_node; } + + + + __detail::_List_node_base* _M_node; + }; + + + + + + + template + struct _List_const_iterator + { + typedef _List_const_iterator<_Tp> _Self; + typedef const _List_node<_Tp> _Node; + typedef _List_iterator<_Tp> iterator; + + typedef ptrdiff_t difference_type; + typedef std::bidirectional_iterator_tag iterator_category; + typedef _Tp value_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + + _List_const_iterator() noexcept + : _M_node() { } + + explicit + _List_const_iterator(const __detail::_List_node_base* __x) + noexcept + : _M_node(__x) { } + + _List_const_iterator(const iterator& __x) noexcept + : _M_node(__x._M_node) { } + + iterator + _M_const_cast() const noexcept + { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); } + + + [[__nodiscard__]] + reference + operator*() const noexcept + { return *static_cast<_Node*>(_M_node)->_M_valptr(); } + + [[__nodiscard__]] + pointer + operator->() const noexcept + { return static_cast<_Node*>(_M_node)->_M_valptr(); } + + _Self& + operator++() noexcept + { + _M_node = _M_node->_M_next; + return *this; + } + + _Self + operator++(int) noexcept + { + _Self __tmp = *this; + _M_node = _M_node->_M_next; + return __tmp; + } + + _Self& + operator--() noexcept + { + _M_node = _M_node->_M_prev; + return *this; + } + + _Self + operator--(int) noexcept + { + _Self __tmp = *this; + _M_node = _M_node->_M_prev; + return __tmp; + } + + [[__nodiscard__]] + friend bool + operator==(const _Self& __x, const _Self& __y) noexcept + { return __x._M_node == __y._M_node; } + + + [[__nodiscard__]] + friend bool + operator!=(const _Self& __x, const _Self& __y) noexcept + { return __x._M_node != __y._M_node; } + + + + const __detail::_List_node_base* _M_node; + }; + +namespace __cxx11 { + + template + class _List_base + { + protected: + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Tp>::other _Tp_alloc_type; + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tp_alloc_traits; + typedef typename _Tp_alloc_traits::template + rebind<_List_node<_Tp> >::other _Node_alloc_type; + typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits; + + + static size_t + _S_distance(const __detail::_List_node_base* __first, + const __detail::_List_node_base* __last) + { + size_t __n = 0; + while (__first != __last) + { + __first = __first->_M_next; + ++__n; + } + return __n; + } + + + struct _List_impl + : public _Node_alloc_type + { + __detail::_List_node_header _M_node; + + _List_impl() noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value) + + : _Node_alloc_type() + { } + + _List_impl(const _Node_alloc_type& __a) noexcept + : _Node_alloc_type(__a) + { } + + + _List_impl(_List_impl&&) = default; + + _List_impl(_Node_alloc_type&& __a, _List_impl&& __x) + : _Node_alloc_type(std::move(__a)), _M_node(std::move(__x._M_node)) + { } + + _List_impl(_Node_alloc_type&& __a) noexcept + : _Node_alloc_type(std::move(__a)) + { } + + }; + + _List_impl _M_impl; + + + size_t _M_get_size() const { return _M_impl._M_node._M_size; } + + void _M_set_size(size_t __n) { _M_impl._M_node._M_size = __n; } + + void _M_inc_size(size_t __n) { _M_impl._M_node._M_size += __n; } + + void _M_dec_size(size_t __n) { _M_impl._M_node._M_size -= __n; } + + + size_t + _M_distance(const __detail::_List_node_base* __first, + const __detail::_List_node_base* __last) const + { return _S_distance(__first, __last); } + + + size_t _M_node_count() const { return _M_get_size(); } +# 516 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + typename _Node_alloc_traits::pointer + _M_get_node() + { return _Node_alloc_traits::allocate(_M_impl, 1); } + + void + _M_put_node(typename _Node_alloc_traits::pointer __p) noexcept + { _Node_alloc_traits::deallocate(_M_impl, __p, 1); } + + public: + typedef _Alloc allocator_type; + + _Node_alloc_type& + _M_get_Node_allocator() noexcept + { return _M_impl; } + + const _Node_alloc_type& + _M_get_Node_allocator() const noexcept + { return _M_impl; } + + + _List_base() = default; + + + + + _List_base(const _Node_alloc_type& __a) noexcept + : _M_impl(__a) + { } + + + _List_base(_List_base&&) = default; + + + _List_base(_List_base&& __x, _Node_alloc_type&& __a) + : _M_impl(std::move(__a)) + { + if (__x._M_get_Node_allocator() == _M_get_Node_allocator()) + _M_move_nodes(std::move(__x)); + + } + + + + _List_base(_Node_alloc_type&& __a, _List_base&& __x) + : _M_impl(std::move(__a), std::move(__x._M_impl)) + { } + + + _List_base(_Node_alloc_type&& __a) + : _M_impl(std::move(__a)) + { } + + void + _M_move_nodes(_List_base&& __x) + { _M_impl._M_node._M_move_nodes(std::move(__x._M_impl._M_node)); } + + + + ~_List_base() noexcept + { _M_clear(); } + + void + _M_clear() noexcept; + + void + _M_init() noexcept + { this->_M_impl._M_node._M_init(); } + }; +# 631 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template > + class list : protected _List_base<_Tp, _Alloc> + { +# 644 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + static_assert(is_same::type, _Tp>::value, + "std::list must have a non-const, non-volatile value_type"); + + static_assert(is_same::value, + "std::list must have the same value_type as its allocator"); + + + + typedef _List_base<_Tp, _Alloc> _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + typedef typename _Base::_Tp_alloc_traits _Tp_alloc_traits; + typedef typename _Base::_Node_alloc_type _Node_alloc_type; + typedef typename _Base::_Node_alloc_traits _Node_alloc_traits; + + public: + typedef _Tp value_type; + typedef typename _Tp_alloc_traits::pointer pointer; + typedef typename _Tp_alloc_traits::const_pointer const_pointer; + typedef typename _Tp_alloc_traits::reference reference; + typedef typename _Tp_alloc_traits::const_reference const_reference; + typedef _List_iterator<_Tp> iterator; + typedef _List_const_iterator<_Tp> const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + protected: + + + typedef _List_node<_Tp> _Node; + + using _Base::_M_impl; + using _Base::_M_put_node; + using _Base::_M_get_node; + using _Base::_M_get_Node_allocator; +# 706 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template + _Node* + _M_create_node(_Args&&... __args) + { + auto __p = this->_M_get_node(); + auto& __alloc = _M_get_Node_allocator(); + __allocated_ptr<_Node_alloc_type> __guard{__alloc, __p}; + _Node_alloc_traits::construct(__alloc, __p->_M_valptr(), + std::forward<_Args>(__args)...); + __guard = nullptr; + return __p; + } + + + + static size_t + _S_distance(const_iterator __first, const_iterator __last) + { return std::distance(__first, __last); } + + + size_t + _M_node_count() const + { return this->_M_get_size(); } +# 741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + public: + + + + + + + + list() = default; +# 758 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + explicit + list(const allocator_type& __a) noexcept + : _Base(_Node_alloc_type(__a)) { } +# 771 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + explicit + list(size_type __n, const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { _M_default_initialize(__n); } +# 784 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + list(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { _M_fill_initialize(__n, __value); } +# 811 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + list(const list& __x) + : _Base(_Node_alloc_traits:: + _S_select_on_copy(__x._M_get_Node_allocator())) + { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } +# 824 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + list(list&&) = default; +# 834 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + list(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); } + + list(const list& __x, const __type_identity_t& __a) + : _Base(_Node_alloc_type(__a)) + { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } + + private: + list(list&& __x, const allocator_type& __a, true_type) noexcept + : _Base(_Node_alloc_type(__a), std::move(__x)) + { } + + list(list&& __x, const allocator_type& __a, false_type) + : _Base(_Node_alloc_type(__a)) + { + if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator()) + this->_M_move_nodes(std::move(__x)); + else + insert(begin(), std::__make_move_if_noexcept_iterator(__x.begin()), + std::__make_move_if_noexcept_iterator(__x.end())); + } + + public: + list(list&& __x, const __type_identity_t& __a) + noexcept(_Node_alloc_traits::_S_always_equal()) + : list(std::move(__x), __a, + typename _Node_alloc_traits::is_always_equal{}) + { } +# 877 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template> + list(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(_Node_alloc_type(__a)) + { _M_initialize_dispatch(__first, __last, __false_type()); } +# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + ~list() = default; +# 914 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + list& + operator=(const list& __x); +# 928 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + list& + operator=(list&& __x) + noexcept(_Node_alloc_traits::_S_nothrow_move()) + { + constexpr bool __move_storage = + _Node_alloc_traits::_S_propagate_on_move_assign() + || _Node_alloc_traits::_S_always_equal(); + _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); + return *this; + } +# 946 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + list& + operator=(initializer_list __l) + { + this->assign(__l.begin(), __l.end()); + return *this; + } +# 964 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + assign(size_type __n, const value_type& __val) + { _M_fill_assign(__n, __val); } +# 981 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template> + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_dispatch(__first, __last, __false_type()); } +# 1005 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + assign(initializer_list __l) + { this->_M_assign_dispatch(__l.begin(), __l.end(), __false_type()); } + + + + allocator_type + get_allocator() const noexcept + { return allocator_type(_Base::_M_get_Node_allocator()); } + + + + + + + [[__nodiscard__]] + iterator + begin() noexcept + { return iterator(this->_M_impl._M_node._M_next); } + + + + + + + [[__nodiscard__]] + const_iterator + begin() const noexcept + { return const_iterator(this->_M_impl._M_node._M_next); } + + + + + + + [[__nodiscard__]] + iterator + end() noexcept + { return iterator(&this->_M_impl._M_node); } + + + + + + + [[__nodiscard__]] + const_iterator + end() const noexcept + { return const_iterator(&this->_M_impl._M_node); } + + + + + + + [[__nodiscard__]] + reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + + + + + + [[__nodiscard__]] + reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + + + + + + + [[__nodiscard__]] + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_impl._M_node._M_next); } + + + + + + + [[__nodiscard__]] + const_iterator + cend() const noexcept + { return const_iterator(&this->_M_impl._M_node); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + + + + + + + [[__nodiscard__]] bool + empty() const noexcept + { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; } + + + [[__nodiscard__]] + size_type + size() const noexcept + { return _M_node_count(); } + + + [[__nodiscard__]] + size_type + max_size() const noexcept + { return _Node_alloc_traits::max_size(_M_get_Node_allocator()); } +# 1168 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + resize(size_type __new_size); +# 1181 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + resize(size_type __new_size, const value_type& __x); +# 1203 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + [[__nodiscard__]] + reference + front() noexcept + { return *begin(); } + + + + + + [[__nodiscard__]] + const_reference + front() const noexcept + { return *begin(); } + + + + + + [[__nodiscard__]] + reference + back() noexcept + { + iterator __tmp = end(); + --__tmp; + return *__tmp; + } + + + + + + [[__nodiscard__]] + const_reference + back() const noexcept + { + const_iterator __tmp = end(); + --__tmp; + return *__tmp; + } +# 1254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + push_front(const value_type& __x) + { this->_M_insert(begin(), __x); } + + + void + push_front(value_type&& __x) + { this->_M_insert(begin(), std::move(__x)); } + + template + + reference + + + + emplace_front(_Args&&... __args) + { + this->_M_insert(begin(), std::forward<_Args>(__args)...); + + return front(); + + } +# 1290 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + pop_front() noexcept + { this->_M_erase(begin()); } +# 1304 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + push_back(const value_type& __x) + { this->_M_insert(end(), __x); } + + + void + push_back(value_type&& __x) + { this->_M_insert(end(), std::move(__x)); } + + template + + reference + + + + emplace_back(_Args&&... __args) + { + this->_M_insert(end(), std::forward<_Args>(__args)...); + + return back(); + + } +# 1339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + pop_back() noexcept + { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); } +# 1356 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template + iterator + emplace(const_iterator __position, _Args&&... __args); +# 1371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + iterator + insert(const_iterator __position, const value_type& __x); +# 1401 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + iterator + insert(const_iterator __position, value_type&& __x) + { return emplace(__position, std::move(__x)); } +# 1420 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + iterator + insert(const_iterator __p, initializer_list __l) + { return this->insert(__p, __l.begin(), __l.end()); } +# 1440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + iterator + insert(const_iterator __position, size_type __n, const value_type& __x); +# 1479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template> + iterator + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last); +# 1523 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + iterator + + erase(const_iterator __position) noexcept; +# 1548 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + iterator + + erase(const_iterator __first, const_iterator __last) noexcept + + + + { + while (__first != __last) + __first = erase(__first); + return __last._M_const_cast(); + } +# 1571 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + swap(list& __x) noexcept + { + __detail::_List_node_base::swap(this->_M_impl._M_node, + __x._M_impl._M_node); + + size_t __xsize = __x._M_get_size(); + __x._M_set_size(this->_M_get_size()); + this->_M_set_size(__xsize); + + _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(), + __x._M_get_Node_allocator()); + } + + + + + + + + void + clear() noexcept + { + _Base::_M_clear(); + _Base::_M_init(); + } +# 1610 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + + splice(const_iterator __position, list&& __x) noexcept + + + + { + if (!__x.empty()) + { + _M_check_equal_allocators(__x); + + this->_M_transfer(__position._M_const_cast(), + __x.begin(), __x.end()); + + this->_M_inc_size(__x._M_get_size()); + __x._M_set_size(0); + } + } + + + void + splice(const_iterator __position, list& __x) noexcept + { splice(__position, std::move(__x)); } +# 1646 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + splice(const_iterator __position, list&& __x, const_iterator __i) noexcept +# 1661 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + { + iterator __j = __i._M_const_cast(); + ++__j; + if (__position == __i || __position == __j) + return; + + if (this != std::__addressof(__x)) + _M_check_equal_allocators(__x); + + this->_M_transfer(__position._M_const_cast(), + __i._M_const_cast(), __j); + + this->_M_inc_size(1); + __x._M_dec_size(1); + } +# 1688 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + splice(const_iterator __position, list& __x, const_iterator __i) noexcept + { splice(__position, std::move(__x), __i); } +# 1707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + splice(const_iterator __position, list&& __x, const_iterator __first, + const_iterator __last) noexcept +# 1727 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + { + if (__first != __last) + { + if (this != std::__addressof(__x)) + _M_check_equal_allocators(__x); + + size_t __n = _S_distance(__first, __last); + this->_M_inc_size(__n); + __x._M_dec_size(__n); + + this->_M_transfer(__position._M_const_cast(), + __first._M_const_cast(), + __last._M_const_cast()); + } + } +# 1757 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + splice(const_iterator __position, list& __x, const_iterator __first, + const_iterator __last) noexcept + { splice(__position, std::move(__x), __first, __last); } + + + private: + + + + + + + typedef void __remove_return_type; + + + public: +# 1787 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + __remove_return_type + remove(const _Tp& __value); +# 1801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template + __remove_return_type + remove_if(_Predicate); +# 1816 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + __remove_return_type + unique(); +# 1831 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template + __remove_return_type + unique(_BinaryPredicate); +# 1847 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + merge(list&& __x); + + void + merge(list& __x) + { merge(std::move(__x)); } +# 1872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template + void + merge(list&& __x, _StrictWeakOrdering __comp); + + template + void + merge(list& __x, _StrictWeakOrdering __comp) + { merge(std::move(__x), __comp); } +# 1891 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + void + reverse() noexcept + { this->_M_impl._M_node._M_reverse(); } + + + + + + + + void + sort(); + + + + + + + + template + void + sort(_StrictWeakOrdering); + + protected: + + + + + + + template + void + _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) + { _M_fill_initialize(static_cast(__n), __x); } + + + template + void + _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { + for (; __first != __last; ++__first) + + emplace_back(*__first); + + + + } + + + + void + _M_fill_initialize(size_type __n, const value_type& __x) + { + for (; __n; --__n) + push_back(__x); + } + + + + void + _M_default_initialize(size_type __n) + { + for (; __n; --__n) + emplace_back(); + } + + + void + _M_default_append(size_type __n); +# 1969 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { _M_fill_assign(__n, __val); } + + + template + void + _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + __false_type); + + + + void + _M_fill_assign(size_type __n, const value_type& __val); + + + + void + _M_transfer(iterator __position, iterator __first, iterator __last) + { __position._M_node->_M_transfer(__first._M_node, __last._M_node); } +# 2001 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template + void + _M_insert(iterator __position, _Args&&... __args) + { + _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); + __tmp->_M_hook(__position._M_node); + this->_M_inc_size(1); + } + + + + void + _M_erase(iterator __position) noexcept + { + this->_M_dec_size(1); + __position._M_node->_M_unhook(); + _Node* __n = static_cast<_Node*>(__position._M_node); + + _Node_alloc_traits::destroy(_M_get_Node_allocator(), __n->_M_valptr()); + + + + + _M_put_node(__n); + } + + + void + _M_check_equal_allocators(const list& __x) noexcept + { + if (_M_get_Node_allocator() != __x._M_get_Node_allocator()) + __builtin_abort(); + } + + + const_iterator + _M_resize_pos(size_type& __new_size) const; + + + void + _M_move_assign(list&& __x, true_type) noexcept + { + this->clear(); + this->_M_move_nodes(std::move(__x)); + std::__alloc_on_move(this->_M_get_Node_allocator(), + __x._M_get_Node_allocator()); + } + + void + _M_move_assign(list&& __x, false_type) + { + if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator()) + _M_move_assign(std::move(__x), true_type{}); + else + + + _M_assign_dispatch(std::make_move_iterator(__x.begin()), + std::make_move_iterator(__x.end()), + __false_type{}); + } + + + + + struct _Finalize_merge + { + explicit + _Finalize_merge(list& __dest, list& __src, const iterator& __src_next) + : _M_dest(__dest), _M_src(__src), _M_next(__src_next) + { } + + ~_Finalize_merge() + { + + + + const size_t __num_unmerged = std::distance(_M_next, _M_src.end()); + const size_t __orig_size = _M_src._M_get_size(); + _M_dest._M_inc_size(__orig_size - __num_unmerged); + _M_src._M_set_size(__num_unmerged); + } + + list& _M_dest; + list& _M_src; + const iterator& _M_next; + + + _Finalize_merge(const _Finalize_merge&) = delete; + + }; + + + + + + }; + + + template::value_type, + typename _Allocator = allocator<_ValT>, + typename = _RequireInputIter<_InputIterator>, + typename = _RequireAllocator<_Allocator>> + list(_InputIterator, _InputIterator, _Allocator = _Allocator()) + -> list<_ValT, _Allocator>; + + +} +# 2120 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { + + if (__x.size() != __y.size()) + return false; + + + typedef typename list<_Tp, _Alloc>::const_iterator const_iterator; + const_iterator __end1 = __x.end(); + const_iterator __end2 = __y.end(); + + const_iterator __i1 = __x.begin(); + const_iterator __i2 = __y.begin(); + while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) + { + ++__i1; + ++__i2; + } + return __i1 == __end1 && __i2 == __end2; + } +# 2177 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 + template + [[__nodiscard__]] + inline bool + operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); } + + + template + [[__nodiscard__]] + inline bool + operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline bool + operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return __y < __x; } + + + template + [[__nodiscard__]] + inline bool + operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return !(__y < __x); } + + + template + [[__nodiscard__]] + inline bool + operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) + { return !(__x < __y); } + + + + template + inline void + swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + + + + + + template + inline ptrdiff_t + __distance(std::_List_iterator<_Tp> __first, + std::_List_iterator<_Tp> __last, + input_iterator_tag __tag) + { + typedef std::_List_const_iterator<_Tp> _CIter; + return std::__distance(_CIter(__first), _CIter(__last), __tag); + } + + template + inline ptrdiff_t + __distance(std::_List_const_iterator<_Tp> __first, + std::_List_const_iterator<_Tp> __last, + input_iterator_tag) + { + typedef __detail::_List_node_header _Sentinel; + std::_List_const_iterator<_Tp> __beyond = __last; + ++__beyond; + const bool __whole = __first == __beyond; + if (__builtin_constant_p (__whole) && __whole) + return static_cast(__last._M_node)->_M_size; + + ptrdiff_t __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + + +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 1 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + void + _List_base<_Tp, _Alloc>:: + _M_clear() noexcept + { + typedef _List_node<_Tp> _Node; + __detail::_List_node_base* __cur = _M_impl._M_node._M_next; + while (__cur != &_M_impl._M_node) + { + _Node* __tmp = static_cast<_Node*>(__cur); + __cur = __tmp->_M_next; + _Tp* __val = __tmp->_M_valptr(); + + _Node_alloc_traits::destroy(_M_get_Node_allocator(), __val); + + + + _M_put_node(__tmp); + } + } + + + template + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + emplace(const_iterator __position, _Args&&... __args) + { + _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); + __tmp->_M_hook(__position._M_const_cast()._M_node); + this->_M_inc_size(1); + return iterator(__tmp); + } + + + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + + insert(const_iterator __position, const value_type& __x) + + + + { + _Node* __tmp = _M_create_node(__x); + __tmp->_M_hook(__position._M_const_cast()._M_node); + this->_M_inc_size(1); + return iterator(__tmp); + } + + + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + insert(const_iterator __position, size_type __n, const value_type& __x) + { + if (__n) + { + list __tmp(__n, __x, get_allocator()); + iterator __it = __tmp.begin(); + splice(__position, __tmp); + return __it; + } + return __position._M_const_cast(); + } + + template + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last) + { + list __tmp(__first, __last, get_allocator()); + if (!__tmp.empty()) + { + iterator __it = __tmp.begin(); + splice(__position, __tmp); + return __it; + } + return __position._M_const_cast(); + } + + + template + typename list<_Tp, _Alloc>::iterator + list<_Tp, _Alloc>:: + + erase(const_iterator __position) noexcept + + + + { + iterator __ret = iterator(__position._M_node->_M_next); + _M_erase(__position._M_const_cast()); + return __ret; + } +# 173 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 3 + template + typename list<_Tp, _Alloc>::const_iterator + list<_Tp, _Alloc>:: + _M_resize_pos(size_type& __new_size) const + { + const_iterator __i; + + const size_type __len = size(); + if (__new_size < __len) + { + if (__new_size <= __len / 2) + { + __i = begin(); + std::advance(__i, __new_size); + } + else + { + __i = end(); + ptrdiff_t __num_erase = __len - __new_size; + std::advance(__i, -__num_erase); + } + __new_size = 0; + return __i; + } + else + __i = end(); + + + + + + __new_size -= __len; + return __i; + } + + + template + void + list<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + size_type __i = 0; + try + { + for (; __i < __n; ++__i) + emplace_back(); + } + catch(...) + { + for (; __i; --__i) + pop_back(); + throw; + } + } + + template + void + list<_Tp, _Alloc>:: + resize(size_type __new_size) + { + const_iterator __i = _M_resize_pos(__new_size); + if (__new_size) + _M_default_append(__new_size); + else + erase(__i, end()); + } + + template + void + list<_Tp, _Alloc>:: + resize(size_type __new_size, const value_type& __x) + { + const_iterator __i = _M_resize_pos(__new_size); + if (__new_size) + insert(end(), __new_size, __x); + else + erase(__i, end()); + } +# 265 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 3 + template + list<_Tp, _Alloc>& + list<_Tp, _Alloc>:: + operator=(const list& __x) + { + if (this != std::__addressof(__x)) + { + + if (_Node_alloc_traits::_S_propagate_on_copy_assign()) + { + auto& __this_alloc = this->_M_get_Node_allocator(); + auto& __that_alloc = __x._M_get_Node_allocator(); + if (!_Node_alloc_traits::_S_always_equal() + && __this_alloc != __that_alloc) + { + + clear(); + } + std::__alloc_on_copy(__this_alloc, __that_alloc); + } + + _M_assign_dispatch(__x.begin(), __x.end(), __false_type()); + } + return *this; + } + + template + void + list<_Tp, _Alloc>:: + _M_fill_assign(size_type __n, const value_type& __val) + { + iterator __i = begin(); + for (; __i != end() && __n > 0; ++__i, --__n) + *__i = __val; + if (__n > 0) + insert(end(), __n, __val); + else + erase(__i, end()); + } + + template + template + void + list<_Tp, _Alloc>:: + _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2, + __false_type) + { + iterator __first1 = begin(); + iterator __last1 = end(); + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + *__first1 = *__first2; + if (__first2 == __last2) + erase(__first1, __last1); + else + insert(__last1, __first2, __last2); + } + + + + + + + + template + typename list<_Tp, _Alloc>::__remove_return_type + list<_Tp, _Alloc>:: + remove(const value_type& __value) + { + + + + list __to_destroy(get_allocator()); + iterator __first = begin(); + iterator __last = end(); + while (__first != __last) + { + iterator __next = __first; + ++__next; + if (*__first == __value) + { + + + + __to_destroy.splice(__to_destroy.begin(), *this, __first); + + + + } + + __first = __next; + } + + + + + return ; + + } + + template + typename list<_Tp, _Alloc>::__remove_return_type + list<_Tp, _Alloc>:: + unique() + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) + return ; + + + + list __to_destroy(get_allocator()); + iterator __next = __first; + while (++__next != __last) + { + if (*__first == *__next) + { + __to_destroy.splice(__to_destroy.begin(), *this, __next); + + + + } + else + __first = __next; + __next = __first; + } + + + + + return ; + + } + + template + void + list<_Tp, _Alloc>:: + + merge(list&& __x) + + + + { + + + if (this != std::__addressof(__x)) + { + _M_check_equal_allocators(__x); + + iterator __first1 = begin(); + iterator __last1 = end(); + iterator __first2 = __x.begin(); + iterator __last2 = __x.end(); + + const _Finalize_merge __fin(*this, __x, __first2); + + while (__first1 != __last1 && __first2 != __last2) + if (*__first2 < *__first1) + { + iterator __next = __first2; + _M_transfer(__first1, __first2, ++__next); + __first2 = __next; + } + else + ++__first1; + if (__first2 != __last2) + { + _M_transfer(__last1, __first2, __last2); + __first2 = __last2; + } + } + } + + template + template + void + list<_Tp, _Alloc>:: + + merge(list&& __x, _StrictWeakOrdering __comp) + + + + { + + + if (this != std::__addressof(__x)) + { + _M_check_equal_allocators(__x); + + iterator __first1 = begin(); + iterator __last1 = end(); + iterator __first2 = __x.begin(); + iterator __last2 = __x.end(); + + const _Finalize_merge __fin(*this, __x, __first2); + + while (__first1 != __last1 && __first2 != __last2) + if (__comp(*__first2, *__first1)) + { + iterator __next = __first2; + _M_transfer(__first1, __first2, ++__next); + __first2 = __next; + } + else + ++__first1; + if (__first2 != __last2) + { + _M_transfer(__last1, __first2, __last2); + __first2 = __last2; + } + } + } + + template + void + list<_Tp, _Alloc>:: + sort() + { + + if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node + && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) + { + using __detail::_Scratch_list; +# 497 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 3 + _Scratch_list __carry; + _Scratch_list __tmp[64]; + _Scratch_list* __fill = __tmp; + _Scratch_list* __counter; + + _Scratch_list::_Ptr_cmp __ptr_comp; + + try + { + do + { + __carry._M_take_one(begin()._M_node); + + for(__counter = __tmp; + __counter != __fill && !__counter->empty(); + ++__counter) + { + + __counter->merge(__carry, __ptr_comp); + __carry.swap(*__counter); + } + __carry.swap(*__counter); + if (__counter == __fill) + ++__fill; + } + while ( !empty() ); + + for (__counter = __tmp + 1; __counter != __fill; ++__counter) + __counter->merge(__counter[-1], __ptr_comp); + __fill[-1].swap(this->_M_impl._M_node); + } + catch(...) + { + + __carry._M_put_all(end()._M_node); + for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i) + __tmp[__i]._M_put_all(end()._M_node); + throw; + } + } + } + + template + template + typename list<_Tp, _Alloc>::__remove_return_type + list<_Tp, _Alloc>:: + remove_if(_Predicate __pred) + { + + + + list __to_destroy(get_allocator()); + iterator __first = begin(); + iterator __last = end(); + while (__first != __last) + { + iterator __next = __first; + ++__next; + if (__pred(*__first)) + { + __to_destroy.splice(__to_destroy.begin(), *this, __first); + + + + } + __first = __next; + } + + + + + return ; + + } + + template + template + typename list<_Tp, _Alloc>::__remove_return_type + list<_Tp, _Alloc>:: + unique(_BinaryPredicate __binary_pred) + { + iterator __first = begin(); + iterator __last = end(); + if (__first == __last) + return ; + + + + list __to_destroy(get_allocator()); + iterator __next = __first; + while (++__next != __last) + { + if (__binary_pred(*__first, *__next)) + { + __to_destroy.splice(__to_destroy.begin(), *this, __next); + + + + } + else + __first = __next; + __next = __first; + } + + + + + return ; + + } + + + + template + template + void + list<_Tp, _Alloc>:: + sort(_StrictWeakOrdering __comp) + { + + if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node + && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) + { + using __detail::_Scratch_list; + _Scratch_list __carry; + _Scratch_list __tmp[64]; + _Scratch_list* __fill = __tmp; + _Scratch_list* __counter; + + _Scratch_list::_Ptr_cmp __ptr_comp + = { __comp }; + + try + { + do + { + __carry._M_take_one(begin()._M_node); + + for(__counter = __tmp; + __counter != __fill && !__counter->empty(); + ++__counter) + { + + __counter->merge(__carry, __ptr_comp); + __carry.swap(*__counter); + } + __carry.swap(*__counter); + if (__counter == __fill) + ++__fill; + } + while ( !empty() ); + + for (__counter = __tmp + 1; __counter != __fill; ++__counter) + __counter->merge(__counter[-1], __ptr_comp); + __fill[-1].swap(this->_M_impl._M_node); + } + catch(...) + { + + __carry._M_put_all(end()._M_node); + for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i) + __tmp[__i]._M_put_all(end()._M_node); + throw; + } + } + } + + + +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 1 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 + + + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 +# 35 "/usr/lib/clang/16/include/stddef.h" 3 +typedef long int ptrdiff_t; +# 46 "/usr/lib/clang/16/include/stddef.h" 3 +typedef long unsigned int size_t; +# 109 "/usr/lib/clang/16/include/stddef.h" 3 +# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 +# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 +typedef struct { + long long __clang_max_align_nonce1 + __attribute__((__aligned__(__alignof__(long long)))); + long double __clang_max_align_nonce2 + __attribute__((__aligned__(__alignof__(long double)))); +} max_align_t; +# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 +# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 2 3 + +extern "C++" +{ + +namespace std +{ + + using ::max_align_t; +} + + + +namespace std +{ + + + + + enum class byte : unsigned char {}; + + template struct __byte_operand { }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + + + + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; +# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + + template + using __byte_op_t = typename __byte_operand<_IntegerType>::__type; + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType> + operator<<(byte __b, _IntegerType __shift) noexcept + { return (byte)(unsigned char)((unsigned)__b << __shift); } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType> + operator>>(byte __b, _IntegerType __shift) noexcept + { return (byte)(unsigned char)((unsigned)__b >> __shift); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator|(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator&(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator^(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator~(byte __b) noexcept + { return (byte)(unsigned char)~(unsigned)__b; } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType>& + operator<<=(byte& __b, _IntegerType __shift) noexcept + { return __b = __b << __shift; } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType>& + operator>>=(byte& __b, _IntegerType __shift) noexcept + { return __b = __b >> __shift; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator|=(byte& __l, byte __r) noexcept + { return __l = __l | __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator&=(byte& __l, byte __r) noexcept + { return __l = __l & __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator^=(byte& __l, byte __r) noexcept + { return __l = __l ^ __r; } + + template + [[nodiscard,__gnu__::__always_inline__]] + constexpr _IntegerType + to_integer(__byte_op_t<_IntegerType> __b) noexcept + { return _IntegerType(__b); } + + +} + +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + struct __erased_type { }; + + + + + template + using __is_erased_or_convertible + = __or_, is_same<_Tp, __erased_type>>; + + + struct allocator_arg_t { explicit allocator_arg_t() = default; }; + + inline constexpr allocator_arg_t allocator_arg = + allocator_arg_t(); + + template> + struct __uses_allocator_helper + : false_type { }; + + template + struct __uses_allocator_helper<_Tp, _Alloc, + __void_t> + : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type + { }; + + + template + struct uses_allocator + : __uses_allocator_helper<_Tp, _Alloc>::type + { }; + + struct __uses_alloc_base { }; + + struct __uses_alloc0 : __uses_alloc_base + { + struct _Sink { void operator=(const void*) { } } _M_a; + }; + + template + struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc; + + template + struct __uses_alloc + : __conditional_t< + is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, + __uses_alloc1<_Alloc>, + __uses_alloc2<_Alloc>> + { + + + static_assert(__or_< + is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, + is_constructible<_Tp, _Args..., const _Alloc&>>::value, + "construction with an allocator must be possible" + " if uses_allocator is true"); + }; + + template + struct __uses_alloc + : __uses_alloc0 { }; + + template + using __uses_alloc_t = + __uses_alloc::value, _Tp, _Alloc, _Args...>; + + template + + inline __uses_alloc_t<_Tp, _Alloc, _Args...> + __use_alloc(const _Alloc& __a) + { + __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; + __ret._M_a = std::__addressof(__a); + return __ret; + } + + template + void + __use_alloc(const _Alloc&&) = delete; + + + template + inline constexpr bool uses_allocator_v = + uses_allocator<_Tp, _Alloc>::value; + + + template class _Predicate, + typename _Tp, typename _Alloc, typename... _Args> + struct __is_uses_allocator_predicate + : __conditional_t::value, + __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, + _Predicate<_Tp, _Args..., _Alloc>>, + _Predicate<_Tp, _Args...>> { }; + + template + struct __is_uses_allocator_constructible + : __is_uses_allocator_predicate + { }; + + + template + inline constexpr bool __is_uses_allocator_constructible_v = + __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; + + + template + struct __is_nothrow_uses_allocator_constructible + : __is_uses_allocator_predicate + { }; + + + + template + inline constexpr bool + __is_nothrow_uses_allocator_constructible_v = + __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; + + + template + void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr, + _Args&&... __args) + { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } + + template + void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr, + _Args&&... __args) + { + ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a, + std::forward<_Args>(__args)...); + } + + template + void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr, + _Args&&... __args) + { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); } + + template + void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr, + _Args&&... __args) + { + std::__uses_allocator_construct_impl( + std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr, + std::forward<_Args>(__args)...); + } + + + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + + + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 + template::type> + constexpr _Up&& + __invfwd(typename remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Up&&>(__t); } + + template + constexpr _Res + __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) + { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } + + template + constexpr _Res + __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } + + template + constexpr _Res + __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + { + return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); + } + + template + constexpr _Res + __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) + { return __invfwd<_Tp>(__t).*__f; } + + template + constexpr _Res + __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) + { return (*std::forward<_Tp>(__t)).*__f; } + + + template + constexpr typename __invoke_result<_Callable, _Args...>::type + __invoke(_Callable&& __fn, _Args&&... __args) + noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) + { + using __result = __invoke_result<_Callable, _Args...>; + using __type = typename __result::type; + using __tag = typename __result::__invoke_type; + return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + } + + + + template + constexpr enable_if_t, _Res> + __invoke_r(_Callable&& __fn, _Args&&... __args) + noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) + { + using __result = __invoke_result<_Callable, _Args...>; + using __type = typename __result::type; + using __tag = typename __result::__invoke_type; + if constexpr (is_void_v<_Res>) + std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + else + return std::__invoke_impl<__type>(__tag{}, + std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + } +# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + class tuple; + + template + struct __is_empty_non_tuple : is_empty<_Tp> { }; + + + template + struct __is_empty_non_tuple> : false_type { }; + + + template + using __empty_not_final + = __conditional_t<__is_final(_Tp), false_type, + __is_empty_non_tuple<_Tp>>; + + template::value> + struct _Head_base; + + + template + struct _Head_base<_Idx, _Head, true> + { + constexpr _Head_base() + : _M_head_impl() { } + + constexpr _Head_base(const _Head& __h) + : _M_head_impl(__h) { } + + constexpr _Head_base(const _Head_base&) = default; + constexpr _Head_base(_Head_base&&) = default; + + template + constexpr _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + + + _Head_base(allocator_arg_t, __uses_alloc0) + : _M_head_impl() { } + + template + + _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) + : _M_head_impl(allocator_arg, *__a._M_a) { } + + template + + _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) + : _M_head_impl(*__a._M_a) { } + + template + + _Head_base(__uses_alloc0, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead)) { } + + template + + _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) + { } + + template + + _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } + + static constexpr _Head& + _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } + + static constexpr const _Head& + _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } + + [[__no_unique_address__]] _Head _M_head_impl; + }; +# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + struct _Head_base<_Idx, _Head, false> + { + constexpr _Head_base() + : _M_head_impl() { } + + constexpr _Head_base(const _Head& __h) + : _M_head_impl(__h) { } + + constexpr _Head_base(const _Head_base&) = default; + constexpr _Head_base(_Head_base&&) = default; + + template + constexpr _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + + + _Head_base(allocator_arg_t, __uses_alloc0) + : _M_head_impl() { } + + template + + _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) + : _M_head_impl(allocator_arg, *__a._M_a) { } + + template + + _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) + : _M_head_impl(*__a._M_a) { } + + template + + _Head_base(__uses_alloc0, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead)) { } + + template + + _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) + { } + + template + + _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } + + static constexpr _Head& + _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } + + static constexpr const _Head& + _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } + + _Head _M_head_impl; + }; +# 250 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + struct _Tuple_impl; + + + + + + + template + struct _Tuple_impl<_Idx, _Head, _Tail...> + : public _Tuple_impl<_Idx + 1, _Tail...>, + private _Head_base<_Idx, _Head> + { + template friend struct _Tuple_impl; + + typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; + typedef _Head_base<_Idx, _Head> _Base; + + static constexpr _Head& + _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr const _Head& + _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr _Inherited& + _M_tail(_Tuple_impl& __t) noexcept { return __t; } + + static constexpr const _Inherited& + _M_tail(const _Tuple_impl& __t) noexcept { return __t; } + + constexpr _Tuple_impl() + : _Inherited(), _Base() { } + + explicit constexpr + _Tuple_impl(const _Head& __head, const _Tail&... __tail) + : _Inherited(__tail...), _Base(__head) + { } + + template> + explicit constexpr + _Tuple_impl(_UHead&& __head, _UTail&&... __tail) + : _Inherited(std::forward<_UTail>(__tail)...), + _Base(std::forward<_UHead>(__head)) + { } + + constexpr _Tuple_impl(const _Tuple_impl&) = default; + + + + _Tuple_impl& operator=(const _Tuple_impl&) = delete; + + _Tuple_impl(_Tuple_impl&&) = default; + + template + constexpr + _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) + : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), + _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) + { } + + template + constexpr + _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + : _Inherited(std::move + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), + _Base(std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) + { } +# 338 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a), + _Base(__tag, __use_alloc<_Head>(__a)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Head& __head, const _Tail&... __tail) + : _Inherited(__tag, __a, __tail...), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) + { } + + template> + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _UHead&& __head, _UTail&&... __tail) + : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), + _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(__head)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl& __in) + : _Inherited(__tag, __a, _M_tail(__in)), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl&& __in) + : _Inherited(__tag, __a, std::move(_M_tail(__in))), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + std::forward<_Head>(_M_head(__in))) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl<_Idx, _UHead, _UTails...>& __in) + : _Inherited(__tag, __a, + _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), + _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), + _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + : _Inherited(__tag, __a, std::move + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), + _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) + { } +# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + void + _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) + { + _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); + _M_tail(*this)._M_assign( + _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); + } + + template + + void + _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + { + _M_head(*this) = std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); + _M_tail(*this)._M_assign( + std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); + } +# 466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + protected: + + void + _M_swap(_Tuple_impl& __in) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + _Inherited::_M_swap(_M_tail(__in)); + } +# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + template + struct _Tuple_impl<_Idx, _Head> + : private _Head_base<_Idx, _Head> + { + template friend struct _Tuple_impl; + + typedef _Head_base<_Idx, _Head> _Base; + + static constexpr _Head& + _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr const _Head& + _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + constexpr + _Tuple_impl() + : _Base() { } + + explicit constexpr + _Tuple_impl(const _Head& __head) + : _Base(__head) + { } + + template + explicit constexpr + _Tuple_impl(_UHead&& __head) + : _Base(std::forward<_UHead>(__head)) + { } + + constexpr _Tuple_impl(const _Tuple_impl&) = default; + + + + _Tuple_impl& operator=(const _Tuple_impl&) = delete; + + + + + constexpr + _Tuple_impl(_Tuple_impl&& __in) + noexcept(is_nothrow_move_constructible<_Head>::value) + : _Base(static_cast<_Base&&>(__in)) + { } + + + template + constexpr + _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) + : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) + { } + + template + constexpr + _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) + : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) + { } +# 559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) + : _Base(__tag, __use_alloc<_Head>(__a)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Head& __head) + : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _UHead&& __head) + : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(__head)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl& __in) + : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl&& __in) + : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + std::forward<_Head>(_M_head(__in))) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl<_Idx, _UHead>& __in) + : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), + _Tuple_impl<_Idx, _UHead>::_M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl<_Idx, _UHead>&& __in) + : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) + { } +# 629 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + void + _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) + { + _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); + } + + template + + void + _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) + { + _M_head(*this) + = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); + } +# 663 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + protected: + + void + _M_swap(_Tuple_impl& __in) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + } +# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + + template + struct _TupleConstraints + { + template + using __constructible = __and_...>; + + template + using __convertible = __and_...>; + + + + + template + static constexpr bool __is_implicitly_constructible() + { + return __and_<__constructible<_UTypes...>, + __convertible<_UTypes...> + >::value; + } + + + + + template + static constexpr bool __is_explicitly_constructible() + { + return __and_<__constructible<_UTypes...>, + __not_<__convertible<_UTypes...>> + >::value; + } + + static constexpr bool __is_implicitly_default_constructible() + { + return __and_... + >::value; + } + + static constexpr bool __is_explicitly_default_constructible() + { + return __and_..., + __not_<__and_< + std::__is_implicitly_default_constructible<_Types>...> + >>::value; + } + }; + + + + template + struct _TupleConstraints + { + template + static constexpr bool __is_implicitly_constructible() + { return false; } + + template + static constexpr bool __is_explicitly_constructible() + { return false; } + }; + + + template + class tuple : public _Tuple_impl<0, _Elements...> + { + typedef _Tuple_impl<0, _Elements...> _Inherited; + + template + using _TCC = _TupleConstraints<_Cond, _Elements...>; + + + template + using _ImplicitDefaultCtor = __enable_if_t< + _TCC<_Dummy>::__is_implicitly_default_constructible(), + bool>; + + + template + using _ExplicitDefaultCtor = __enable_if_t< + _TCC<_Dummy>::__is_explicitly_default_constructible(), + bool>; + + + template + using _ImplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), + bool>; + + + template + using _ExplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), + bool>; + + template + static constexpr + __enable_if_t + __assignable() + { return __and_...>::value; } + + + template + static constexpr bool __nothrow_assignable() + { + return + __and_...>::value; + } + + + template + static constexpr bool __nothrow_constructible() + { + return + __and_...>::value; + } + + + template + static constexpr bool __valid_args() + { + return sizeof...(_Elements) == 1 + && !is_same>::value; + } + + + template + static constexpr bool __valid_args() + { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } +# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template> + struct _UseOtherCtor + : false_type + { }; + + + template + struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> + : __or_, is_constructible<_Tp, _Tuple>>::type + { }; + + + template + struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> + : true_type + { }; + + + + + template + static constexpr bool __use_other_ctor() + { return _UseOtherCtor<_Tuple>::value; } +# 856 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + public: + template::value> = true> + constexpr + tuple() + noexcept(__and_...>::value) + : _Inherited() { } + + template::value> = false> + explicit constexpr + tuple() + noexcept(__and_...>::value) + : _Inherited() { } + + template= 1), + _ImplicitCtor<_NotEmpty, const _Elements&...> = true> + constexpr + tuple(const _Elements&... __elements) + noexcept(__nothrow_constructible()) + : _Inherited(__elements...) { } + + template= 1), + _ExplicitCtor<_NotEmpty, const _Elements&...> = false> + explicit constexpr + tuple(const _Elements&... __elements) + noexcept(__nothrow_constructible()) + : _Inherited(__elements...) { } + + template(), + _ImplicitCtor<_Valid, _UElements...> = true> + constexpr + tuple(_UElements&&... __elements) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + template(), + _ExplicitCtor<_Valid, _UElements...> = false> + explicit constexpr + tuple(_UElements&&... __elements) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + constexpr tuple(const tuple&) = default; + + constexpr tuple(tuple&&) = default; + + template&>(), + _ImplicitCtor<_Valid, const _UElements&...> = true> + constexpr + tuple(const tuple<_UElements...>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) + { } + + template&>(), + _ExplicitCtor<_Valid, const _UElements&...> = false> + explicit constexpr + tuple(const tuple<_UElements...>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) + { } + + template&&>(), + _ImplicitCtor<_Valid, _UElements...> = true> + constexpr + tuple(tuple<_UElements...>&& __in) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } + + template&&>(), + _ExplicitCtor<_Valid, _UElements...> = false> + explicit constexpr + tuple(tuple<_UElements...>&& __in) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } +# 968 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template::value> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template= 1), + _ImplicitCtor<_NotEmpty, const _Elements&...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template= 1), + _ExplicitCtor<_NotEmpty, const _Elements&...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template(), + _ImplicitCtor<_Valid, _UElements...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + _UElements&&... __elements) + : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) + { } + + template(), + _ExplicitCtor<_Valid, _UElements...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + _UElements&&... __elements) + : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) + { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) + : _Inherited(__tag, __a, static_cast(__in)) { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) + : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } + + template&>(), + _ImplicitCtor<_Valid, const _UElements&...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template&>(), + _ExplicitCtor<_Valid, const _UElements&...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template&&>(), + _ImplicitCtor<_Valid, _UElements...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_UElements...>&& __in) + : _Inherited(__tag, __a, + static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) + { } + + template&&>(), + _ExplicitCtor<_Valid, _UElements...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_UElements...>&& __in) + : _Inherited(__tag, __a, + static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) + { } +# 1093 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + tuple& + operator=(__conditional_t<__assignable(), + const tuple&, + const __nonesuch&> __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + + tuple& + operator=(__conditional_t<__assignable<_Elements...>(), + tuple&&, + __nonesuch&&> __in) + noexcept(__nothrow_assignable<_Elements...>()) + { + this->_M_assign(std::move(__in)); + return *this; + } + + template + + __enable_if_t<__assignable(), tuple&> + operator=(const tuple<_UElements...>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + template + + __enable_if_t<__assignable<_UElements...>(), tuple&> + operator=(tuple<_UElements...>&& __in) + noexcept(__nothrow_assignable<_UElements...>()) + { + this->_M_assign(std::move(__in)); + return *this; + } +# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + void + swap(tuple& __in) + noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) + { _Inherited::_M_swap(__in); } +# 1192 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + template + tuple(_UTypes...) -> tuple<_UTypes...>; + template + tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; + template + tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; + template + tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; + template + tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; + + + + template<> + class tuple<> + { + public: + + void swap(tuple&) noexcept { } + + + + + + tuple() = default; + + template + + tuple(allocator_arg_t, const _Alloc&) noexcept { } + template + + tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } + }; + + + + template + class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> + { + typedef _Tuple_impl<0, _T1, _T2> _Inherited; + + + template + using _ImplicitDefaultCtor = __enable_if_t< + _TupleConstraints<_Dummy, _U1, _U2>:: + __is_implicitly_default_constructible(), + bool>; + + + template + using _ExplicitDefaultCtor = __enable_if_t< + _TupleConstraints<_Dummy, _U1, _U2>:: + __is_explicitly_default_constructible(), + bool>; + + template + using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; + + + template + using _ImplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), + bool>; + + + template + using _ExplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), + bool>; + + template + static constexpr bool __assignable() + { + return __and_, + is_assignable<_T2&, _U2>>::value; + } + + template + static constexpr bool __nothrow_assignable() + { + return __and_, + is_nothrow_assignable<_T2&, _U2>>::value; + } + + template + static constexpr bool __nothrow_constructible() + { + return __and_, + is_nothrow_constructible<_T2, _U2>>::value; + } + + static constexpr bool __nothrow_default_constructible() + { + return __and_, + is_nothrow_default_constructible<_T2>>::value; + } + + template + static constexpr bool __is_alloc_arg() + { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } +# 1306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + public: + template = true> + constexpr + tuple() + noexcept(__nothrow_default_constructible()) + : _Inherited() { } + + template = false> + explicit constexpr + tuple() + noexcept(__nothrow_default_constructible()) + : _Inherited() { } + + template = true> + constexpr + tuple(const _T1& __a1, const _T2& __a2) + noexcept(__nothrow_constructible()) + : _Inherited(__a1, __a2) { } + + template = false> + explicit constexpr + tuple(const _T1& __a1, const _T2& __a2) + noexcept(__nothrow_constructible()) + : _Inherited(__a1, __a2) { } + + template(), _U1, _U2> = true> + constexpr + tuple(_U1&& __a1, _U2&& __a2) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + template(), _U1, _U2> = false> + explicit constexpr + tuple(_U1&& __a1, _U2&& __a2) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + constexpr tuple(const tuple&) = default; + + constexpr tuple(tuple&&) = default; + + template = true> + constexpr + tuple(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) { } + + template = false> + explicit constexpr + tuple(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) { } + + template = true> + constexpr + tuple(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } + + template = false> + explicit constexpr + tuple(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } +# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template = true> + constexpr + tuple(const pair<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(__in.first, __in.second) { } + + template = false> + explicit constexpr + tuple(const pair<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(__in.first, __in.second) { } + + template = true> + constexpr + tuple(pair<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + template = false> + explicit constexpr + tuple(pair<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } +# 1450 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template::value, _T1, _T2> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) + : _Inherited(__tag, __a, std::forward<_U1>(__a1), + std::forward<_U2>(__a2)) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + _U1&& __a1, _U2&& __a2) + : _Inherited(__tag, __a, std::forward<_U1>(__a1), + std::forward<_U2>(__a2)) { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) + : _Inherited(__tag, __a, static_cast(__in)) { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) + : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) + : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) + { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) + : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) + { } +# 1553 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) + : _Inherited(__tag, __a, std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) + : _Inherited(__tag, __a, std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } +# 1604 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + tuple& + operator=(__conditional_t<__assignable(), + const tuple&, + const __nonesuch&> __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + + tuple& + operator=(__conditional_t<__assignable<_T1, _T2>(), + tuple&&, + __nonesuch&&> __in) + noexcept(__nothrow_assignable<_T1, _T2>()) + { + this->_M_assign(std::move(__in)); + return *this; + } + + template + + __enable_if_t<__assignable(), tuple&> + operator=(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + template + + __enable_if_t<__assignable<_U1, _U2>(), tuple&> + operator=(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_assignable<_U1, _U2>()) + { + this->_M_assign(std::move(__in)); + return *this; + } +# 1683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + __enable_if_t<__assignable(), tuple&> + operator=(const pair<_U1, _U2>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_head(*this) = __in.first; + this->_M_tail(*this)._M_head(*this) = __in.second; + return *this; + } + + template + + __enable_if_t<__assignable<_U1, _U2>(), tuple&> + operator=(pair<_U1, _U2>&& __in) + noexcept(__nothrow_assignable<_U1, _U2>()) + { + this->_M_head(*this) = std::forward<_U1>(__in.first); + this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); + return *this; + } +# 1730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + void + swap(tuple& __in) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { _Inherited::_M_swap(__in); } +# 1744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + inline constexpr size_t tuple_size_v> + = sizeof...(_Types); + + template + inline constexpr size_t tuple_size_v> + = sizeof...(_Types); + + + + template + struct tuple_element<__i, tuple<_Types...>> + { + static_assert(__i < sizeof...(_Types), "tuple index must be in range"); + + using type = typename _Nth_type<__i, _Types...>::type; + }; + + template + constexpr _Head& + __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + template + constexpr const _Head& + __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + + template + __enable_if_t<(__i >= sizeof...(_Types))> + __get_helper(const tuple<_Types...>&) = delete; + + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>& + get(tuple<_Elements...>& __t) noexcept + { return std::__get_helper<__i>(__t); } + + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>& + get(const tuple<_Elements...>& __t) noexcept + { return std::__get_helper<__i>(__t); } + + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>&& + get(tuple<_Elements...>&& __t) noexcept + { + typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; + return std::forward<__element_type>(std::__get_helper<__i>(__t)); + } + + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& + get(const tuple<_Elements...>&& __t) noexcept + { + typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; + return std::forward(std::__get_helper<__i>(__t)); + } + + + + template + constexpr __enable_if_t<(__i >= sizeof...(_Elements))> + get(const tuple<_Elements...>&) = delete; + + + + + + + + template + constexpr _Tp& + get(tuple<_Types...>& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::__get_helper<__idx>(__t); + } + + + template + constexpr _Tp&& + get(tuple<_Types...>&& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::forward<_Tp>(std::__get_helper<__idx>(__t)); + } + + + template + constexpr const _Tp& + get(const tuple<_Types...>& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::__get_helper<__idx>(__t); + } + + + + template + constexpr const _Tp&& + get(const tuple<_Types...>&& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::forward(std::__get_helper<__idx>(__t)); + } + + + + template + struct __tuple_compare + { + static constexpr bool + __eq(const _Tp& __t, const _Up& __u) + { + return bool(std::get<__i>(__t) == std::get<__i>(__u)) + && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); + } + + static constexpr bool + __less(const _Tp& __t, const _Up& __u) + { + return bool(std::get<__i>(__t) < std::get<__i>(__u)) + || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) + && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); + } + }; + + template + struct __tuple_compare<_Tp, _Up, __size, __size> + { + static constexpr bool + __eq(const _Tp&, const _Up&) { return true; } + + static constexpr bool + __less(const _Tp&, const _Up&) { return false; } + }; + + template + constexpr bool + operator==(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) == sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare = __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__eq(__t, __u); + } +# 1945 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + constexpr bool + operator<(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) == sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare = __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__less(__t, __u); + } + + template + constexpr bool + operator!=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t == __u); } + + template + constexpr bool + operator>(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return __u < __t; } + + template + constexpr bool + operator<=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__u < __t); } + + template + constexpr bool + operator>=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t < __u); } + + + + + template + constexpr tuple::__type...> + make_tuple(_Elements&&... __args) + { + typedef tuple::__type...> + __result_type; + return __result_type(std::forward<_Elements>(__args)...); + } + + + + + template + constexpr tuple<_Elements&&...> + forward_as_tuple(_Elements&&... __args) noexcept + { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } + + + + + template struct array; + + template + constexpr _Tp& + get(array<_Tp, _Nm>&) noexcept; + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&&) noexcept; + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>&) noexcept; + + template + constexpr const _Tp&& + get(const array<_Tp, _Nm>&&) noexcept; + + + template + struct __make_tuple_impl; + + template + struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> + : __make_tuple_impl<_Idx + 1, + tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, + _Tuple, _Nm> + { }; + + template + struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> + { + typedef tuple<_Tp...> __type; + }; + + template + struct __do_make_tuple + : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value> + { }; + + + template + struct __make_tuple + : public __do_make_tuple<__remove_cvref_t<_Tuple>> + { }; + + + template + struct __combine_tuples; + + template<> + struct __combine_tuples<> + { + typedef tuple<> __type; + }; + + template + struct __combine_tuples> + { + typedef tuple<_Ts...> __type; + }; + + template + struct __combine_tuples, tuple<_T2s...>, _Rem...> + { + typedef typename __combine_tuples, + _Rem...>::__type __type; + }; + + + template + struct __tuple_cat_result + { + typedef typename __combine_tuples + ::__type...>::__type __type; + }; + + + + template + struct __make_1st_indices; + + template<> + struct __make_1st_indices<> + { + typedef _Index_tuple<> __type; + }; + + template + struct __make_1st_indices<_Tp, _Tpls...> + { + typedef typename _Build_index_tuple::type>::value>::__type __type; + }; + + + + + template + struct __tuple_concater; + + template + struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...> + { + template + static constexpr _Ret + _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) + { + typedef typename __make_1st_indices<_Tpls...>::__type __idx; + typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; + return __next::_S_do(std::forward<_Tpls>(__tps)..., + std::forward<_Us>(__us)..., + std::get<_Is>(std::forward<_Tp>(__tp))...); + } + }; + + template + struct __tuple_concater<_Ret, _Index_tuple<>> + { + template + static constexpr _Ret + _S_do(_Us&&... __us) + { + return _Ret(std::forward<_Us>(__us)...); + } + }; + + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template...>::value>::type> + constexpr auto + tuple_cat(_Tpls&&... __tpls) + -> typename __tuple_cat_result<_Tpls...>::__type + { + typedef typename __tuple_cat_result<_Tpls...>::__type __ret; + typedef typename __make_1st_indices<_Tpls...>::__type __idx; + typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; + return __concater::_S_do(std::forward<_Tpls>(__tpls)...); + } + + + + + template + constexpr tuple<_Elements&...> + tie(_Elements&... __args) noexcept + { return tuple<_Elements&...>(__args...); } + + + template + + inline + + + typename enable_if<__and_<__is_swappable<_Elements>...>::value + >::type + + + + swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 2184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + typename enable_if...>::value>::type + swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; + + + + + + + struct _Swallow_assign + { + template + constexpr const _Swallow_assign& + operator=(const _Tp&) const + { return *this; } + }; +# 2219 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + inline constexpr _Swallow_assign ignore{}; + + + template + struct uses_allocator, _Alloc> : true_type { }; +# 2234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + template + + inline + pair<_T1, _T2>:: + pair(piecewise_construct_t, + tuple<_Args1...> __first, tuple<_Args2...> __second) + : pair(__first, __second, + typename _Build_index_tuple::__type(), + typename _Build_index_tuple::__type()) + { } + + template + template + inline + pair<_T1, _T2>:: + pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) + : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), + second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) + { } + + + + + + + + template class _Trait, typename _Tp, typename _Tuple> + inline constexpr bool __unpack_std_tuple = false; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> + = _Trait<_Tp, _Up...>::value; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> + = _Trait<_Tp, _Up&...>::value; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> + = _Trait<_Tp, const _Up...>::value; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> + = _Trait<_Tp, const _Up&...>::value; + + + + template + constexpr decltype(auto) + __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) + { + return std::__invoke(std::forward<_Fn>(__f), + std::get<_Idx>(std::forward<_Tuple>(__t))...); + } + + template + constexpr decltype(auto) + apply(_Fn&& __f, _Tuple&& __t) + noexcept(__unpack_std_tuple) + { + using _Indices + = make_index_sequence>>; + return std::__apply_impl(std::forward<_Fn>(__f), + std::forward<_Tuple>(__t), + _Indices{}); + } + + + + template + constexpr _Tp + __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) + { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } + + template + constexpr _Tp + make_from_tuple(_Tuple&& __t) + noexcept(__unpack_std_tuple) + { + constexpr size_t __n = tuple_size_v>; + + + + + + + + return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t), + make_index_sequence<__n>{}); + } +# 2345 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 +} +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace pmr +{ + + + + + + + class memory_resource + { + static constexpr size_t _S_max_align = alignof(max_align_t); + + public: + memory_resource() = default; + memory_resource(const memory_resource&) = default; + virtual ~memory_resource(); + + memory_resource& operator=(const memory_resource&) = default; + + [[nodiscard]] + void* + allocate(size_t __bytes, size_t __alignment = _S_max_align) + __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3))) + { return ::operator new(__bytes, do_allocate(__bytes, __alignment)); } + + void + deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align) + __attribute__((__nonnull__)) + { return do_deallocate(__p, __bytes, __alignment); } + + [[nodiscard]] + bool + is_equal(const memory_resource& __other) const noexcept + { return do_is_equal(__other); } + + private: + virtual void* + do_allocate(size_t __bytes, size_t __alignment) = 0; + + virtual void + do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0; + + virtual bool + do_is_equal(const memory_resource& __other) const noexcept = 0; + }; + + [[nodiscard]] + inline bool + operator==(const memory_resource& __a, const memory_resource& __b) noexcept + { return &__a == &__b || __a.is_equal(__b); } + + + [[nodiscard]] + inline bool + operator!=(const memory_resource& __a, const memory_resource& __b) noexcept + { return !(__a == __b); } +# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + class polymorphic_allocator + { + + + template + struct __not_pair { using type = void; }; + + template + struct __not_pair> { }; + + public: + using value_type = _Tp; + + polymorphic_allocator() noexcept + { + extern memory_resource* get_default_resource() noexcept + __attribute__((__returns_nonnull__)); + _M_resource = get_default_resource(); + } + + polymorphic_allocator(memory_resource* __r) noexcept + __attribute__((__nonnull__)) + : _M_resource(__r) + { ; } + + polymorphic_allocator(const polymorphic_allocator& __other) = default; + + template + polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept + : _M_resource(__x.resource()) + { } + + polymorphic_allocator& + operator=(const polymorphic_allocator&) = delete; + + [[nodiscard]] + _Tp* + allocate(size_t __n) + __attribute__((__returns_nonnull__)) + { + if ((__gnu_cxx::__int_traits::__max / sizeof(_Tp)) < __n) + std::__throw_bad_array_new_length(); + return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp), + alignof(_Tp))); + } + + void + deallocate(_Tp* __p, size_t __n) noexcept + __attribute__((__nonnull__)) + { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); } +# 224 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + __attribute__((__nonnull__)) + typename __not_pair<_Tp1>::type + construct(_Tp1* __p, _Args&&... __args) + { + + + using __use_tag + = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>; + if constexpr (is_base_of_v<__uses_alloc0, __use_tag>) + ::new(__p) _Tp1(std::forward<_Args>(__args)...); + else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>) + ::new(__p) _Tp1(allocator_arg, *this, + std::forward<_Args>(__args)...); + else + ::new(__p) _Tp1(std::forward<_Args>(__args)..., *this); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t, + tuple<_Args1...> __x, tuple<_Args2...> __y) + { + auto __x_tag = + __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this); + auto __y_tag = + __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this); + index_sequence_for<_Args1...> __x_i; + index_sequence_for<_Args2...> __y_i; + + ::new(__p) pair<_Tp1, _Tp2>(piecewise_construct, + _S_construct_p(__x_tag, __x_i, __x), + _S_construct_p(__y_tag, __y_i, __y)); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p) + { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y) + { + this->construct(__p, piecewise_construct, + std::forward_as_tuple(std::forward<_Up>(__x)), + std::forward_as_tuple(std::forward<_Vp>(__y))); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, const std::pair<_Up, _Vp>& __pr) + { + this->construct(__p, piecewise_construct, + std::forward_as_tuple(__pr.first), + std::forward_as_tuple(__pr.second)); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr) + { + this->construct(__p, piecewise_construct, + std::forward_as_tuple(std::forward<_Up>(__pr.first)), + std::forward_as_tuple(std::forward<_Vp>(__pr.second))); + } +# 307 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + + __attribute__((__nonnull__)) + void + destroy(_Up* __p) + { __p->~_Up(); } + + polymorphic_allocator + select_on_container_copy_construction() const noexcept + { return polymorphic_allocator(); } + + memory_resource* + resource() const noexcept + __attribute__((__returns_nonnull__)) + { return _M_resource; } + + + + [[nodiscard]] + friend bool + operator==(const polymorphic_allocator& __a, + const polymorphic_allocator& __b) noexcept + { return *__a.resource() == *__b.resource(); } + + + [[nodiscard]] + friend bool + operator!=(const polymorphic_allocator& __a, + const polymorphic_allocator& __b) noexcept + { return !(__a == __b); } + + + private: + + using __uses_alloc1_ = __uses_alloc1; + using __uses_alloc2_ = __uses_alloc2; + + template + static tuple<_Args&&...> + _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t) + { return std::move(__t); } + + template + static tuple + _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>, + tuple<_Args...>& __t) + { + return { + allocator_arg, *__ua._M_a, std::get<_Ind>(std::move(__t))... + }; + } + + template + static tuple<_Args&&..., polymorphic_allocator> + _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>, + tuple<_Args...>& __t) + { return { std::get<_Ind>(std::move(__t))..., *__ua._M_a }; } + + + memory_resource* _M_resource; + }; + + template + [[nodiscard]] + inline bool + operator==(const polymorphic_allocator<_Tp1>& __a, + const polymorphic_allocator<_Tp2>& __b) noexcept + { return *__a.resource() == *__b.resource(); } + + + template + [[nodiscard]] + inline bool + operator!=(const polymorphic_allocator<_Tp1>& __a, + const polymorphic_allocator<_Tp2>& __b) noexcept + { return !(__a == __b); } + + +} + + template struct allocator_traits; + + + template + struct allocator_traits> + { + + using allocator_type = pmr::polymorphic_allocator<_Tp>; + + + using value_type = _Tp; + + + using pointer = _Tp*; + + + using const_pointer = const _Tp*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + + + + using propagate_on_container_copy_assignment = false_type; + using propagate_on_container_move_assignment = false_type; + using propagate_on_container_swap = false_type; + + static allocator_type + select_on_container_copy_construction(const allocator_type&) noexcept + { return allocator_type(); } + + + + using is_always_equal = false_type; + + template + using rebind_alloc = pmr::polymorphic_allocator<_Up>; + + template + using rebind_traits = allocator_traits>; +# 446 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + [[nodiscard]] static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 461 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + [[nodiscard]] static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer) + { return __a.allocate(__n); } +# 473 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + static void + construct(allocator_type& __a, _Up* __p, _Args&&... __args) + { __a.construct(__p, std::forward<_Args>(__args)...); } +# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + static void + destroy(allocator_type&, _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { __p->~_Up(); } + + + + + + static size_type + max_size(const allocator_type&) noexcept + { return size_t(-1) / sizeof(value_type); } + }; + + +} +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace pmr + { + template + using list = std::list<_Tp, polymorphic_allocator<_Tp>>; + } + +} +# 17 "src/core/application.h" 2 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 1 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 1 3 +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace __detail + { + template + inline void + __return_temporary_buffer(_Tp* __p, + size_t __len __attribute__((__unused__))) + { + + + + ::operator delete(__p); + + } + } +# 101 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 + template + [[__deprecated__]] + pair<_Tp*, ptrdiff_t> + get_temporary_buffer(ptrdiff_t __len) noexcept + { + const ptrdiff_t __max = + __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); + if (__len > __max) + __len = __max; + + while (__len > 0) + { + _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), + std::nothrow)); + if (__tmp != 0) + return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); + __len = __len == 1 ? 0 : ((__len + 1) / 2); + } + return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); + } +# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 + template + inline void + return_temporary_buffer(_Tp* __p) + { ::operator delete(__p); } + + + + + + + template + class _Temporary_buffer + { + + + + public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef pointer iterator; + typedef ptrdiff_t size_type; + + protected: + size_type _M_original_len; + size_type _M_len; + pointer _M_buffer; + + public: + + size_type + size() const + { return _M_len; } + + + size_type + requested_size() const + { return _M_original_len; } + + + iterator + begin() + { return _M_buffer; } + + + iterator + end() + { return _M_buffer + _M_len; } + + + + + + _Temporary_buffer(_ForwardIterator __seed, size_type __original_len); + + ~_Temporary_buffer() + { + std::_Destroy(_M_buffer, _M_buffer + _M_len); + std::__detail::__return_temporary_buffer(_M_buffer, _M_len); + } + + private: + + _Temporary_buffer(const _Temporary_buffer&); + + void + operator=(const _Temporary_buffer&); + }; + + + template + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + if (__first == __last) + return; + + _Pointer __cur = __first; + try + { + std::_Construct(std::__addressof(*__first), + std::move(*__seed)); + _Pointer __prev = __cur; + ++__cur; + for(; __cur != __last; ++__cur, ++__prev) + std::_Construct(std::__addressof(*__cur), + std::move(*__prev)); + *__seed = std::move(*__prev); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer, _Pointer, _ForwardIterator) { } + }; +# 247 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 + template + inline void + __uninitialized_construct_buf(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + typedef typename std::iterator_traits<_Pointer>::value_type + _ValueType; + + std::__uninitialized_construct_buf_dispatch< + __has_trivial_constructor(_ValueType)>:: + __ucr(__first, __last, __seed); + } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _Temporary_buffer<_ForwardIterator, _Tp>:: + _Temporary_buffer(_ForwardIterator __seed, size_type __original_len) + : _M_original_len(__original_len), _M_len(0), _M_buffer(0) + { + std::pair __p( + std::get_temporary_buffer(_M_original_len)); + + if (__p.first) + { + try + { + std::__uninitialized_construct_buf(__p.first, __p.first + __p.second, + __seed); + _M_buffer = __p.first; + _M_len = __p.second; + } + catch(...) + { + std::__detail::__return_temporary_buffer(__p.first, __p.second); + throw; + } + } + } +#pragma GCC diagnostic pop + + +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 1 3 +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + constexpr bool + __check_constructible() + { + + + + + + static_assert(is_constructible<_ValueType, _Tp>::value, + "result type must be constructible from input type"); + + return true; + } +# 110 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + + _ForwardIterator + __do_uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + _ForwardIterator __cur = __result; + try + { + for (; __first != __last; ++__first, (void)++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + catch(...) + { + std::_Destroy(__result, __cur); + throw; + } + } + + template + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { return std::__do_uninit_copy(__first, __last, __result); } + }; + + template<> + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { return std::copy(__first, __last, __result); } + }; +# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + typedef typename iterator_traits<_InputIterator>::value_type + _ValueType1; + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType2; + + + + + const bool __can_memmove = __is_trivial(_ValueType1); + + + + + using _From = decltype(*__first); + + const bool __assignable + = __is_trivial(_ValueType2) && __is_assignable(_ValueType2&, _From) && std::__check_constructible<_ValueType2, _From>(); + + return std::__uninitialized_copy<__can_memmove && __assignable>:: + __uninit_copy(__first, __last, __result); + } + + + + template + void + __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + _ForwardIterator __cur = __first; + try + { + for (; __cur != __last; ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + + template + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { std::__do_uninit_fill(__first, __last, __x); } + }; + + template<> + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { std::fill(__first, __last, __x); } + }; +# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline void + uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + const bool __can_fill + = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>(); + + std::__uninitialized_fill<__can_fill>:: + __uninit_fill(__first, __last, __x); + } + + + + template + + _ForwardIterator + __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) + { + _ForwardIterator __cur = __first; + try + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + + template + struct __uninitialized_fill_n + { + template + static _ForwardIterator + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { return std::__do_uninit_fill_n(__first, __n, __x); } + }; + + template<> + struct __uninitialized_fill_n + { + template + static _ForwardIterator + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { return std::fill_n(__first, __n, __x); } + }; +# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + const bool __can_fill + = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>() + + + + && __is_integer<_Size>::__value; + + return __uninitialized_fill_n<__can_fill>:: + __uninit_fill_n(__first, __n, __x); + } +# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + + _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + { + _ForwardIterator __cur = __result; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __first != __last; ++__first, (void)++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), *__first); + return __cur; + } + catch(...) + { + std::_Destroy(__result, __cur, __alloc); + throw; + } + } + + + template + + inline _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, allocator<_Tp>&) + { + + + + + return std::uninitialized_copy(__first, __last, __result); + } + + + template + + inline _ForwardIterator + __uninitialized_move_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + { + return std::__uninitialized_copy_a(std::make_move_iterator(__first), + std::make_move_iterator(__last), + __result, __alloc); + } + + template + + inline _ForwardIterator + __uninitialized_move_if_noexcept_a(_InputIterator __first, + _InputIterator __last, + _ForwardIterator __result, + _Allocator& __alloc) + { + return std::__uninitialized_copy_a + (std::__make_move_if_noexcept_iterator(__first), + std::__make_move_if_noexcept_iterator(__last), __result, __alloc); + } + + template + + void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur != __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + template + + inline void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x, allocator<_Tp2>&) + { + + + + + std::uninitialized_fill(__first, __last, __x); + } + + + template + + _ForwardIterator + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, (void) ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + template + + inline _ForwardIterator + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, allocator<_Tp2>&) + { + + + + + return std::uninitialized_fill_n(__first, __n, __x); + } +# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + __uninitialized_copy_move(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _ForwardIterator __result, + _Allocator& __alloc) + { + _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, + __result, + __alloc); + try + { + return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); + } + catch(...) + { + std::_Destroy(__result, __mid, __alloc); + throw; + } + } + + + + + + template + inline _ForwardIterator + __uninitialized_move_copy(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _ForwardIterator __result, + _Allocator& __alloc) + { + _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, + __result, + __alloc); + try + { + return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); + } + catch(...) + { + std::_Destroy(__result, __mid, __alloc); + throw; + } + } + + + + + template + inline _ForwardIterator + __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, + const _Tp& __x, _InputIterator __first, + _InputIterator __last, _Allocator& __alloc) + { + std::__uninitialized_fill_a(__result, __mid, __x, __alloc); + try + { + return std::__uninitialized_move_a(__first, __last, __mid, __alloc); + } + catch(...) + { + std::_Destroy(__result, __mid, __alloc); + throw; + } + } + + + + + template + inline void + __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, + _ForwardIterator __last2, const _Tp& __x, + _Allocator& __alloc) + { + _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, + __first2, + __alloc); + try + { + std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); + } + catch(...) + { + std::_Destroy(__first2, __mid2, __alloc); + throw; + } + } +# 592 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + _ForwardIterator __cur = __first; + try + { + for (; __cur != __last; ++__cur) + std::_Construct(std::__addressof(*__cur)); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + if (__first == __last) + return; + + typename iterator_traits<_ForwardIterator>::value_type* __val + = std::__addressof(*__first); + std::_Construct(__val); + if (++__first != __last) + std::fill(__first, __last, *__val); + } + }; + + template + struct __uninitialized_default_n_1 + { + template + + static _ForwardIterator + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur = __first; + try + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct(std::__addressof(*__cur)); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_n_1 + { + template + + static _ForwardIterator + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + if (__n > 0) + { + typename iterator_traits<_ForwardIterator>::value_type* __val + = std::__addressof(*__first); + std::_Construct(__val); + ++__first; + __first = std::fill_n(__first, __n - 1, *__val); + } + return __first; + } + }; + + + + template + inline void + __uninitialized_default(_ForwardIterator __first, + _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + const bool __assignable = is_copy_assignable<_ValueType>::value; + + std::__uninitialized_default_1<__is_trivial(_ValueType) + && __assignable>:: + __uninit_default(__first, __last); + } + + + + template + + inline _ForwardIterator + __uninitialized_default_n(_ForwardIterator __first, _Size __n) + { + + + + + + + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + constexpr bool __can_fill + = __and_, is_copy_assignable<_ValueType>>::value; + + return __uninitialized_default_n_1<__is_trivial(_ValueType) + && __can_fill>:: + __uninit_default_n(__first, __n); + } + + + + + + template + void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur != __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + template + inline void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + allocator<_Tp>&) + { std::__uninitialized_default(__first, __last); } + + + + + + template + _ForwardIterator + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, (void) ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + + + template + + inline _ForwardIterator + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + allocator<_Tp>&) + { return std::__uninitialized_default_n(__first, __n); } + + + template + struct __uninitialized_default_novalue_1 + { + template + static void + __uninit_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + _ForwardIterator __cur = __first; + try + { + for (; __cur != __last; ++__cur) + std::_Construct_novalue(std::__addressof(*__cur)); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_novalue_1 + { + template + static void + __uninit_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + } + }; + + template + struct __uninitialized_default_novalue_n_1 + { + template + static _ForwardIterator + __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur = __first; + try + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct_novalue(std::__addressof(*__cur)); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_novalue_n_1 + { + template + static _ForwardIterator + __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) + { return std::next(__first, __n); } + }; + + + + template + inline void + __uninitialized_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::__uninitialized_default_novalue_1< + is_trivially_default_constructible<_ValueType>::value>:: + __uninit_default_novalue(__first, __last); + } + + + + template + inline _ForwardIterator + __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + return __uninitialized_default_novalue_n_1< + is_trivially_default_constructible<_ValueType>::value>:: + __uninit_default_novalue_n(__first, __n); + } + + template + _ForwardIterator + __uninitialized_copy_n(_InputIterator __first, _Size __n, + _ForwardIterator __result, input_iterator_tag) + { + _ForwardIterator __cur = __result; + try + { + for (; __n > 0; --__n, (void) ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + catch(...) + { + std::_Destroy(__result, __cur); + throw; + } + } + + template + inline _ForwardIterator + __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, + _ForwardIterator __result, + random_access_iterator_tag) + { return std::uninitialized_copy(__first, __first + __n, __result); } + + template + pair<_InputIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, + _ForwardIterator __result, input_iterator_tag) + { + _ForwardIterator __cur = __result; + try + { + for (; __n > 0; --__n, (void) ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return {__first, __cur}; + } + catch(...) + { + std::_Destroy(__result, __cur); + throw; + } + } + + template + inline pair<_RandomAccessIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, + _ForwardIterator __result, + random_access_iterator_tag) + { + auto __second_res = uninitialized_copy(__first, __first + __n, __result); + auto __first_res = std::next(__first, __n); + return {__first_res, __second_res}; + } +# 947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_copy_n(_InputIterator __first, _Size __n, + _ForwardIterator __result) + { return std::__uninitialized_copy_n(__first, __n, __result, + std::__iterator_category(__first)); } + + + template + inline pair<_InputIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, + _ForwardIterator __result) + { + return + std::__uninitialized_copy_n_pair(__first, __n, __result, + std::__iterator_category(__first)); + } +# 976 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline void + uninitialized_default_construct(_ForwardIterator __first, + _ForwardIterator __last) + { + __uninitialized_default_novalue(__first, __last); + } +# 991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) + { + return __uninitialized_default_novalue_n(__first, __count); + } + + + + + + + + template + inline void + uninitialized_value_construct(_ForwardIterator __first, + _ForwardIterator __last) + { + return __uninitialized_default(__first, __last); + } +# 1019 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) + { + return __uninitialized_default_n(__first, __count); + } +# 1034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_move(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + return std::uninitialized_copy + (std::make_move_iterator(__first), + std::make_move_iterator(__last), __result); + } +# 1052 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline pair<_InputIterator, _ForwardIterator> + uninitialized_move_n(_InputIterator __first, _Size __count, + _ForwardIterator __result) + { + auto __res = std::__uninitialized_copy_n_pair + (std::make_move_iterator(__first), + __count, __result); + return {__res.first.base(), __res.second}; + } + + + + + + template + + inline void + __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig, + _Allocator& __alloc) + noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, + __dest, std::move(*__orig))) + && noexcept(std::allocator_traits<_Allocator>::destroy( + __alloc, std::__addressof(*__orig)))) + { + typedef std::allocator_traits<_Allocator> __traits; + __traits::construct(__alloc, __dest, std::move(*__orig)); + __traits::destroy(__alloc, std::__addressof(*__orig)); + } + + + + template + struct __is_bitwise_relocatable + : is_trivial<_Tp> { }; + + template + + inline _ForwardIterator + __relocate_a_1(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), + std::addressof(*__first), + __alloc))) + { + typedef typename iterator_traits<_InputIterator>::value_type + _ValueType; + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType2; + static_assert(std::is_same<_ValueType, _ValueType2>::value, + "relocation is only possible for values of the same type"); + _ForwardIterator __cur = __result; + for (; __first != __last; ++__first, (void)++__cur) + std::__relocate_object_a(std::__addressof(*__cur), + std::__addressof(*__first), __alloc); + return __cur; + } + + + template + + inline __enable_if_t::value, _Tp*> + __relocate_a_1(_Tp* __first, _Tp* __last, + _Tp* __result, + [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept + { + ptrdiff_t __count = __last - __first; + if (__count > 0) + { +# 1132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + __builtin_memmove(__result, __first, __count * sizeof(_Tp)); + } + return __result + __count; + } + + + template + + inline _ForwardIterator + __relocate_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result), __alloc))) + { + return std::__relocate_a_1(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result), __alloc); + } + + + + + + + +} +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_raw_storage_iter.h" 1 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_raw_storage_iter.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + + + template + class [[__deprecated__]] raw_storage_iterator + : public iterator + { + protected: + _OutputIterator _M_iter; + + public: + explicit + raw_storage_iterator(_OutputIterator __x) + : _M_iter(__x) {} + + raw_storage_iterator& + operator*() { return *this; } + + raw_storage_iterator& + operator=(const _Tp& __element) + { + std::_Construct(std::__addressof(*_M_iter), __element); + return *this; + } + + + + + raw_storage_iterator& + operator=(_Tp&& __element) + { + std::_Construct(std::__addressof(*_M_iter), std::move(__element)); + return *this; + } + + + raw_storage_iterator& + operator++() + { + ++_M_iter; + return *this; + } + + raw_storage_iterator + operator++(int) + { + raw_storage_iterator __tmp = *this; + ++_M_iter; + return __tmp; + } + + + + _OutputIterator base() const { return _M_iter; } + }; +#pragma GCC diagnostic pop + + +} +# 71 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 +# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 +# 52 "/usr/lib/clang/16/include/stdint.h" 3 +# 1 "/usr/include/stdint.h" 1 3 4 +# 26 "/usr/include/stdint.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 28 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/wchar.h" 1 3 4 +# 29 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 30 "/usr/include/stdint.h" 2 3 4 + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 35 "/usr/include/stdint.h" 2 3 4 + + +# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-uintn.h" 3 4 +typedef __uint8_t uint8_t; +typedef __uint16_t uint16_t; +typedef __uint32_t uint32_t; +typedef __uint64_t uint64_t; +# 38 "/usr/include/stdint.h" 2 3 4 + + + + + +typedef __int_least8_t int_least8_t; +typedef __int_least16_t int_least16_t; +typedef __int_least32_t int_least32_t; +typedef __int_least64_t int_least64_t; + + +typedef __uint_least8_t uint_least8_t; +typedef __uint_least16_t uint_least16_t; +typedef __uint_least32_t uint_least32_t; +typedef __uint_least64_t uint_least64_t; + + + + + +typedef signed char int_fast8_t; + +typedef long int int_fast16_t; +typedef long int int_fast32_t; +typedef long int int_fast64_t; +# 71 "/usr/include/stdint.h" 3 4 +typedef unsigned char uint_fast8_t; + +typedef unsigned long int uint_fast16_t; +typedef unsigned long int uint_fast32_t; +typedef unsigned long int uint_fast64_t; +# 87 "/usr/include/stdint.h" 3 4 +typedef long int intptr_t; + + +typedef unsigned long int uintptr_t; +# 101 "/usr/include/stdint.h" 3 4 +typedef __intmax_t intmax_t; +typedef __uintmax_t uintmax_t; +# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 +inline void* +align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept +{ + if (__space < __size) + return nullptr; + const auto __intptr = reinterpret_cast(__ptr); + const auto __aligned = (__intptr - 1u + __align) & -__align; + const auto __diff = __aligned - __intptr; + if (__diff > (__space - __size)) + return nullptr; + else + { + __space -= __diff; + return __ptr = reinterpret_cast(__aligned); + } +} +# 109 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 +} +# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct unary_function + { + + typedef _Arg argument_type; + + + typedef _Result result_type; + } __attribute__ ((__deprecated__)); + + + + + + template + struct binary_function + { + + typedef _Arg1 first_argument_type; + + + typedef _Arg2 second_argument_type; + + + typedef _Result result_type; + } __attribute__ ((__deprecated__)); +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + struct __is_transparent; + + template + struct plus; + + template + struct minus; + + template + struct multiplies; + + template + struct divides; + + template + struct modulus; + + template + struct negate; + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct plus : public binary_function<_Tp, _Tp, _Tp> + { + + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x + __y; } + }; + + + template + struct minus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x - __y; } + }; + + + template + struct multiplies : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x * __y; } + }; + + + template + struct divides : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x / __y; } + }; + + + template + struct modulus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x % __y; } + }; + + + template + struct negate : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return -__x; } + }; +#pragma GCC diagnostic pop + + + + + + template<> + struct plus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct minus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct multiplies + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct divides + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct modulus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct negate + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(-std::forward<_Tp>(__t))) + -> decltype(-std::forward<_Tp>(__t)) + { return -std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; +# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct equal_to; + + template + struct not_equal_to; + + template + struct greater; + + template + struct less; + + template + struct greater_equal; + + template + struct less_equal; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x == __y; } + }; + + + template + struct not_equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x != __y; } + }; + + + template + struct greater : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x > __y; } + }; + + + template + struct less : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x < __y; } + }; + + + template + struct greater_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x >= __y; } + }; + + + template + struct less_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x <= __y; } + }; + + + template + struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x > __y; + + return (long unsigned int)__x > (long unsigned int)__y; + } + }; + + + template + struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x < __y; + + return (long unsigned int)__x < (long unsigned int)__y; + } + }; + + + template + struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x >= __y; + + return (long unsigned int)__x >= (long unsigned int)__y; + } + }; + + + template + struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x <= __y; + + return (long unsigned int)__x <= (long unsigned int)__y; + } + }; +#pragma GCC diagnostic pop + + + + template<> + struct equal_to + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct not_equal_to + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct greater + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return greater>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return greater{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct less + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return less>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return less{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct greater_equal + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return greater_equal>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return greater_equal{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct less_equal + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return less_equal>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return less_equal{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; +# 781 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct logical_and; + + template + struct logical_or; + + template + struct logical_not; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct logical_and : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x && __y; } + }; + + + template + struct logical_or : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x || __y; } + }; + + + template + struct logical_not : public unary_function<_Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x) const + { return !__x; } + }; +#pragma GCC diagnostic pop + + + + template<> + struct logical_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(!std::forward<_Tp>(__t))) + -> decltype(!std::forward<_Tp>(__t)) + { return !std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; + + + + + template + struct bit_and; + + template + struct bit_or; + + template + struct bit_xor; + + template + struct bit_not; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + template + struct bit_and : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x & __y; } + }; + + template + struct bit_or : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x | __y; } + }; + + template + struct bit_xor : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x ^ __y; } + }; + + template + struct bit_not : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return ~__x; } + }; +#pragma GCC diagnostic pop + + + template <> + struct bit_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_xor + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(~std::forward<_Tp>(__t))) + -> decltype(~std::forward<_Tp>(__t)) + { return ~std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class [[__deprecated__]] unary_negate + : public unary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + unary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::argument_type& __x) const + { return !_M_pred(__x); } + }; + + + template + __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) + constexpr + inline unary_negate<_Predicate> + not1(const _Predicate& __pred) + { return unary_negate<_Predicate>(__pred); } + + + template + class [[__deprecated__]] binary_negate + : public binary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + binary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::first_argument_type& __x, + const typename _Predicate::second_argument_type& __y) const + { return !_M_pred(__x, __y); } + }; + + + template + __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) + constexpr + inline binary_negate<_Predicate> + not2(const _Predicate& __pred) + { return binary_negate<_Predicate>(__pred); } +# 1104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class pointer_to_unary_function : public unary_function<_Arg, _Result> + { + protected: + _Result (*_M_ptr)(_Arg); + + public: + pointer_to_unary_function() { } + + explicit + pointer_to_unary_function(_Result (*__x)(_Arg)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg __x) const + { return _M_ptr(__x); } + } __attribute__ ((__deprecated__)); + + + template + __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) + inline pointer_to_unary_function<_Arg, _Result> + ptr_fun(_Result (*__x)(_Arg)) + { return pointer_to_unary_function<_Arg, _Result>(__x); } + + + template + class pointer_to_binary_function + : public binary_function<_Arg1, _Arg2, _Result> + { + protected: + _Result (*_M_ptr)(_Arg1, _Arg2); + + public: + pointer_to_binary_function() { } + + explicit + pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg1 __x, _Arg2 __y) const + { return _M_ptr(__x, __y); } + } __attribute__ ((__deprecated__)); + + + template + __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) + inline pointer_to_binary_function<_Arg1, _Arg2, _Result> + ptr_fun(_Result (*__x)(_Arg1, _Arg2)) + { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } + + + template + struct _Identity + : public unary_function<_Tp, _Tp> + { + _Tp& + operator()(_Tp& __x) const + { return __x; } + + const _Tp& + operator()(const _Tp& __x) const + { return __x; } + }; + + + template struct _Identity : _Identity<_Tp> { }; + + template + struct _Select1st + : public unary_function<_Pair, typename _Pair::first_type> + { + typename _Pair::first_type& + operator()(_Pair& __x) const + { return __x.first; } + + const typename _Pair::first_type& + operator()(const _Pair& __x) const + { return __x.first; } + + + template + typename _Pair2::first_type& + operator()(_Pair2& __x) const + { return __x.first; } + + template + const typename _Pair2::first_type& + operator()(const _Pair2& __x) const + { return __x.first; } + + }; + + template + struct _Select2nd + : public unary_function<_Pair, typename _Pair::second_type> + { + typename _Pair::second_type& + operator()(_Pair& __x) const + { return __x.second; } + + const typename _Pair::second_type& + operator()(const _Pair& __x) const + { return __x.second; } + }; +# 1231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class mem_fun_t : public unary_function<_Tp*, _Ret> + { + public: + explicit + mem_fun_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun_t : public unary_function + { + public: + explicit + const_mem_fun_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + mem_fun_ref_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> + { + public: + explicit + mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun1_t : public binary_function + { + public: + explicit + const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + } __attribute__ ((__deprecated__)); + + + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)()) + { return mem_fun_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)() const) + { return const_mem_fun_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)()) + { return mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)() const) + { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } +#pragma GCC diagnostic pop + + + + + template> + struct __has_is_transparent + { }; + + template + struct __has_is_transparent<_Func, _SfinaeType, + __void_t> + { typedef void type; }; + + template + using __has_is_transparent_t + = typename __has_is_transparent<_Func, _SfinaeType>::type; + + + +} + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 1 3 +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 + template + class binder1st + : public unary_function + { + protected: + _Operation op; + typename _Operation::first_argument_type value; + + public: + binder1st(const _Operation& __x, + const typename _Operation::first_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + + + + typename _Operation::result_type + operator()(typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); + + + template + __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) + inline binder1st<_Operation> + bind1st(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::first_argument_type _Arg1_type; + return binder1st<_Operation>(__fn, _Arg1_type(__x)); + } + + + template + class binder2nd + : public unary_function + { + protected: + _Operation op; + typename _Operation::second_argument_type value; + + public: + binder2nd(const _Operation& __x, + const typename _Operation::second_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + + + + typename _Operation::result_type + operator()(typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); + + + template + __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) + inline binder2nd<_Operation> + bind2nd(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::second_argument_type _Arg2_type; + return binder2nd<_Operation>(__fn, _Arg2_type(__x)); + } + + + +} + +#pragma GCC diagnostic pop +# 1439 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 2 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hash_bytes.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template + struct __hash_base + { + typedef _Result result_type [[__deprecated__]]; + typedef _Arg argument_type [[__deprecated__]]; + }; + + + template + struct hash; + + template + struct __poison_hash + { + static constexpr bool __enable_hash_call = false; + private: + + __poison_hash(__poison_hash&&); + ~__poison_hash(); + }; + + template + struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> + { + static constexpr bool __enable_hash_call = true; + }; + + + template::value> + struct __hash_enum + { + private: + + __hash_enum(__hash_enum&&); + ~__hash_enum(); + }; + + + template + struct __hash_enum<_Tp, true> : public __hash_base + { + size_t + operator()(_Tp __val) const noexcept + { + using __type = typename underlying_type<_Tp>::type; + return hash<__type>{}(static_cast<__type>(__val)); + } + }; + + + + template + struct hash : __hash_enum<_Tp> + { }; + + + template + struct hash<_Tp*> : public __hash_base + { + size_t + operator()(_Tp* __p) const noexcept + { return reinterpret_cast(__p); } + }; +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; + + + + + + + + template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; +# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + struct _Hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(0xc70f6907UL)) + { return _Hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + + struct _Fnv_hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(2166136261UL)) + { return _Fnv_hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(float __val) const noexcept + { + + return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(double __val) const noexcept + { + + return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash + : public __hash_base + { + __attribute__ ((__pure__)) size_t + operator()(long double __val) const noexcept; + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(nullptr_t) const noexcept + { return 0; } + }; +# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template + struct __is_fast_hash : public std::true_type + { }; + + template<> + struct __is_fast_hash> : public std::false_type + { }; + + +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template class auto_ptr; +#pragma GCC diagnostic pop + + + + + + + + template + struct default_delete + { + + constexpr default_delete() noexcept = default; + + + + + + + template>> + + default_delete(const default_delete<_Up>&) noexcept { } + + + + void + operator()(_Tp* __ptr) const + { + static_assert(!is_void<_Tp>::value, + "can't delete pointer to incomplete type"); + static_assert(sizeof(_Tp)>0, + "can't delete pointer to incomplete type"); + delete __ptr; + } + }; +# 111 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + struct default_delete<_Tp[]> + { + public: + + constexpr default_delete() noexcept = default; +# 127 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template>> + + default_delete(const default_delete<_Up[]>&) noexcept { } + + + template + + typename enable_if::value>::type + operator()(_Up* __ptr) const + { + static_assert(sizeof(_Tp)>0, + "can't delete pointer to incomplete type"); + delete [] __ptr; + } + }; + + + + + template + class __uniq_ptr_impl + { + template + struct _Ptr + { + using type = _Up*; + }; + + template + struct + _Ptr<_Up, _Ep, __void_t::type::pointer>> + { + using type = typename remove_reference<_Ep>::type::pointer; + }; + + public: + using _DeleterConstraint = enable_if< + __and_<__not_>, + is_default_constructible<_Dp>>::value>; + + using pointer = typename _Ptr<_Tp, _Dp>::type; + + static_assert( !is_rvalue_reference<_Dp>::value, + "unique_ptr's deleter type must be a function object type" + " or an lvalue reference type" ); + + __uniq_ptr_impl() = default; + + __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; } + + template + + __uniq_ptr_impl(pointer __p, _Del&& __d) + : _M_t(__p, std::forward<_Del>(__d)) { } + + + __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept + : _M_t(std::move(__u._M_t)) + { __u._M_ptr() = nullptr; } + + + __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept + { + reset(__u.release()); + _M_deleter() = std::forward<_Dp>(__u._M_deleter()); + return *this; + } + + + pointer& _M_ptr() noexcept { return std::get<0>(_M_t); } + + pointer _M_ptr() const noexcept { return std::get<0>(_M_t); } + + _Dp& _M_deleter() noexcept { return std::get<1>(_M_t); } + + const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); } + + + void reset(pointer __p) noexcept + { + const pointer __old_p = _M_ptr(); + _M_ptr() = __p; + if (__old_p) + _M_deleter()(__old_p); + } + + + pointer release() noexcept + { + pointer __p = _M_ptr(); + _M_ptr() = nullptr; + return __p; + } + + + void + swap(__uniq_ptr_impl& __rhs) noexcept + { + using std::swap; + swap(this->_M_ptr(), __rhs._M_ptr()); + swap(this->_M_deleter(), __rhs._M_deleter()); + } + + private: + tuple _M_t; + }; + + + template ::value, + bool = is_move_assignable<_Dp>::value> + struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp> + { + using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; + __uniq_ptr_data(__uniq_ptr_data&&) = default; + __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; + }; + + template + struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp> + { + using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; + __uniq_ptr_data(__uniq_ptr_data&&) = default; + __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; + }; + + template + struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp> + { + using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; + __uniq_ptr_data(__uniq_ptr_data&&) = delete; + __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; + }; + + template + struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp> + { + using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; + __uniq_ptr_data(__uniq_ptr_data&&) = delete; + __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; + }; + + + + + + + + template > + class unique_ptr + { + template + using _DeleterConstraint = + typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; + + __uniq_ptr_data<_Tp, _Dp> _M_t; + + public: + using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; + using element_type = _Tp; + using deleter_type = _Dp; + + private: + + + template + using __safe_conversion_up = __and_< + is_convertible::pointer, pointer>, + __not_> + >; + + public: + + + + template> + constexpr unique_ptr() noexcept + : _M_t() + { } + + + + + + + + template> + + explicit + unique_ptr(pointer __p) noexcept + : _M_t(__p) + { } +# 328 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template>> + + unique_ptr(pointer __p, const deleter_type& __d) noexcept + : _M_t(__p, __d) { } +# 341 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template>> + + unique_ptr(pointer __p, + __enable_if_t::value, + _Del&&> __d) noexcept + : _M_t(__p, std::move(__d)) + { } + + template::type> + + unique_ptr(pointer, + __enable_if_t::value, + _DelUnref&&>) = delete; + + + template> + constexpr unique_ptr(nullptr_t) noexcept + : _M_t() + { } + + + + + unique_ptr(unique_ptr&&) = default; + + + + + + + + template, + __conditional_t::value, + is_same<_Ep, _Dp>, + is_convertible<_Ep, _Dp>>>> + + unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept + : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) + { } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template, is_same<_Dp, default_delete<_Tp>>>> + unique_ptr(auto_ptr<_Up>&& __u) noexcept; +#pragma GCC diagnostic pop + + + + + + + ~unique_ptr() noexcept + { + static_assert(__is_invocable::value, + "unique_ptr's deleter must be invocable with a pointer"); + auto& __ptr = _M_t._M_ptr(); + if (__ptr != nullptr) + get_deleter()(std::move(__ptr)); + __ptr = pointer(); + } + + + + + + + + unique_ptr& operator=(unique_ptr&&) = default; +# 423 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + + typename enable_if< __and_< + __safe_conversion_up<_Up, _Ep>, + is_assignable + >::value, + unique_ptr&>::type + operator=(unique_ptr<_Up, _Ep>&& __u) noexcept + { + reset(__u.release()); + get_deleter() = std::forward<_Ep>(__u.get_deleter()); + return *this; + } + + + + unique_ptr& + operator=(nullptr_t) noexcept + { + reset(); + return *this; + } + + + + + + typename add_lvalue_reference::type + operator*() const noexcept(noexcept(*std::declval())) + { + do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) __builtin_unreachable(); } while (false); + return *get(); + } + + + + pointer + operator->() const noexcept + { + ; + return get(); + } + + + + pointer + get() const noexcept + { return _M_t._M_ptr(); } + + + + deleter_type& + get_deleter() noexcept + { return _M_t._M_deleter(); } + + + + const deleter_type& + get_deleter() const noexcept + { return _M_t._M_deleter(); } + + + + explicit operator bool() const noexcept + { return get() == pointer() ? false : true; } + + + + + + pointer + release() noexcept + { return _M_t.release(); } +# 504 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + void + reset(pointer __p = pointer()) noexcept + { + static_assert(__is_invocable::value, + "unique_ptr's deleter must be invocable with a pointer"); + _M_t.reset(std::move(__p)); + } + + + + void + swap(unique_ptr& __u) noexcept + { + static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); + _M_t.swap(__u._M_t); + } + + + unique_ptr(const unique_ptr&) = delete; + unique_ptr& operator=(const unique_ptr&) = delete; + }; +# 534 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + class unique_ptr<_Tp[], _Dp> + { + template + using _DeleterConstraint = + typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; + + __uniq_ptr_data<_Tp, _Dp> _M_t; + + + template + using __is_derived_Tp + = __and_< is_base_of<_Tp, _Up>, + __not_, __remove_cv_t<_Up>>> >; + + public: + using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; + using element_type = _Tp; + using deleter_type = _Dp; + + + + template, + typename _UP_pointer = typename _UPtr::pointer, + typename _UP_element_type = typename _UPtr::element_type> + using __safe_conversion_up = __and_< + is_array<_Up>, + is_same, + is_same<_UP_pointer, _UP_element_type*>, + is_convertible<_UP_element_type(*)[], element_type(*)[]> + >; + + + template + using __safe_conversion_raw = __and_< + __or_<__or_, + is_same<_Up, nullptr_t>>, + __and_, + is_same, + is_convertible< + typename remove_pointer<_Up>::type(*)[], + element_type(*)[]> + > + > + >; + + + + + template> + constexpr unique_ptr() noexcept + : _M_t() + { } +# 596 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template, + typename = typename enable_if< + __safe_conversion_raw<_Up>::value, bool>::type> + + explicit + unique_ptr(_Up __p) noexcept + : _M_t(__p) + { } +# 615 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template, + is_copy_constructible<_Del>>> + + unique_ptr(_Up __p, const deleter_type& __d) noexcept + : _M_t(__p, __d) { } +# 630 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template, + is_move_constructible<_Del>>> + + unique_ptr(_Up __p, + __enable_if_t::value, + _Del&&> __d) noexcept + : _M_t(std::move(__p), std::move(__d)) + { } + + template::type, + typename = _Require<__safe_conversion_raw<_Up>>> + unique_ptr(_Up, + __enable_if_t::value, + _DelUnref&&>) = delete; + + + unique_ptr(unique_ptr&&) = default; + + + template> + constexpr unique_ptr(nullptr_t) noexcept + : _M_t() + { } + + template, + __conditional_t::value, + is_same<_Ep, _Dp>, + is_convertible<_Ep, _Dp>>>> + + unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept + : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) + { } + + + + + + ~unique_ptr() + { + auto& __ptr = _M_t._M_ptr(); + if (__ptr != nullptr) + get_deleter()(__ptr); + __ptr = pointer(); + } + + + + + + + + unique_ptr& + operator=(unique_ptr&&) = default; +# 694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + + typename + enable_if<__and_<__safe_conversion_up<_Up, _Ep>, + is_assignable + >::value, + unique_ptr&>::type + operator=(unique_ptr<_Up, _Ep>&& __u) noexcept + { + reset(__u.release()); + get_deleter() = std::forward<_Ep>(__u.get_deleter()); + return *this; + } + + + + unique_ptr& + operator=(nullptr_t) noexcept + { + reset(); + return *this; + } + + + + + + typename std::add_lvalue_reference::type + operator[](size_t __i) const + { + do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) __builtin_unreachable(); } while (false); + return get()[__i]; + } + + + + pointer + get() const noexcept + { return _M_t._M_ptr(); } + + + + deleter_type& + get_deleter() noexcept + { return _M_t._M_deleter(); } + + + + const deleter_type& + get_deleter() const noexcept + { return _M_t._M_deleter(); } + + + + explicit operator bool() const noexcept + { return get() == pointer() ? false : true; } + + + + + + pointer + release() noexcept + { return _M_t.release(); } + + + + + + + + template , + __and_, + is_pointer<_Up>, + is_convertible< + typename remove_pointer<_Up>::type(*)[], + element_type(*)[] + > + > + > + >> + + void + reset(_Up __p) noexcept + { _M_t.reset(std::move(__p)); } + + + void reset(nullptr_t = nullptr) noexcept + { reset(pointer()); } + + + + void + swap(unique_ptr& __u) noexcept + { + static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); + _M_t.swap(__u._M_t); + } + + + unique_ptr(const unique_ptr&) = delete; + unique_ptr& operator=(const unique_ptr&) = delete; + }; + + + + + + template + inline + + + + typename enable_if<__is_swappable<_Dp>::value>::type + + + + swap(unique_ptr<_Tp, _Dp>& __x, + unique_ptr<_Tp, _Dp>& __y) noexcept + { __x.swap(__y); } + + + template + typename enable_if::value>::type + swap(unique_ptr<_Tp, _Dp>&, + unique_ptr<_Tp, _Dp>&) = delete; + + + + template + [[__nodiscard__]] + inline bool + operator==(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return __x.get() == __y.get(); } + + + template + [[__nodiscard__]] + inline bool + operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept + { return !__x; } + + + + template + [[__nodiscard__]] + inline bool + operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept + { return !__x; } + + + template + [[__nodiscard__]] + inline bool + operator!=(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return __x.get() != __y.get(); } + + + template + [[__nodiscard__]] + inline bool + operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept + { return (bool)__x; } + + + template + [[__nodiscard__]] + inline bool + operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept + { return (bool)__x; } + + + + template + [[__nodiscard__]] + inline bool + operator<(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { + typedef typename + std::common_type::pointer, + typename unique_ptr<_Up, _Ep>::pointer>::type _CT; + return std::less<_CT>()(__x.get(), __y.get()); + } + + + template + [[__nodiscard__]] + inline bool + operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { + return std::less::pointer>()(__x.get(), + nullptr); + } + + + template + [[__nodiscard__]] + inline bool + operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { + return std::less::pointer>()(nullptr, + __x.get()); + } + + + template + [[__nodiscard__]] + inline bool + operator<=(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return !(__y < __x); } + + + template + [[__nodiscard__]] + inline bool + operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return !(nullptr < __x); } + + + template + [[__nodiscard__]] + inline bool + operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { return !(__x < nullptr); } + + + template + [[__nodiscard__]] + inline bool + operator>(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return (__y < __x); } + + + template + [[__nodiscard__]] + inline bool + operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { + return std::less::pointer>()(nullptr, + __x.get()); + } + + + template + [[__nodiscard__]] + inline bool + operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { + return std::less::pointer>()(__x.get(), + nullptr); + } + + + template + [[__nodiscard__]] + inline bool + operator>=(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return !(__x < __y); } + + + template + [[__nodiscard__]] + inline bool + operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return !(__x < nullptr); } + + + template + [[__nodiscard__]] inline bool + operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { return !(nullptr < __x); } +# 1006 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template::__enable_hash_call> + struct __uniq_ptr_hash + + : private __poison_hash<_Ptr> + + { + size_t + operator()(const _Up& __u) const + noexcept(noexcept(std::declval>()(std::declval<_Ptr>()))) + { return hash<_Ptr>()(__u.get()); } + }; + + template + struct __uniq_ptr_hash<_Up, _Ptr, false> + : private __poison_hash<_Ptr> + { }; + + + + template + struct hash> + : public __hash_base>, + public __uniq_ptr_hash> + { }; + + + + + +namespace __detail +{ + template + struct _MakeUniq + { typedef unique_ptr<_Tp> __single_object; }; + + template + struct _MakeUniq<_Tp[]> + { typedef unique_ptr<_Tp[]> __array; }; + + template + struct _MakeUniq<_Tp[_Bound]> + { struct __invalid_type { }; }; + + template + using __unique_ptr_t = typename _MakeUniq<_Tp>::__single_object; + template + using __unique_ptr_array_t = typename _MakeUniq<_Tp>::__array; + template + using __invalid_make_unique_t = typename _MakeUniq<_Tp>::__invalid_type; +} +# 1066 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + + inline __detail::__unique_ptr_t<_Tp> + make_unique(_Args&&... __args) + { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } +# 1081 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + + inline __detail::__unique_ptr_array_t<_Tp> + make_unique(size_t __num) + { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); } + + + + + + + template + __detail::__invalid_make_unique_t<_Tp> + make_unique(_Args&&...) = delete; +# 1154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + } + + + +} +# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 1 3 +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 + template + struct char_traits; + + template<> struct char_traits; + + template<> struct char_traits; + + + + + + + template<> struct char_traits; + template<> struct char_traits; + + +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_string; + +} + + + typedef basic_string string; + + + typedef basic_string wstring; +# 89 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 + typedef basic_string u16string; + + + typedef basic_string u32string; + + + + + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 27 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/include/bits/floatn.h" 1 3 4 +# 119 "/usr/include/bits/floatn.h" 3 4 +# 1 "/usr/include/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/bits/floatn-common.h" 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 25 "/usr/include/bits/floatn-common.h" 2 3 4 +# 214 "/usr/include/bits/floatn-common.h" 3 4 +typedef float _Float32; +# 251 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float64; +# 268 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float32x; +# 285 "/usr/include/bits/floatn-common.h" 3 4 +typedef long double _Float64x; +# 120 "/usr/include/bits/floatn.h" 2 3 4 +# 31 "/usr/include/wchar.h" 2 3 4 + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 36 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 +# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 39 "/usr/include/wchar.h" 2 3 4 + + + + +typedef __gnuc_va_list va_list; +# 52 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 +# 20 "/usr/include/bits/types/wint_t.h" 3 4 +typedef unsigned int wint_t; +# 53 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 + + + +# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 +# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 +typedef struct +{ + int __count; + union + { + unsigned int __wch; + char __wchb[4]; + } __value; +} __mbstate_t; +# 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4 + +typedef __mbstate_t mbstate_t; +# 54 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 + + + +struct _IO_FILE; +typedef struct _IO_FILE __FILE; +# 55 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/include/bits/types/FILE.h" 1 3 4 + + + +struct _IO_FILE; + + +typedef struct _IO_FILE FILE; +# 58 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 61 "/usr/include/wchar.h" 2 3 4 +# 90 "/usr/include/wchar.h" 3 4 +extern "C" { + + + +struct tm; + + + +extern wchar_t *wcscpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern wchar_t *wcsncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern size_t wcslcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern size_t wcslcat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern wchar_t *wcscat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern wchar_t *wcsncat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + +extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, + size_t __n) noexcept (true); + + + +extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + +extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + + + +extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + + +extern size_t wcsxfrm (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + + + + + +extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + + + + +extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + +extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) + __attribute__ ((__malloc__)) ; +# 189 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); +# 199 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + +extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) + noexcept (true) __attribute__ ((__pure__)); + + +extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 226 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 237 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + +extern wchar_t *wcstok (wchar_t *__restrict __s, + const wchar_t *__restrict __delim, + wchar_t **__restrict __ptr) noexcept (true); + + +extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); +# 258 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)); +# 278 "/usr/include/wchar.h" 3 4 +extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + + +extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + +extern wchar_t *wmemcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + +extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true); + + +extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); + + + + +extern wchar_t *wmempcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) + noexcept (true); + + + + + +extern wint_t btowc (int __c) noexcept (true); + + + +extern int wctob (wint_t __c) noexcept (true); + + + +extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); + + + +extern size_t mbrtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n, + mbstate_t *__restrict __p) noexcept (true); + + +extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, + mbstate_t *__restrict __ps) noexcept (true); + + +extern size_t __mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); +extern size_t mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + + +extern wint_t __btowc_alias (int __c) __asm ("btowc"); +extern __inline __attribute__ ((__gnu_inline__)) wint_t + btowc (int __c) noexcept (true) +{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' + ? (wint_t) __c : __btowc_alias (__c)); } + +extern int __wctob_alias (wint_t __c) __asm ("wctob"); +extern __inline __attribute__ ((__gnu_inline__)) int + wctob (wint_t __wc) noexcept (true) +{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' + ? (int) __wc : __wctob_alias (__wc)); } + +extern __inline __attribute__ ((__gnu_inline__)) size_t + mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) + +{ return (__ps != __null + ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } + + + + +extern size_t mbsrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + +extern size_t mbsnrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsnrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + +extern int wcwidth (wchar_t __c) noexcept (true); + + + +extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); + + + + + +extern double wcstod (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern float wcstof (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +extern long double wcstold (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 422 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 437 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 455 "/usr/include/wchar.h" 3 4 +extern long int wcstol (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) noexcept (true); + + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + + +extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); +# 561 "/usr/include/wchar.h" 3 4 +extern long int wcstol_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base, + locale_t __loc) noexcept (true); + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true); + + + + + +extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); + + + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); + + + + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); + + + + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); +# 630 "/usr/include/wchar.h" 3 4 +extern double wcstod_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern float wcstof_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern long double wcstold_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 649 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 667 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 689 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcpcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) noexcept (true); + + + +extern wchar_t *wcpncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true); +# 718 "/usr/include/wchar.h" 3 4 +extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern int fwide (__FILE *__fp, int __mode) noexcept (true); + + + + + + +extern int fwprintf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wprintf (const wchar_t *__restrict __format, ...) + ; + +extern int swprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, ...) + noexcept (true) ; + + + + + +extern int vfwprintf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwprintf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + +extern int vswprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; + + + + + + +extern int fwscanf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wscanf (const wchar_t *__restrict __format, ...) + ; + +extern int swscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, ...) + noexcept (true) ; +# 795 "/usr/include/wchar.h" 3 4 +extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") + + + ; +extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") + + ; +extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") + + + ; +# 851 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwscanf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + +extern int vswscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; +# 875 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") + + + ; +extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") + + ; +extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") + + + ; +# 935 "/usr/include/wchar.h" 3 4 +extern wint_t fgetwc (__FILE *__stream); +extern wint_t getwc (__FILE *__stream); + + + + + +extern wint_t getwchar (void); + + + + + + +extern wint_t fputwc (wchar_t __wc, __FILE *__stream); +extern wint_t putwc (wchar_t __wc, __FILE *__stream); + + + + + +extern wint_t putwchar (wchar_t __wc); + + + + + + + +extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + +extern int fputws (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern wint_t ungetwc (wint_t __wc, __FILE *__stream); +# 990 "/usr/include/wchar.h" 3 4 +extern wint_t getwc_unlocked (__FILE *__stream); +extern wint_t getwchar_unlocked (void); + + + + + + + +extern wint_t fgetwc_unlocked (__FILE *__stream); + + + + + + + +extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); +# 1016 "/usr/include/wchar.h" 3 4 +extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); +extern wint_t putwchar_unlocked (wchar_t __wc); +# 1026 "/usr/include/wchar.h" 3 4 +extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + + + +extern int fputws_unlocked (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp) noexcept (true); + + + + +extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); +# 1073 "/usr/include/wchar.h" 3 4 +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 2 3 +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +namespace std +{ + using ::mbstate_t; +} +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::wint_t; + + using ::btowc; + using ::fgetwc; + using ::fgetws; + using ::fputwc; + using ::fputws; + using ::fwide; + using ::fwprintf; + using ::fwscanf; + using ::getwc; + using ::getwchar; + using ::mbrlen; + using ::mbrtowc; + using ::mbsinit; + using ::mbsrtowcs; + using ::putwc; + using ::putwchar; + + using ::swprintf; + + using ::swscanf; + using ::ungetwc; + using ::vfwprintf; + + using ::vfwscanf; + + + using ::vswprintf; + + + using ::vswscanf; + + using ::vwprintf; + + using ::vwscanf; + + using ::wcrtomb; + using ::wcscat; + using ::wcscmp; + using ::wcscoll; + using ::wcscpy; + using ::wcscspn; + using ::wcsftime; + using ::wcslen; + using ::wcsncat; + using ::wcsncmp; + using ::wcsncpy; + using ::wcsrtombs; + using ::wcsspn; + using ::wcstod; + + using ::wcstof; + + using ::wcstok; + using ::wcstol; + using ::wcstoul; + using ::wcsxfrm; + using ::wctob; + using ::wmemcmp; + using ::wmemcpy; + using ::wmemmove; + using ::wmemset; + using ::wprintf; + using ::wscanf; + using ::wcschr; + using ::wcspbrk; + using ::wcsrchr; + using ::wcsstr; + using ::wmemchr; + + + inline wchar_t* + wcschr(wchar_t* __p, wchar_t __c) + { return wcschr(const_cast(__p), __c); } + + inline wchar_t* + wcspbrk(wchar_t* __s1, const wchar_t* __s2) + { return wcspbrk(const_cast(__s1), __s2); } + + inline wchar_t* + wcsrchr(wchar_t* __p, wchar_t __c) + { return wcsrchr(const_cast(__p), __c); } + + inline wchar_t* + wcsstr(wchar_t* __s1, const wchar_t* __s2) + { return wcsstr(const_cast(__s1), __s2); } + + inline wchar_t* + wmemchr(wchar_t* __p, wchar_t __c, size_t __n) + { return wmemchr(const_cast(__p), __c, __n); } + + + +} +} + + + + + + + +namespace __gnu_cxx +{ + + + + + + using ::wcstold; +# 260 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 + using ::wcstoll; + using ::wcstoull; + +} + +namespace std +{ + using ::__gnu_cxx::wcstold; + using ::__gnu_cxx::wcstoll; + using ::__gnu_cxx::wcstoull; +} +# 280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +namespace std +{ + + using std::wcstof; + + + using std::vfwscanf; + + + using std::vswscanf; + + + using std::vwscanf; + + + + using std::wcstold; + using std::wcstoll; + using std::wcstoull; + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + typedef long int streamoff; + + + + + + typedef ptrdiff_t streamsize; +# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + template + class fpos + { + private: + streamoff _M_off; + _StateT _M_state; + + public: + + + + + fpos() + : _M_off(0), _M_state() { } +# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + fpos(streamoff __off) + : _M_off(__off), _M_state() { } + + + fpos(const fpos&) = default; + fpos& operator=(const fpos&) = default; + ~fpos() = default; + + + + operator streamoff() const { return _M_off; } + + + void + state(_StateT __st) + { _M_state = __st; } + + + _StateT + state() const + { return _M_state; } + + + + + + fpos& + operator+=(streamoff __off) + { + _M_off += __off; + return *this; + } + + + + + + fpos& + operator-=(streamoff __off) + { + _M_off -= __off; + return *this; + } + + + + + + + + fpos + operator+(streamoff __off) const + { + fpos __pos(*this); + __pos += __off; + return __pos; + } + + + + + + + + fpos + operator-(streamoff __off) const + { + fpos __pos(*this); + __pos -= __off; + return __pos; + } + + + + + + + streamoff + operator-(const fpos& __other) const + { return _M_off - __other._M_off; } + }; + + + + + + + template + inline bool + operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) == streamoff(__rhs); } + + template + inline bool + operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) != streamoff(__rhs); } + + + + + + typedef fpos streampos; + + typedef fpos wstreampos; +# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + typedef fpos u16streampos; + + typedef fpos u32streampos; + + + +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 76 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 + class ios_base; + + template > + class basic_ios; + + template > + class basic_streambuf; + + template > + class basic_istream; + + template > + class basic_ostream; + + template > + class basic_iostream; + + +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringbuf; + + template, + typename _Alloc = allocator<_CharT> > + class basic_istringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_ostringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringstream; + +} + + template > + class basic_filebuf; + + template > + class basic_ifstream; + + template > + class basic_ofstream; + + template > + class basic_fstream; + + template > + class istreambuf_iterator; + + template > + class ostreambuf_iterator; + + + + typedef basic_ios ios; + + + typedef basic_streambuf streambuf; + + + typedef basic_istream istream; + + + typedef basic_ostream ostream; + + + typedef basic_iostream iostream; + + + typedef basic_stringbuf stringbuf; + + + typedef basic_istringstream istringstream; + + + typedef basic_ostringstream ostringstream; + + + typedef basic_stringstream stringstream; + + + typedef basic_filebuf filebuf; + + + typedef basic_ifstream ifstream; + + + typedef basic_ofstream ofstream; + + + typedef basic_fstream fstream; + + + + typedef basic_ios wios; + + + typedef basic_streambuf wstreambuf; + + + typedef basic_istream wistream; + + + typedef basic_ostream wostream; + + + typedef basic_iostream wiostream; + + + typedef basic_stringbuf wstringbuf; + + + typedef basic_istringstream wistringstream; + + + typedef basic_ostringstream wostringstream; + + + typedef basic_stringstream wstringstream; + + + typedef basic_filebuf wfilebuf; + + + typedef basic_ifstream wifstream; + + + typedef basic_ofstream wofstream; + + + typedef basic_fstream wfstream; +# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 +} +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 1 3 +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + + + + + + +#pragma GCC visibility push(default) + + + + + +extern "C++" { + +namespace __cxxabiv1 +{ + class __class_type_info; +} +# 84 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 +namespace std +{ + + + + + + + class type_info + { + public: + + + + + virtual ~type_info(); + + + + const char* name() const noexcept + { return __name[0] == '*' ? __name + 1 : __name; } + + + + bool before(const type_info& __arg) const noexcept; + + + bool operator==(const type_info& __arg) const noexcept; + + + 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&) = delete; + type_info(const type_info&) = delete; +# 167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + }; + + + inline bool + type_info::before(const type_info& __arg) const noexcept + { + + + + + if (__name[0] != '*' || __arg.__name[0] != '*') + return __builtin_strcmp (__name, __arg.__name) < 0; +# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + return __name < __arg.__name; + } + + + + inline bool + type_info::operator==(const type_info& __arg) const noexcept + { + if (std::__is_constant_evaluated()) + return this == &__arg; + + if (__name == __arg.__name) + return true; + + + + + + + return __name[0] != '*' && __builtin_strcmp (__name, __arg.name()) == 0; + + + + } +# 220 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + class bad_cast : public exception + { + public: + bad_cast() noexcept { } + + + + virtual ~bad_cast() noexcept; + + + virtual const char* what() const noexcept; + }; + + + + + + class bad_typeid : public exception + { + public: + bad_typeid () noexcept { } + + + + virtual ~bad_typeid() noexcept; + + + virtual const char* what() const noexcept; + }; +} + +} + +#pragma GCC visibility pop +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 + template + struct _Maybe_unary_or_binary_function { }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1> + : std::unary_function<_T1, _Res> { }; + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> + : std::binary_function<_T1, _T2, _Res> { }; + +#pragma GCC diagnostic pop + + template + struct _Mem_fn_traits; + + template + struct _Mem_fn_traits_base + { + using __result_type = _Res; + using __maybe_type + = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; + using __arity = integral_constant; + }; +# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; + + +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; + + + + + + + template> + struct _Maybe_get_result_type + { }; + + template + struct _Maybe_get_result_type<_Functor, + __void_t> + { typedef typename _Functor::result_type result_type; }; + + + + + + template + struct _Weak_result_type_impl + : _Maybe_get_result_type<_Functor> + { }; + + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct + _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)> + { typedef _Res result_type; }; + + + template::value> + struct _Weak_result_type_memfun + : _Weak_result_type_impl<_Functor> + { }; + + + template + struct _Weak_result_type_memfun<_MemFunPtr, true> + { + using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; + }; + + + template + struct _Weak_result_type_memfun<_Func _Class::*, false> + { }; + + + + + + template + struct _Weak_result_type + : _Weak_result_type_memfun::type> + { }; + + + + template> + struct _Refwrap_base_arg1 + { }; + + + template + struct _Refwrap_base_arg1<_Tp, + __void_t> + { + typedef typename _Tp::argument_type argument_type; + }; + + + template> + struct _Refwrap_base_arg2 + { }; + + + template + struct _Refwrap_base_arg2<_Tp, + __void_t> + { + typedef typename _Tp::first_argument_type first_argument_type; + typedef typename _Tp::second_argument_type second_argument_type; + }; + + + + + + + + template + struct _Reference_wrapper_base + : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> + { }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) volatile> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const volatile> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> + : binary_function<_T1, _T2, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)> + : binary_function<_T1, _T2, _Res> + { }; + + template::value> + struct _Reference_wrapper_base_memfun + : _Reference_wrapper_base<_Tp> + { }; + + template + struct _Reference_wrapper_base_memfun<_MemFunPtr, true> + : _Mem_fn_traits<_MemFunPtr>::__maybe_type + { + using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; + }; +#pragma GCC diagnostic pop + + + + + + + + + template + class reference_wrapper + + + + : public _Reference_wrapper_base_memfun::type> + + { + _Tp* _M_data; + + + static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } + + static void _S_fun(_Tp&&) = delete; + + template> + using __not_same + = typename enable_if::value>::type; + + public: + typedef _Tp type; + + + + + template, typename + = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> + + reference_wrapper(_Up&& __uref) + noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) + : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) + { } + + reference_wrapper(const reference_wrapper&) = default; + + reference_wrapper& + operator=(const reference_wrapper&) = default; + + + operator _Tp&() const noexcept + { return this->get(); } + + + _Tp& + get() const noexcept + { return *_M_data; } + + template + + typename __invoke_result<_Tp&, _Args...>::type + operator()(_Args&&... __args) const + noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value) + { + + + + + return std::__invoke(get(), std::forward<_Args>(__args)...); + } + }; + + + template + reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; + + + + + + template + + inline reference_wrapper<_Tp> + ref(_Tp& __t) noexcept + { return reference_wrapper<_Tp>(__t); } + + + template + + inline reference_wrapper + cref(const _Tp& __t) noexcept + { return reference_wrapper(__t); } + + template + void ref(const _Tp&&) = delete; + + template + void cref(const _Tp&&) = delete; + + + template + + inline reference_wrapper<_Tp> + ref(reference_wrapper<_Tp> __t) noexcept + { return __t; } + + + template + + inline reference_wrapper + cref(reference_wrapper<_Tp> __t) noexcept + { return { __t.get() }; } + + + + +} +# 58 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 1 3 +# 30 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 +#pragma GCC visibility push(default) +# 148 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +# 1 "/usr/include/pthread.h" 1 3 4 +# 22 "/usr/include/pthread.h" 3 4 +# 1 "/usr/include/sched.h" 1 3 4 +# 29 "/usr/include/sched.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 30 "/usr/include/sched.h" 2 3 4 + +# 1 "/usr/include/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 32 "/usr/include/sched.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 + + + + + +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 35 "/usr/include/bits/endian.h" 3 4 +# 1 "/usr/include/bits/endianness.h" 1 3 4 +# 36 "/usr/include/bits/endian.h" 2 3 4 +# 7 "/usr/include/bits/types/struct_timespec.h" 2 3 4 + + + + +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 +}; +# 33 "/usr/include/sched.h" 2 3 4 + + + + + +typedef __pid_t pid_t; + + + + +# 1 "/usr/include/bits/sched.h" 1 3 4 +# 80 "/usr/include/bits/sched.h" 3 4 +# 1 "/usr/include/bits/types/struct_sched_param.h" 1 3 4 +# 23 "/usr/include/bits/types/struct_sched_param.h" 3 4 +struct sched_param +{ + int sched_priority; +}; +# 81 "/usr/include/bits/sched.h" 2 3 4 + +extern "C" { + + + +extern int clone (int (*__fn) (void *__arg), void *__child_stack, + int __flags, void *__arg, ...) noexcept (true); + + +extern int unshare (int __flags) noexcept (true); + + +extern int sched_getcpu (void) noexcept (true); + + +extern int getcpu (unsigned int *, unsigned int *) noexcept (true); + + +extern int setns (int __fd, int __nstype) noexcept (true); + + +} +# 44 "/usr/include/sched.h" 2 3 4 +# 1 "/usr/include/bits/cpu-set.h" 1 3 4 +# 32 "/usr/include/bits/cpu-set.h" 3 4 +typedef unsigned long int __cpu_mask; + + + + + + +typedef struct +{ + __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; +} cpu_set_t; +# 115 "/usr/include/bits/cpu-set.h" 3 4 +extern "C" { + +extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) + noexcept (true); +extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) ; +extern void __sched_cpufree (cpu_set_t *__set) noexcept (true); + +} +# 45 "/usr/include/sched.h" 2 3 4 + + + + + + +extern "C" { + + +extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) + noexcept (true); + + +extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true); + + +extern int sched_setscheduler (__pid_t __pid, int __policy, + const struct sched_param *__param) noexcept (true); + + +extern int sched_getscheduler (__pid_t __pid) noexcept (true); + + +extern int sched_yield (void) noexcept (true); + + +extern int sched_get_priority_max (int __algorithm) noexcept (true); + + +extern int sched_get_priority_min (int __algorithm) noexcept (true); + + + +extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true); +# 130 "/usr/include/sched.h" 3 4 +extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, + const cpu_set_t *__cpuset) noexcept (true); + + +extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, + cpu_set_t *__cpuset) noexcept (true); + + +} +# 23 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 73 "/usr/include/bits/time.h" 3 4 +# 1 "/usr/include/bits/timex.h" 1 3 4 +# 22 "/usr/include/bits/timex.h" 3 4 +# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 23 "/usr/include/bits/timex.h" 2 3 4 + + + +struct timex +{ +# 58 "/usr/include/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); +# 90 "/usr/include/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 38 "/usr/include/time.h" 2 3 4 + +# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 + + + + + + +# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 47 "/usr/include/time.h" 2 3 4 +# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 48 "/usr/include/time.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0) + noexcept (true) __attribute__ ((__const__)); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 100 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) + noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 155 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 180 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 198 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 218 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 247 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); +# 264 "/usr/include/time.h" 3 4 +extern time_t timelocal (struct tm *__tp) noexcept (true); + + + + + + + +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 282 "/usr/include/time.h" 3 4 +extern int nanosleep (const struct timespec *__requested_time, + struct timespec *__remaining); + + +extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 324 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 339 "/usr/include/time.h" 3 4 +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) noexcept (true); + + +extern int timer_delete (timer_t __timerid) noexcept (true); + + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) noexcept (true); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + noexcept (true); +# 377 "/usr/include/time.h" 3 4 +extern int timer_getoverrun (timer_t __timerid) noexcept (true); + + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 400 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 426 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 435 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 449 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 24 "/usr/include/pthread.h" 2 3 4 + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 27 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/setjmp.h" 1 3 4 +# 26 "/usr/include/bits/setjmp.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 27 "/usr/include/bits/setjmp.h" 2 3 4 + + + + +typedef long int __jmp_buf[8]; +# 28 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 29 "/usr/include/pthread.h" 2 3 4 + +# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 31 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/types/struct___jmp_buf_tag.h" 1 3 4 +# 26 "/usr/include/bits/types/struct___jmp_buf_tag.h" 3 4 +struct __jmp_buf_tag + { + + + + + __jmp_buf __jmpbuf; + int __mask_was_saved; + __sigset_t __saved_mask; + }; +# 32 "/usr/include/pthread.h" 2 3 4 + +# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 34 "/usr/include/pthread.h" 2 3 4 + + + +enum +{ + PTHREAD_CREATE_JOINABLE, + + PTHREAD_CREATE_DETACHED + +}; + + + +enum +{ + PTHREAD_MUTEX_TIMED_NP, + PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_ADAPTIVE_NP + + , + PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, + PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL + + + + , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP + +}; + + + + +enum +{ + PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_ROBUST, + PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST +}; + + + + + +enum +{ + PTHREAD_PRIO_NONE, + PTHREAD_PRIO_INHERIT, + PTHREAD_PRIO_PROTECT +}; +# 104 "/usr/include/pthread.h" 3 4 +enum +{ + PTHREAD_RWLOCK_PREFER_READER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, + PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP +}; +# 124 "/usr/include/pthread.h" 3 4 +enum +{ + PTHREAD_INHERIT_SCHED, + + PTHREAD_EXPLICIT_SCHED + +}; + + + +enum +{ + PTHREAD_SCOPE_SYSTEM, + + PTHREAD_SCOPE_PROCESS + +}; + + + +enum +{ + PTHREAD_PROCESS_PRIVATE, + + PTHREAD_PROCESS_SHARED + +}; +# 159 "/usr/include/pthread.h" 3 4 +struct _pthread_cleanup_buffer +{ + void (*__routine) (void *); + void *__arg; + int __canceltype; + struct _pthread_cleanup_buffer *__prev; +}; + + +enum +{ + PTHREAD_CANCEL_ENABLE, + + PTHREAD_CANCEL_DISABLE + +}; +enum +{ + PTHREAD_CANCEL_DEFERRED, + + PTHREAD_CANCEL_ASYNCHRONOUS + +}; +# 197 "/usr/include/pthread.h" 3 4 +extern "C" { + + + + +extern int pthread_create (pthread_t *__restrict __newthread, + const pthread_attr_t *__restrict __attr, + void *(*__start_routine) (void *), + void *__restrict __arg) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + + + +extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); + + + + + + + +extern int pthread_join (pthread_t __th, void **__thread_return); + + + + +extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) noexcept (true); +# 233 "/usr/include/pthread.h" 3 4 +extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, + const struct timespec *__abstime); +# 243 "/usr/include/pthread.h" 3 4 +extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return, + clockid_t __clockid, + const struct timespec *__abstime); +# 269 "/usr/include/pthread.h" 3 4 +extern int pthread_detach (pthread_t __th) noexcept (true); + + + +extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__)); + + +extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) + noexcept (true) __attribute__ ((__const__)); + + + + + + + +extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_destroy (pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, + int *__detachstate) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, + int __detachstate) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, + size_t *__guardsize) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setguardsize (pthread_attr_t *__attr, + size_t __guardsize) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, + struct sched_param *__restrict __param) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, + const struct sched_param *__restrict + __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict + __attr, int *__restrict __policy) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict + __attr, int *__restrict __inherit) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, + int __inherit) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, + int *__restrict __scope) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict + __attr, void **__restrict __stackaddr) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); + + + + + +extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, + void *__stackaddr) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); + + +extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict + __attr, size_t *__restrict __stacksize) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int pthread_attr_setstacksize (pthread_attr_t *__attr, + size_t __stacksize) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, + void **__restrict __stackaddr, + size_t *__restrict __stacksize) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))); + + + + +extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, + size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, + size_t __cpusetsize, + const cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, + size_t __cpusetsize, + cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + +extern int pthread_getattr_default_np (pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr, + const __sigset_t *sigmask); + + + + +extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr, + __sigset_t *sigmask); + + + + + + + +extern int pthread_setattr_default_np (const pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + + + + +extern int pthread_setschedparam (pthread_t __target_thread, int __policy, + const struct sched_param *__param) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + +extern int pthread_getschedparam (pthread_t __target_thread, + int *__restrict __policy, + struct sched_param *__restrict __param) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + +extern int pthread_setschedprio (pthread_t __target_thread, int __prio) + noexcept (true); + + + + +extern int pthread_getname_np (pthread_t __target_thread, char *__buf, + size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int pthread_setname_np (pthread_t __target_thread, const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + + +extern int pthread_getconcurrency (void) noexcept (true); + + +extern int pthread_setconcurrency (int __level) noexcept (true); + + + +extern int pthread_yield (void) noexcept (true); + +extern int pthread_yield (void) noexcept (true) __asm__ ("" "sched_yield") + __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead"))); +# 489 "/usr/include/pthread.h" 3 4 +extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, + const cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + +extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, + cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 509 "/usr/include/pthread.h" 3 4 +extern int pthread_once (pthread_once_t *__once_control, + void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); +# 521 "/usr/include/pthread.h" 3 4 +extern int pthread_setcancelstate (int __state, int *__oldstate); + + + +extern int pthread_setcanceltype (int __type, int *__oldtype); + + +extern int pthread_cancel (pthread_t __th); + + + + +extern void pthread_testcancel (void); + + + + +struct __cancel_jmp_buf_tag +{ + __jmp_buf __cancel_jmp_buf; + int __mask_was_saved; +}; + +typedef struct +{ + struct __cancel_jmp_buf_tag __cancel_jmp_buf[1]; + void *__pad[4]; +} __pthread_unwind_buf_t __attribute__ ((__aligned__)); +# 557 "/usr/include/pthread.h" 3 4 +struct __pthread_cleanup_frame +{ + void (*__cancel_routine) (void *); + void *__cancel_arg; + int __do_it; + int __cancel_type; +}; + + + + +class __pthread_cleanup_class +{ + void (*__cancel_routine) (void *); + void *__cancel_arg; + int __do_it; + int __cancel_type; + + public: + __pthread_cleanup_class (void (*__fct) (void *), void *__arg) + : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } + ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } + void __setdoit (int __newval) { __do_it = __newval; } + void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, + &__cancel_type); } + void __restore () const { pthread_setcanceltype (__cancel_type, 0); } +}; +# 773 "/usr/include/pthread.h" 3 4 +extern int __sigsetjmp (struct __jmp_buf_tag __env[1], + int __savemask) noexcept (true); + + + + + + +extern int pthread_mutex_init (pthread_mutex_t *__mutex, + const pthread_mutexattr_t *__mutexattr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_lock (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 817 "/usr/include/pthread.h" 3 4 +extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex, + clockid_t __clockid, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 835 "/usr/include/pthread.h" 3 4 +extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutex_getprioceiling (const pthread_mutex_t * + __restrict __mutex, + int *__restrict __prioceiling) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, + int __prioceiling, + int *__restrict __old_ceiling) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + + +extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_consistent_np (pthread_mutex_t *) noexcept (true) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nonnull__ (1))) + + __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent"))); +# 874 "/usr/include/pthread.h" 3 4 +extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, + int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict + __attr, int *__restrict __kind) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __protocol) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, + int __protocol) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __prioceiling) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, + int __prioceiling) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, + int *__robustness) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) noexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nonnull__ (1))) + + + __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust"))); + + + + + + + +extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, + int __robustness) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) noexcept (true) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nonnull__ (1))) + + + __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust"))); +# 967 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, + const pthread_rwlockattr_t *__restrict + __attr) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 1004 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock, + clockid_t __clockid, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 1023 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 1051 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock, + clockid_t __clockid, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 1071 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, + int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * + __restrict __attr, + int *__restrict __pref) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, + int __pref) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern int pthread_cond_init (pthread_cond_t *__restrict __cond, + const pthread_condattr_t *__restrict __cond_attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_destroy (pthread_cond_t *__cond) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_signal (pthread_cond_t *__cond) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_broadcast (pthread_cond_t *__cond) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex) + __attribute__ ((__nonnull__ (1, 2))); +# 1145 "/usr/include/pthread.h" 3 4 +extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex, + const struct timespec *__restrict __abstime) + __attribute__ ((__nonnull__ (1, 2, 3))); +# 1171 "/usr/include/pthread.h" 3 4 +extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex, + __clockid_t __clock_id, + const struct timespec *__restrict __abstime) + __attribute__ ((__nonnull__ (1, 2, 4))); +# 1194 "/usr/include/pthread.h" 3 4 +extern int pthread_condattr_init (pthread_condattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_condattr_destroy (pthread_condattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_condattr_getpshared (const pthread_condattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, + int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_condattr_getclock (const pthread_condattr_t * + __restrict __attr, + __clockid_t *__restrict __clock_id) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_condattr_setclock (pthread_condattr_t *__attr, + __clockid_t __clock_id) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1230 "/usr/include/pthread.h" 3 4 +extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_destroy (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_lock (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_trylock (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_unlock (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, + const pthread_barrierattr_t *__restrict + __attr, unsigned int __count) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrier_wait (pthread_barrier_t *__barrier) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, + int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1297 "/usr/include/pthread.h" 3 4 +extern int pthread_key_create (pthread_key_t *__key, + void (*__destr_function) (void *)) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_key_delete (pthread_key_t __key) noexcept (true); + + +extern void *pthread_getspecific (pthread_key_t __key) noexcept (true); + + +extern int pthread_setspecific (pthread_key_t __key, + const void *__pointer) + noexcept (true) ; + + + + +extern int pthread_getcpuclockid (pthread_t __thread_id, + __clockid_t *__clock_id) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 1332 "/usr/include/pthread.h" 3 4 +extern int pthread_atfork (void (*__prepare) (void), + void (*__parent) (void), + void (*__child) (void)) noexcept (true); + + + + +extern __inline __attribute__ ((__gnu_inline__)) int + pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true) +{ + return __thread1 == __thread2; +} + + +} +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +typedef pthread_t __gthread_t; +typedef pthread_key_t __gthread_key_t; +typedef pthread_once_t __gthread_once_t; +typedef pthread_mutex_t __gthread_mutex_t; +typedef pthread_mutex_t __gthread_recursive_mutex_t; +typedef pthread_cond_t __gthread_cond_t; +typedef struct timespec __gthread_time_t; +# 299 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_active_p (void) +{ + return 1; +} +# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), + void *__args) +{ + return pthread_create (__threadid, __null, __func, __args); +} + +static inline int +__gthread_join (__gthread_t __threadid, void **__value_ptr) +{ + return pthread_join (__threadid, __value_ptr); +} + +static inline int +__gthread_detach (__gthread_t __threadid) +{ + return pthread_detach (__threadid); +} + +static inline int +__gthread_equal (__gthread_t __t1, __gthread_t __t2) +{ + return pthread_equal (__t1, __t2); +} + +static inline __gthread_t +__gthread_self (void) +{ + return pthread_self (); +} + +static inline int +__gthread_yield (void) +{ + return sched_yield (); +} + +static inline int +__gthread_once (__gthread_once_t *__once, void (*__func) (void)) +{ + if (__gthread_active_p ()) + return pthread_once (__once, __func); + else + return -1; +} + +static inline int +__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) +{ + return pthread_key_create (__key, __dtor); +} + +static inline int +__gthread_key_delete (__gthread_key_t __key) +{ + return pthread_key_delete (__key); +} + +static inline void * +__gthread_getspecific (__gthread_key_t __key) +{ + return pthread_getspecific (__key); +} + +static inline int +__gthread_setspecific (__gthread_key_t __key, const void *__ptr) +{ + return pthread_setspecific (__key, __ptr); +} + +static inline void +__gthread_mutex_init_function (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + pthread_mutex_init (__mutex, __null); +} + +static inline int +__gthread_mutex_destroy (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_destroy (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_lock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_lock (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_trylock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_trylock (__mutex); + else + return 0; +} + + +static inline int +__gthread_mutex_timedlock (__gthread_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + if (__gthread_active_p ()) + return pthread_mutex_timedlock (__mutex, __abs_timeout); + else + return 0; +} + + +static inline int +__gthread_mutex_unlock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_unlock (__mutex); + else + return 0; +} +# 808 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_lock (__mutex); +} + +static inline int +__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_trylock (__mutex); +} + + +static inline int +__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + return __gthread_mutex_timedlock (__mutex, __abs_timeout); +} + + +static inline int +__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_unlock (__mutex); +} + +static inline int +__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_destroy (__mutex); +} +# 850 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_cond_broadcast (__gthread_cond_t *__cond) +{ + return pthread_cond_broadcast (__cond); +} + +static inline int +__gthread_cond_signal (__gthread_cond_t *__cond) +{ + return pthread_cond_signal (__cond); +} + +static inline int +__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) +{ + return pthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + return pthread_cond_timedwait (__cond, __mutex, __abs_timeout); +} + +static inline int +__gthread_cond_wait_recursive (__gthread_cond_t *__cond, + __gthread_recursive_mutex_t *__mutex) +{ + return __gthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_destroy (__gthread_cond_t* __cond) +{ + return pthread_cond_destroy (__cond); +} +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 2 3 + + +#pragma GCC visibility pop +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3 +# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 3 +typedef int _Atomic_word; +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 + +# 1 "/usr/include/sys/single_threaded.h" 1 3 4 +# 24 "/usr/include/sys/single_threaded.h" 3 4 +extern "C" { + + + + +extern char __libc_single_threaded; + +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + __attribute__((__always_inline__)) + inline bool + __is_single_threaded() noexcept + { + + + + return ::__libc_single_threaded; + + + + } + + + + + + + inline _Atomic_word + __attribute__((__always_inline__)) + __exchange_and_add(volatile _Atomic_word* __mem, int __val) + { return __atomic_fetch_add(__mem, __val, 4); } + + inline void + __attribute__((__always_inline__)) + __atomic_add(volatile _Atomic_word* __mem, int __val) + { __atomic_fetch_add(__mem, __val, 4); } +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 + inline _Atomic_word + __attribute__((__always_inline__)) + __exchange_and_add_single(_Atomic_word* __mem, int __val) + { + _Atomic_word __result = *__mem; + *__mem += __val; + return __result; + } + + inline void + __attribute__((__always_inline__)) + __atomic_add_single(_Atomic_word* __mem, int __val) + { *__mem += __val; } + + inline _Atomic_word + __attribute__ ((__always_inline__)) + __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) + { + if (__is_single_threaded()) + return __exchange_and_add_single(__mem, __val); + else + return __exchange_and_add(__mem, __val); + } + + inline void + __attribute__ ((__always_inline__)) + __atomic_add_dispatch(_Atomic_word* __mem, int __val) + { + if (__is_single_threaded()) + __atomic_add_single(__mem, __val); + else + __atomic_add(__mem, __val); + } + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + class bad_exception : public exception + { + public: + bad_exception() noexcept { } + + + + virtual ~bad_exception() noexcept; + + + virtual const char* + what() const noexcept; + }; + + + typedef void (*terminate_handler) (); + + + terminate_handler set_terminate(terminate_handler) noexcept; + + + + terminate_handler get_terminate() noexcept; + + + + + void terminate() noexcept __attribute__ ((__noreturn__)); + + + + typedef void (*__attribute__ ((__deprecated__)) unexpected_handler) (); + + + + + + __attribute__ ((__deprecated__)) + unexpected_handler set_unexpected(unexpected_handler) noexcept; + + + + + + + + __attribute__ ((__deprecated__)) + unexpected_handler get_unexpected() noexcept; + + + + + + + + __attribute__ ((__deprecated__)) + void unexpected() __attribute__ ((__noreturn__)); +# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + __attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "' instead"))) + bool uncaught_exception() noexcept __attribute__ ((__pure__)); + + + + + + + + int uncaught_exceptions() noexcept __attribute__ ((__pure__)); + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + void __verbose_terminate_handler(); + + +} + +} + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 + +#pragma GCC visibility push(default) + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 2 3 +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 +namespace std +{ + class type_info; +} + +namespace __cxxabiv1 +{ + struct __cxa_refcounted_exception; + + extern "C" + { + + void* + __cxa_allocate_exception(size_t) noexcept; + + void + __cxa_free_exception(void*) noexcept; + + + __cxa_refcounted_exception* + __cxa_init_primary_exception(void *__object, std::type_info *__tinfo, + void ( *__dest) (void *)) + noexcept; + + } +} + + + +#pragma GCC visibility pop +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + class type_info; + + + + + + + namespace __exception_ptr + { + class exception_ptr; + } + + using __exception_ptr::exception_ptr; +# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + exception_ptr current_exception() noexcept; + + template + exception_ptr make_exception_ptr(_Ex) noexcept; + + + void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); + + namespace __exception_ptr + { + using std::rethrow_exception; +# 97 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + class exception_ptr + { + void* _M_exception_object; + + explicit exception_ptr(void* __e) noexcept; + + void _M_addref() noexcept; + void _M_release() noexcept; + + void *_M_get() const noexcept __attribute__ ((__pure__)); + + friend exception_ptr std::current_exception() noexcept; + friend void std::rethrow_exception(exception_ptr); + template + friend exception_ptr std::make_exception_ptr(_Ex) noexcept; + + public: + exception_ptr() noexcept; + + exception_ptr(const exception_ptr&) noexcept; + + + exception_ptr(nullptr_t) noexcept + : _M_exception_object(nullptr) + { } + + exception_ptr(exception_ptr&& __o) noexcept + : _M_exception_object(__o._M_exception_object) + { __o._M_exception_object = nullptr; } +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +# 162 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + explicit operator bool() const noexcept + { return _M_exception_object; } + + + + + + + + friend bool + operator==(const exception_ptr& __x, const exception_ptr& __y) + noexcept + { return __x._M_exception_object == __y._M_exception_object; } + + friend bool + operator!=(const exception_ptr& __x, const exception_ptr& __y) + noexcept + { return __x._M_exception_object != __y._M_exception_object; } + + + const class std::type_info* + __cxa_exception_type() const noexcept + __attribute__ ((__pure__)); + }; + + + inline + exception_ptr::exception_ptr() noexcept + : _M_exception_object(0) + { } + + + inline + exception_ptr::exception_ptr(const exception_ptr& __other) + noexcept + : _M_exception_object(__other._M_exception_object) + { + if (_M_exception_object) + _M_addref(); + } + + + inline + exception_ptr::~exception_ptr() noexcept + { + if (_M_exception_object) + _M_release(); + } + + + inline exception_ptr& + exception_ptr::operator=(const exception_ptr& __other) noexcept + { + exception_ptr(__other).swap(*this); + return *this; + } + + + inline void + exception_ptr::swap(exception_ptr &__other) noexcept + { + void *__tmp = _M_exception_object; + _M_exception_object = __other._M_exception_object; + __other._M_exception_object = __tmp; + } + + + inline void + swap(exception_ptr& __lhs, exception_ptr& __rhs) + { __lhs.swap(__rhs); } + + + template + + inline void + __dest_thunk(void* __x) + { static_cast<_Ex*>(__x)->~_Ex(); } + + + } + + using __exception_ptr::swap; + + + + template + exception_ptr + make_exception_ptr(_Ex __ex) noexcept + { + + using _Ex2 = typename decay<_Ex>::type; + void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); + (void) __cxxabiv1::__cxa_init_primary_exception( + __e, const_cast(&typeid(_Ex)), + __exception_ptr::__dest_thunk<_Ex2>); + try + { + ::new (__e) _Ex2(__ex); + return exception_ptr(__e); + } + catch(...) + { + __cxxabiv1::__cxa_free_exception(__e); + return current_exception(); + } +# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + } +# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 +} + +} +# 165 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + class nested_exception + { + exception_ptr _M_ptr; + + public: + + nested_exception() noexcept : _M_ptr(current_exception()) { } + + nested_exception(const nested_exception&) noexcept = 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)) + { } + }; +# 145 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + 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"); + + + if constexpr (is_class_v<_Up>) + if constexpr (!is_final_v<_Up>) + if constexpr (!is_base_of_v) + throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; + throw std::forward<_Tp>(__t); + + + + + + } +# 203 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + template + + + + inline void + rethrow_if_nested(const _Ex& __ex) + { + const _Ex* __ptr = __builtin_addressof(__ex); +# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + if constexpr (!is_polymorphic_v<_Ex>) + return; + else if constexpr (is_base_of_v + && !is_convertible_v<_Ex*, nested_exception*>) + return; + + + + + else if (auto __ne_ptr = dynamic_cast(__ptr)) + __ne_ptr->rethrow_nested(); + + } + + +} + +} +# 166 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 2 3 + + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; + + + + inline const _Lock_policy __default_lock_policy = + + + + _S_atomic; + + + + + + + class __concurrence_lock_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_lock_error"; } + }; + + class __concurrence_unlock_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_unlock_error"; } + }; + + class __concurrence_broadcast_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_broadcast_error"; } + }; + + class __concurrence_wait_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_wait_error"; } + }; + + + inline void + __throw_concurrence_lock_error() + { (throw (__concurrence_lock_error())); } + + inline void + __throw_concurrence_unlock_error() + { (throw (__concurrence_unlock_error())); } + + + inline void + __throw_concurrence_broadcast_error() + { (throw (__concurrence_broadcast_error())); } + + inline void + __throw_concurrence_wait_error() + { (throw (__concurrence_wait_error())); } + + + class __mutex + { + private: + + __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } }; + + + + + __mutex(const __mutex&); + __mutex& operator=(const __mutex&); + + public: + __mutex() + { + + + + + } +# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 + void lock() + { + + if (__gthread_active_p()) + { + if (__gthread_mutex_lock(&_M_mutex) != 0) + __throw_concurrence_lock_error(); + } + + } + + void unlock() + { + + if (__gthread_active_p()) + { + if (__gthread_mutex_unlock(&_M_mutex) != 0) + __throw_concurrence_unlock_error(); + } + + } + + __gthread_mutex_t* gthread_mutex(void) + { return &_M_mutex; } + }; + + class __recursive_mutex + { + private: + + __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } }; + + + + + __recursive_mutex(const __recursive_mutex&); + __recursive_mutex& operator=(const __recursive_mutex&); + + public: + __recursive_mutex() + { + + + + + } +# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 + void lock() + { + + if (__gthread_active_p()) + { + if (__gthread_recursive_mutex_lock(&_M_mutex) != 0) + __throw_concurrence_lock_error(); + } + + } + + void unlock() + { + + if (__gthread_active_p()) + { + if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0) + __throw_concurrence_unlock_error(); + } + + } + + __gthread_recursive_mutex_t* gthread_recursive_mutex(void) + { return &_M_mutex; } + }; + + + + + class __scoped_lock + { + public: + typedef __mutex __mutex_type; + + private: + __mutex_type& _M_device; + + __scoped_lock(const __scoped_lock&); + __scoped_lock& operator=(const __scoped_lock&); + + public: + explicit __scoped_lock(__mutex_type& __name) : _M_device(__name) + { _M_device.lock(); } + + ~__scoped_lock() throw() + { _M_device.unlock(); } + }; + + + class __cond + { + private: + + __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } }; + + + + + __cond(const __cond&); + __cond& operator=(const __cond&); + + public: + __cond() + { + + + + + } +# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 + void broadcast() + { + + if (__gthread_active_p()) + { + if (__gthread_cond_broadcast(&_M_cond) != 0) + __throw_concurrence_broadcast_error(); + } + + } + + void wait(__mutex *mutex) + { + + { + if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0) + __throw_concurrence_wait_error(); + } + + } + + void wait_recursive(__recursive_mutex *mutex) + { + + { + if (__gthread_cond_wait_recursive(&_M_cond, + mutex->gthread_recursive_mutex()) + != 0) + __throw_concurrence_wait_error(); + } + + } + }; + + + +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template class auto_ptr; +#pragma GCC diagnostic pop + + + + + + + class bad_weak_ptr : public std::exception + { + public: + virtual char const* what() const noexcept; + + virtual ~bad_weak_ptr() noexcept; + }; + + + inline void + __throw_bad_weak_ptr() + { (throw (bad_weak_ptr())); } + + using __gnu_cxx::_Lock_policy; + using __gnu_cxx::__default_lock_policy; + using __gnu_cxx::_S_single; + using __gnu_cxx::_S_mutex; + using __gnu_cxx::_S_atomic; + + + template<_Lock_policy _Lp> + class _Mutex_base + { + protected: + + enum { _S_need_barriers = 0 }; + }; + + template<> + class _Mutex_base<_S_mutex> + : public __gnu_cxx::__mutex + { + protected: + + + + enum { _S_need_barriers = 1 }; + }; + + template<_Lock_policy _Lp = __default_lock_policy> + class _Sp_counted_base + : public _Mutex_base<_Lp> + { + public: + _Sp_counted_base() noexcept + : _M_use_count(1), _M_weak_count(1) { } + + virtual + ~_Sp_counted_base() noexcept + { } + + + + virtual void + _M_dispose() noexcept = 0; + + + virtual void + _M_destroy() noexcept + { delete this; } + + virtual void* + _M_get_deleter(const std::type_info&) noexcept = 0; + + + void + _M_add_ref_copy() + { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } + + + void + _M_add_ref_lock() + { + if (!_M_add_ref_lock_nothrow()) + __throw_bad_weak_ptr(); + } + + + bool + _M_add_ref_lock_nothrow() noexcept; + + + void + _M_release() noexcept; + + + void + _M_release_last_use() noexcept + { + ; + _M_dispose(); + + + + + if (_Mutex_base<_Lp>::_S_need_barriers) + { + __atomic_thread_fence (4); + } + + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, + -1) == 1) + { + ; + _M_destroy(); + } + } + + + __attribute__((__noinline__)) + void + _M_release_last_use_cold() noexcept + { _M_release_last_use(); } + + + void + _M_weak_add_ref() noexcept + { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } + + + void + _M_weak_release() noexcept + { + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) + { + ; + if (_Mutex_base<_Lp>::_S_need_barriers) + { + + + __atomic_thread_fence (4); + } + _M_destroy(); + } + } + + long + _M_get_use_count() const noexcept + { + + + return __atomic_load_n(&_M_use_count, 0); + } + + private: + _Sp_counted_base(_Sp_counted_base const&) = delete; + _Sp_counted_base& operator=(_Sp_counted_base const&) = delete; + + _Atomic_word _M_use_count; + _Atomic_word _M_weak_count; + }; + + template<> + inline bool + _Sp_counted_base<_S_single>:: + _M_add_ref_lock_nothrow() noexcept + { + if (_M_use_count == 0) + return false; + ++_M_use_count; + return true; + } + + template<> + inline bool + _Sp_counted_base<_S_mutex>:: + _M_add_ref_lock_nothrow() noexcept + { + __gnu_cxx::__scoped_lock sentry(*this); + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) + { + _M_use_count = 0; + return false; + } + return true; + } + + template<> + inline bool + _Sp_counted_base<_S_atomic>:: + _M_add_ref_lock_nothrow() noexcept + { + + _Atomic_word __count = _M_get_use_count(); + do + { + if (__count == 0) + return false; + + + } + while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, + true, 4, + 0)); + return true; + } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_add_ref_copy() + { ++_M_use_count; } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_release() noexcept + { + if (--_M_use_count == 0) + { + _M_dispose(); + if (--_M_weak_count == 0) + _M_destroy(); + } + } + + template<> + inline void + _Sp_counted_base<_S_mutex>::_M_release() noexcept + { + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) + { + _M_release_last_use(); + } + } + + template<> + inline void + _Sp_counted_base<_S_atomic>::_M_release() noexcept + { + ; + + constexpr bool __lock_free + = __atomic_always_lock_free(sizeof(long long), 0) + && __atomic_always_lock_free(sizeof(_Atomic_word), 0); + constexpr bool __double_word + = sizeof(long long) == 2 * sizeof(_Atomic_word); + + + constexpr bool __aligned = __alignof(long long) <= alignof(void*); + if constexpr (__lock_free && __double_word && __aligned) + { + constexpr int __wordbits = 8 * sizeof(_Atomic_word); + constexpr int __shiftbits = __double_word ? __wordbits : 0; + constexpr long long __unique_ref = 1LL + (1LL << __shiftbits); + auto __both_counts = reinterpret_cast(&_M_use_count); + + ; + if (__atomic_load_n(__both_counts, 2) == __unique_ref) + { + + + + + _M_weak_count = _M_use_count = 0; + ; + ; + _M_dispose(); + _M_destroy(); + return; + } + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) + [[__unlikely__]] + { + _M_release_last_use_cold(); + return; + } + } + else + + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) + { + _M_release_last_use(); + } + } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept + { ++_M_weak_count; } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_weak_release() noexcept + { + if (--_M_weak_count == 0) + _M_destroy(); + } + + template<> + inline long + _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept + { return _M_use_count; } + + + + template + class __shared_ptr; + + template + class __weak_ptr; + + template + class __enable_shared_from_this; + + template + class shared_ptr; + + template + class weak_ptr; + + template + struct owner_less; + + template + class enable_shared_from_this; + + template<_Lock_policy _Lp = __default_lock_policy> + class __weak_count; + + template<_Lock_policy _Lp = __default_lock_policy> + class __shared_count; + + + + + + + + template + class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> + { + public: + explicit + _Sp_counted_ptr(_Ptr __p) noexcept + : _M_ptr(__p) { } + + virtual void + _M_dispose() noexcept + { delete _M_ptr; } + + virtual void + _M_destroy() noexcept + { delete this; } + + virtual void* + _M_get_deleter(const std::type_info&) noexcept + { return nullptr; } + + _Sp_counted_ptr(const _Sp_counted_ptr&) = delete; + _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; + + private: + _Ptr _M_ptr; + }; + + template<> + inline void + _Sp_counted_ptr::_M_dispose() noexcept { } + + template<> + inline void + _Sp_counted_ptr::_M_dispose() noexcept { } + + template<> + inline void + _Sp_counted_ptr::_M_dispose() noexcept { } + + + + + + + template + struct _Sp_ebo_helper; + + + template + struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp + { + explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { } + explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { } + + static _Tp& + _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); } + }; + + + template + struct _Sp_ebo_helper<_Nm, _Tp, false> + { + explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { } + explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { } + + static _Tp& + _S_get(_Sp_ebo_helper& __eboh) + { return __eboh._M_tp; } + + private: + _Tp _M_tp; + }; + + + template + class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> + { + class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> + { + typedef _Sp_ebo_helper<0, _Deleter> _Del_base; + typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base; + + public: + _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept + : _Del_base(std::move(__d)), _Alloc_base(__a), _M_ptr(__p) + { } + + _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); } + _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); } + + _Ptr _M_ptr; + }; + + public: + using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>; + + + _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept + : _M_impl(__p, std::move(__d), _Alloc()) { } + + + _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept + : _M_impl(__p, std::move(__d), __a) { } + + ~_Sp_counted_deleter() noexcept { } + + virtual void + _M_dispose() noexcept + { _M_impl._M_del()(_M_impl._M_ptr); } + + virtual void + _M_destroy() noexcept + { + __allocator_type __a(_M_impl._M_alloc()); + __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; + this->~_Sp_counted_deleter(); + } + + virtual void* + _M_get_deleter(const type_info& __ti [[__gnu__::__unused__]]) noexcept + { + + + + return __ti == typeid(_Deleter) + ? std::__addressof(_M_impl._M_del()) + : nullptr; + + + + } + + private: + _Impl _M_impl; + }; + + + + struct _Sp_make_shared_tag + { + private: + template + friend class _Sp_counted_ptr_inplace; + + static const type_info& + _S_ti() noexcept __attribute__ ((__visibility__ ("default"))) + { + alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { }; + return reinterpret_cast(__tag); + } + + static bool _S_eq(const type_info&) noexcept; + }; + + template + struct _Sp_alloc_shared_tag + { + const _Alloc& _M_a; + }; + + template + class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> + { + class _Impl : _Sp_ebo_helper<0, _Alloc> + { + typedef _Sp_ebo_helper<0, _Alloc> _A_base; + + public: + explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { } + + _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); } + + __gnu_cxx::__aligned_buffer<_Tp> _M_storage; + }; + + public: + using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>; + + + template + _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args) + : _M_impl(__a) + { + + + allocator_traits<_Alloc>::construct(__a, _M_ptr(), + std::forward<_Args>(__args)...); + } + + ~_Sp_counted_ptr_inplace() noexcept { } + + virtual void + _M_dispose() noexcept + { + allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr()); + } + + + virtual void + _M_destroy() noexcept + { + __allocator_type __a(_M_impl._M_alloc()); + __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; + this->~_Sp_counted_ptr_inplace(); + } + + private: + friend class __shared_count<_Lp>; + + + + virtual void* + _M_get_deleter(const std::type_info& __ti) noexcept override + { + auto __ptr = const_cast::type*>(_M_ptr()); + + + + + if (&__ti == &_Sp_make_shared_tag::_S_ti() + || + + __ti == typeid(_Sp_make_shared_tag) + + + + ) + return __ptr; + return nullptr; + } + + _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } + + _Impl _M_impl; + }; +# 886 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + struct __sp_array_delete + { + template + void operator()(_Yp* __p) const { delete[] __p; } + }; + + template<_Lock_policy _Lp> + class __shared_count + { + + template + struct __not_alloc_shared_tag { using type = void; }; + + template + struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { }; + + + + + + + public: + constexpr __shared_count() noexcept : _M_pi(0) + { } + + template + explicit + __shared_count(_Ptr __p) : _M_pi(0) + { + try + { + _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); + } + catch(...) + { + delete __p; + throw; + } + } + + template + __shared_count(_Ptr __p, false_type) + : __shared_count(__p) + { } + + template + __shared_count(_Ptr __p, true_type) + : __shared_count(__p, __sp_array_delete{}, allocator()) + { } + + template::type> + __shared_count(_Ptr __p, _Deleter __d) + : __shared_count(__p, std::move(__d), allocator()) + { } + + template::type> + __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0) + { + typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; + try + { + typename _Sp_cd_type::__allocator_type __a2(__a); + auto __guard = std::__allocate_guarded(__a2); + _Sp_cd_type* __mem = __guard.get(); + ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a)); + _M_pi = __mem; + __guard = nullptr; + } + catch(...) + { + __d(__p); + throw; + } + } + + template + __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a, + _Args&&... __args) + { + typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type; + typename _Sp_cp_type::__allocator_type __a2(__a._M_a); + auto __guard = std::__allocate_guarded(__a2); + _Sp_cp_type* __mem = __guard.get(); + auto __pi = ::new (__mem) + _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...); + __guard = nullptr; + _M_pi = __pi; + __p = __pi->_M_ptr(); + } +# 1024 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template + explicit + __shared_count(std::auto_ptr<_Tp>&& __r); +#pragma GCC diagnostic pop + + + + template + explicit + __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0) + { + + + if (__r.get() == nullptr) + return; + + using _Ptr = typename unique_ptr<_Tp, _Del>::pointer; + using _Del2 = __conditional_t::value, + reference_wrapper::type>, + _Del>; + using _Sp_cd_type + = _Sp_counted_deleter<_Ptr, _Del2, allocator, _Lp>; + using _Alloc = allocator<_Sp_cd_type>; + using _Alloc_traits = allocator_traits<_Alloc>; + _Alloc __a; + _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1); + + + + _Alloc_traits::construct(__a, __mem, __r.release(), + std::forward<_Del>(__r.get_deleter())); + _M_pi = __mem; + } + + + explicit __shared_count(const __weak_count<_Lp>& __r); + + + explicit + __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept; + + ~__shared_count() noexcept + { + if (_M_pi != nullptr) + _M_pi->_M_release(); + } + + __shared_count(const __shared_count& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi != nullptr) + _M_pi->_M_add_ref_copy(); + } + + __shared_count& + operator=(const __shared_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != _M_pi) + { + if (__tmp != nullptr) + __tmp->_M_add_ref_copy(); + if (_M_pi != nullptr) + _M_pi->_M_release(); + _M_pi = __tmp; + } + return *this; + } + + void + _M_swap(__shared_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + __r._M_pi = _M_pi; + _M_pi = __tmp; + } + + long + _M_get_use_count() const noexcept + { return _M_pi ? _M_pi->_M_get_use_count() : 0; } + + bool + _M_unique() const noexcept + { return this->_M_get_use_count() == 1; } + + void* + _M_get_deleter(const std::type_info& __ti) const noexcept + { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; } + + bool + _M_less(const __shared_count& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + bool + _M_less(const __weak_count<_Lp>& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + + friend inline bool + operator==(const __shared_count& __a, const __shared_count& __b) noexcept + { return __a._M_pi == __b._M_pi; } + + private: + friend class __weak_count<_Lp>; + + + + + _Sp_counted_base<_Lp>* _M_pi; + }; + + + template<_Lock_policy _Lp> + class __weak_count + { + public: + constexpr __weak_count() noexcept : _M_pi(nullptr) + { } + + __weak_count(const __shared_count<_Lp>& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi != nullptr) + _M_pi->_M_weak_add_ref(); + } + + __weak_count(const __weak_count& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi != nullptr) + _M_pi->_M_weak_add_ref(); + } + + __weak_count(__weak_count&& __r) noexcept + : _M_pi(__r._M_pi) + { __r._M_pi = nullptr; } + + ~__weak_count() noexcept + { + if (_M_pi != nullptr) + _M_pi->_M_weak_release(); + } + + __weak_count& + operator=(const __shared_count<_Lp>& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != nullptr) + __tmp->_M_weak_add_ref(); + if (_M_pi != nullptr) + _M_pi->_M_weak_release(); + _M_pi = __tmp; + return *this; + } + + __weak_count& + operator=(const __weak_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != nullptr) + __tmp->_M_weak_add_ref(); + if (_M_pi != nullptr) + _M_pi->_M_weak_release(); + _M_pi = __tmp; + return *this; + } + + __weak_count& + operator=(__weak_count&& __r) noexcept + { + if (_M_pi != nullptr) + _M_pi->_M_weak_release(); + _M_pi = __r._M_pi; + __r._M_pi = nullptr; + return *this; + } + + void + _M_swap(__weak_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + __r._M_pi = _M_pi; + _M_pi = __tmp; + } + + long + _M_get_use_count() const noexcept + { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; } + + bool + _M_less(const __weak_count& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + bool + _M_less(const __shared_count<_Lp>& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + + friend inline bool + operator==(const __weak_count& __a, const __weak_count& __b) noexcept + { return __a._M_pi == __b._M_pi; } + + private: + friend class __shared_count<_Lp>; + + + + + _Sp_counted_base<_Lp>* _M_pi; + }; + + + template<_Lock_policy _Lp> + inline + __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r) + : _M_pi(__r._M_pi) + { + if (_M_pi == nullptr || !_M_pi->_M_add_ref_lock_nothrow()) + __throw_bad_weak_ptr(); + } + + + template<_Lock_policy _Lp> + inline + __shared_count<_Lp>:: + __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi && !_M_pi->_M_add_ref_lock_nothrow()) + _M_pi = nullptr; + } + + + + + + template + struct __sp_compatible_with + : false_type + { }; + + template + struct __sp_compatible_with<_Yp*, _Tp*> + : is_convertible<_Yp*, _Tp*>::type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]> + : true_type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]> + : true_type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]> + : true_type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]> + : true_type + { }; + + + template + struct __sp_is_constructible_arrN + : false_type + { }; + + template + struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> + : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type + { }; + + + template + struct __sp_is_constructible_arr + : false_type + { }; + + template + struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> + : is_convertible<_Yp(*)[], _Up(*)[]>::type + { }; + + + template + struct __sp_is_constructible; + + + template + struct __sp_is_constructible<_Up[_Nm], _Yp> + : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type + { }; + + + template + struct __sp_is_constructible<_Up[], _Yp> + : __sp_is_constructible_arr<_Up, _Yp>::type + { }; + + + template + struct __sp_is_constructible + : is_convertible<_Yp*, _Tp*>::type + { }; + + + + template::value, bool = is_void<_Tp>::value> + class __shared_ptr_access + { + public: + using element_type = _Tp; + + element_type& + operator*() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(_M_get() != nullptr)) __builtin_unreachable(); } while (false); + return *_M_get(); + } + + element_type* + operator->() const noexcept + { + ; + return _M_get(); + } + + private: + element_type* + _M_get() const noexcept + { return static_cast*>(this)->get(); } + }; + + + template + class __shared_ptr_access<_Tp, _Lp, false, true> + { + public: + using element_type = _Tp; + + element_type* + operator->() const noexcept + { + auto __ptr = static_cast*>(this)->get(); + ; + return __ptr; + } + }; + + + template + class __shared_ptr_access<_Tp, _Lp, true, false> + { + public: + using element_type = typename remove_extent<_Tp>::type; +# 1407 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + element_type& + operator[](ptrdiff_t __i) const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(_M_get() != nullptr)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(!extent<_Tp>::value || __i < extent<_Tp>::value)) __builtin_unreachable(); } while (false); + return _M_get()[__i]; + } + + private: + element_type* + _M_get() const noexcept + { return static_cast*>(this)->get(); } + }; + + template + class __shared_ptr + : public __shared_ptr_access<_Tp, _Lp> + { + public: + using element_type = typename remove_extent<_Tp>::type; + + private: + + template + using _SafeConv + = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type; + + + template + using _Compatible = typename + enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; + + + template + using _Assignable = _Compatible<_Yp, __shared_ptr&>; + + + template::pointer> + using _UniqCompatible = __enable_if_t<__and_< + __sp_compatible_with<_Yp*, _Tp*>, + is_convertible<_Ptr, element_type*>, + is_move_constructible<_Del> + >::value, _Res>; + + + template + using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>; + + public: + + + using weak_type = __weak_ptr<_Tp, _Lp>; + + + constexpr __shared_ptr() noexcept + : _M_ptr(0), _M_refcount() + { } + + template> + explicit + __shared_ptr(_Yp* __p) + : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type()) + { + static_assert( !is_void<_Yp>::value, "incomplete type" ); + static_assert( sizeof(_Yp) > 0, "incomplete type" ); + _M_enable_shared_from_this_with(__p); + } + + template> + __shared_ptr(_Yp* __p, _Deleter __d) + : _M_ptr(__p), _M_refcount(__p, std::move(__d)) + { + static_assert(__is_invocable<_Deleter&, _Yp*&>::value, + "deleter expression d(p) is well-formed"); + _M_enable_shared_from_this_with(__p); + } + + template> + __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) + : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a)) + { + static_assert(__is_invocable<_Deleter&, _Yp*&>::value, + "deleter expression d(p) is well-formed"); + _M_enable_shared_from_this_with(__p); + } + + template + __shared_ptr(nullptr_t __p, _Deleter __d) + : _M_ptr(0), _M_refcount(__p, std::move(__d)) + { } + + template + __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) + : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a)) + { } + + + template + __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r, + element_type* __p) noexcept + : _M_ptr(__p), _M_refcount(__r._M_refcount) + { } + + + template + __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r, + element_type* __p) noexcept + : _M_ptr(__p), _M_refcount() + { + _M_refcount._M_swap(__r._M_refcount); + __r._M_ptr = nullptr; + } + + __shared_ptr(const __shared_ptr&) noexcept = default; + __shared_ptr& operator=(const __shared_ptr&) noexcept = default; + ~__shared_ptr() = default; + + template> + __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) + { } + + __shared_ptr(__shared_ptr&& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount() + { + _M_refcount._M_swap(__r._M_refcount); + __r._M_ptr = nullptr; + } + + template> + __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount() + { + _M_refcount._M_swap(__r._M_refcount); + __r._M_ptr = nullptr; + } + + template> + explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r) + : _M_refcount(__r._M_refcount) + { + + + _M_ptr = __r._M_ptr; + } + + + template> + __shared_ptr(unique_ptr<_Yp, _Del>&& __r) + : _M_ptr(__r.get()), _M_refcount() + { + auto __raw = __to_address(__r.get()); + _M_refcount = __shared_count<_Lp>(std::move(__r)); + _M_enable_shared_from_this_with(__raw); + } +# 1585 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template> + __shared_ptr(auto_ptr<_Yp>&& __r); +#pragma GCC diagnostic pop + + + constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } + + template + _Assignable<_Yp> + operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept + { + _M_ptr = __r._M_ptr; + _M_refcount = __r._M_refcount; + return *this; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _Assignable<_Yp> + operator=(auto_ptr<_Yp>&& __r) + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } +#pragma GCC diagnostic pop + + + __shared_ptr& + operator=(__shared_ptr&& __r) noexcept + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + _Assignable<_Yp> + operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + _UniqAssignable<_Yp, _Del> + operator=(unique_ptr<_Yp, _Del>&& __r) + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + void + reset() noexcept + { __shared_ptr().swap(*this); } + + template + _SafeConv<_Yp> + reset(_Yp* __p) + { + + do { if (std::__is_constant_evaluated() && !bool(__p == nullptr || __p != _M_ptr)) __builtin_unreachable(); } while (false); + __shared_ptr(__p).swap(*this); + } + + template + _SafeConv<_Yp> + reset(_Yp* __p, _Deleter __d) + { __shared_ptr(__p, std::move(__d)).swap(*this); } + + template + _SafeConv<_Yp> + reset(_Yp* __p, _Deleter __d, _Alloc __a) + { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); } + + + element_type* + get() const noexcept + { return _M_ptr; } + + + explicit operator bool() const noexcept + { return _M_ptr != nullptr; } + + + bool + unique() const noexcept + { return _M_refcount._M_unique(); } + + + long + use_count() const noexcept + { return _M_refcount._M_get_use_count(); } + + + void + swap(__shared_ptr<_Tp, _Lp>& __other) noexcept + { + std::swap(_M_ptr, __other._M_ptr); + _M_refcount._M_swap(__other._M_refcount); + } +# 1697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + template + bool + owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept + { return _M_refcount._M_less(__rhs._M_refcount); } + + template + bool + owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept + { return _M_refcount._M_less(__rhs._M_refcount); } + + + protected: + + template + __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) + : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...) + { _M_enable_shared_from_this_with(_M_ptr); } + + template + friend __shared_ptr<_Tp1, _Lp1> + __allocate_shared(const _Alloc& __a, _Args&&... __args); +# 1731 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexcept + : _M_refcount(__r._M_refcount, std::nothrow) + { + _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr; + } + + friend class __weak_ptr<_Tp, _Lp>; + + private: + + template + using __esft_base_t = decltype(__enable_shared_from_this_base( + std::declval&>(), + std::declval<_Yp*>())); + + + template + struct __has_esft_base + : false_type { }; + + template + struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>> + : __not_> { }; + + template::type> + typename enable_if<__has_esft_base<_Yp2>::value>::type + _M_enable_shared_from_this_with(_Yp* __p) noexcept + { + if (auto __base = __enable_shared_from_this_base(_M_refcount, __p)) + __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount); + } + + template::type> + typename enable_if::value>::type + _M_enable_shared_from_this_with(_Yp*) noexcept + { } + + void* + _M_get_deleter(const std::type_info& __ti) const noexcept + { return _M_refcount._M_get_deleter(__ti); } + + template friend class __shared_ptr; + template friend class __weak_ptr; + + template + friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; + + template + friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept; + + + + + + element_type* _M_ptr; + __shared_count<_Lp> _M_refcount; + }; + + + + template + inline bool + operator==(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return __a.get() == __b.get(); } + + template + inline bool + operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !__a; } +# 1817 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + template + inline bool + operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !__a; } + + template + inline bool + operator!=(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return __a.get() != __b.get(); } + + template + inline bool + operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return (bool)__a; } + + template + inline bool + operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return (bool)__a; } + + template + inline bool + operator<(const __shared_ptr<_Tp, _Lp>& __a, + const __shared_ptr<_Up, _Lp>& __b) noexcept + { + using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; + using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type; + using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; + return less<_Vp>()(__a.get(), __b.get()); + } + + template + inline bool + operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { + using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; + return less<_Tp_elt*>()(__a.get(), nullptr); + } + + template + inline bool + operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { + using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; + return less<_Tp_elt*>()(nullptr, __a.get()); + } + + template + inline bool + operator<=(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return !(__b < __a); } + + template + inline bool + operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !(nullptr < __a); } + + template + inline bool + operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !(__a < nullptr); } + + template + inline bool + operator>(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return (__b < __a); } + + template + inline bool + operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return nullptr < __a; } + + template + inline bool + operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return __a < nullptr; } + + template + inline bool + operator>=(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return !(__a < __b); } + + template + inline bool + operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !(__a < nullptr); } + + template + inline bool + operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !(nullptr < __a); } + + + + template + inline void + swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept + { __a.swap(__b); } +# 1927 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + template + inline __shared_ptr<_Tp, _Lp> + static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + using _Sp = __shared_ptr<_Tp, _Lp>; + return _Sp(__r, static_cast(__r.get())); + } + + + + + + + template + inline __shared_ptr<_Tp, _Lp> + const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + using _Sp = __shared_ptr<_Tp, _Lp>; + return _Sp(__r, const_cast(__r.get())); + } + + + + + + + template + inline __shared_ptr<_Tp, _Lp> + dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + using _Sp = __shared_ptr<_Tp, _Lp>; + if (auto* __p = dynamic_cast(__r.get())) + return _Sp(__r, __p); + return _Sp(); + } + + + template + inline __shared_ptr<_Tp, _Lp> + reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + using _Sp = __shared_ptr<_Tp, _Lp>; + return _Sp(__r, reinterpret_cast(__r.get())); + } + + + template + class __weak_ptr + { + template + using _Compatible = typename + enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; + + + template + using _Assignable = _Compatible<_Yp, __weak_ptr&>; + + public: + using element_type = typename remove_extent<_Tp>::type; + + constexpr __weak_ptr() noexcept + : _M_ptr(nullptr), _M_refcount() + { } + + __weak_ptr(const __weak_ptr&) noexcept = default; + + ~__weak_ptr() = default; +# 2009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + template> + __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept + : _M_refcount(__r._M_refcount) + { _M_ptr = __r.lock().get(); } + + template> + __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) + { } + + __weak_ptr(__weak_ptr&& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount)) + { __r._M_ptr = nullptr; } + + template> + __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept + : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount)) + { __r._M_ptr = nullptr; } + + __weak_ptr& + operator=(const __weak_ptr& __r) noexcept = default; + + template + _Assignable<_Yp> + operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept + { + _M_ptr = __r.lock().get(); + _M_refcount = __r._M_refcount; + return *this; + } + + template + _Assignable<_Yp> + operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept + { + _M_ptr = __r._M_ptr; + _M_refcount = __r._M_refcount; + return *this; + } + + __weak_ptr& + operator=(__weak_ptr&& __r) noexcept + { + __weak_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + _Assignable<_Yp> + operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept + { + _M_ptr = __r.lock().get(); + _M_refcount = std::move(__r._M_refcount); + __r._M_ptr = nullptr; + return *this; + } + + __shared_ptr<_Tp, _Lp> + lock() const noexcept + { return __shared_ptr(*this, std::nothrow); } + + long + use_count() const noexcept + { return _M_refcount._M_get_use_count(); } + + bool + expired() const noexcept + { return _M_refcount._M_get_use_count() == 0; } + + template + bool + owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept + { return _M_refcount._M_less(__rhs._M_refcount); } + + template + bool + owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept + { return _M_refcount._M_less(__rhs._M_refcount); } + + void + reset() noexcept + { __weak_ptr().swap(*this); } + + void + swap(__weak_ptr& __s) noexcept + { + std::swap(_M_ptr, __s._M_ptr); + _M_refcount._M_swap(__s._M_refcount); + } + + private: + + void + _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept + { + if (use_count() == 0) + { + _M_ptr = __ptr; + _M_refcount = __refcount; + } + } + + template friend class __shared_ptr; + template friend class __weak_ptr; + friend class __enable_shared_from_this<_Tp, _Lp>; + friend class enable_shared_from_this<_Tp>; + + + + + element_type* _M_ptr; + __weak_count<_Lp> _M_refcount; + }; + + + template + inline void + swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept + { __a.swap(__b); } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept + { return __lhs.owner_before(__rhs); } + + bool + operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept + { return __lhs.owner_before(__rhs); } + + bool + operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept + { return __lhs.owner_before(__rhs); } + }; +#pragma GCC diagnostic pop + + template<> + struct _Sp_owner_less + { + template + auto + operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept + -> decltype(__lhs.owner_before(__rhs)) + { return __lhs.owner_before(__rhs); } + + using is_transparent = void; + }; + + template + struct owner_less<__shared_ptr<_Tp, _Lp>> + : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>> + { }; + + template + struct owner_less<__weak_ptr<_Tp, _Lp>> + : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>> + { }; + + + template + class __enable_shared_from_this + { + protected: + constexpr __enable_shared_from_this() noexcept { } + + __enable_shared_from_this(const __enable_shared_from_this&) noexcept { } + + __enable_shared_from_this& + operator=(const __enable_shared_from_this&) noexcept + { return *this; } + + ~__enable_shared_from_this() { } + + public: + __shared_ptr<_Tp, _Lp> + shared_from_this() + { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } + + __shared_ptr + shared_from_this() const + { return __shared_ptr(this->_M_weak_this); } + + + __weak_ptr<_Tp, _Lp> + weak_from_this() noexcept + { return this->_M_weak_this; } + + __weak_ptr + weak_from_this() const noexcept + { return this->_M_weak_this; } + + + private: + template + void + _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept + { _M_weak_this._M_assign(__p, __n); } + + friend const __enable_shared_from_this* + __enable_shared_from_this_base(const __shared_count<_Lp>&, + const __enable_shared_from_this* __p) + { return __p; } + + template + friend class __shared_ptr; + + mutable __weak_ptr<_Tp, _Lp> _M_weak_this; + }; + + template + inline __shared_ptr<_Tp, _Lp> + __allocate_shared(const _Alloc& __a, _Args&&... __args) + { + static_assert(!is_array<_Tp>::value, "make_shared not supported"); + + return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a}, + std::forward<_Args>(__args)...); + } + + template + inline __shared_ptr<_Tp, _Lp> + __make_shared(_Args&&... __args) + { + typedef typename std::remove_const<_Tp>::type _Tp_nc; + return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(), + std::forward<_Args>(__args)...); + } + + + template + struct hash<__shared_ptr<_Tp, _Lp>> + : public __hash_base> + { + size_t + operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept + { + return hash::element_type*>()( + __s.get()); + } + }; + + +} +# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + inline std::basic_ostream<_Ch, _Tr>& + operator<<(std::basic_ostream<_Ch, _Tr>& __os, + const __shared_ptr<_Tp, _Lp>& __p) + { + __os << __p.get(); + return __os; + } + + template + inline _Del* + get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept + { + + return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); + + + + } + + + + + + template + inline _Del* + get_deleter(const shared_ptr<_Tp>& __p) noexcept + { + + return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); + + + + } +# 111 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + using _NonArray = __enable_if_t::value, _Tp>; +# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + class shared_ptr : public __shared_ptr<_Tp> + { + template + using _Constructible = typename enable_if< + is_constructible<__shared_ptr<_Tp>, _Args...>::value + >::type; + + template + using _Assignable = typename enable_if< + is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr& + >::type; + + public: + + + using element_type = typename __shared_ptr<_Tp>::element_type; + + + + + + using weak_type = weak_ptr<_Tp>; + + + + + + constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } + + shared_ptr(const shared_ptr&) noexcept = default; + + + + + + + + template> + explicit + shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { } +# 229 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template> + shared_ptr(_Yp* __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, std::move(__d)) { } +# 247 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + shared_ptr(nullptr_t __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, std::move(__d)) { } +# 266 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template> + shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) + : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } +# 286 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) + : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } +# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept + : __shared_ptr<_Tp>(__r, __p) { } +# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template&>> + shared_ptr(const shared_ptr<_Yp>& __r) noexcept + : __shared_ptr<_Tp>(__r) { } + + + + + + + shared_ptr(shared_ptr&& __r) noexcept + : __shared_ptr<_Tp>(std::move(__r)) { } + + + + + + + template>> + shared_ptr(shared_ptr<_Yp>&& __r) noexcept + : __shared_ptr<_Tp>(std::move(__r)) { } +# 379 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template&>> + explicit shared_ptr(const weak_ptr<_Yp>& __r) + : __shared_ptr<_Tp>(__r) { } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template>> + shared_ptr(auto_ptr<_Yp>&& __r); +#pragma GCC diagnostic pop + + + + + template>> + shared_ptr(unique_ptr<_Yp, _Del>&& __r) + : __shared_ptr<_Tp>(std::move(__r)) { } +# 412 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } + + shared_ptr& operator=(const shared_ptr&) noexcept = default; + + template + _Assignable&> + operator=(const shared_ptr<_Yp>& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=(__r); + return *this; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _Assignable> + operator=(auto_ptr<_Yp>&& __r) + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } +#pragma GCC diagnostic pop + + + shared_ptr& + operator=(shared_ptr&& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + template + _Assignable> + operator=(shared_ptr<_Yp>&& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + template + _Assignable> + operator=(unique_ptr<_Yp, _Del>&& __r) + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + private: + + template + shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) + : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...) + { } + + template + friend shared_ptr<_NonArray<_Yp>> + allocate_shared(const _Alloc&, _Args&&...); + + template + friend shared_ptr<_NonArray<_Yp>> + make_shared(_Args&&...); +# 535 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) noexcept + : __shared_ptr<_Tp>(__r, std::nothrow) { } + + friend class weak_ptr<_Tp>; + }; + + + template + shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; + template + shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>; + + + + + + + + template + [[__nodiscard__]] inline bool + operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return __a.get() == __b.get(); } + + + template + [[__nodiscard__]] inline bool + operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !__a; } +# 580 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + [[__nodiscard__]] inline bool + operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !__a; } + + + template + [[__nodiscard__]] inline bool + operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return __a.get() != __b.get(); } + + + template + [[__nodiscard__]] inline bool + operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return (bool)__a; } + + + template + [[__nodiscard__]] inline bool + operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return (bool)__a; } + + + template + [[__nodiscard__]] inline bool + operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { + using _Tp_elt = typename shared_ptr<_Tp>::element_type; + using _Up_elt = typename shared_ptr<_Up>::element_type; + using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; + return less<_Vp>()(__a.get(), __b.get()); + } + + + template + [[__nodiscard__]] inline bool + operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { + using _Tp_elt = typename shared_ptr<_Tp>::element_type; + return less<_Tp_elt*>()(__a.get(), nullptr); + } + + + template + [[__nodiscard__]] inline bool + operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { + using _Tp_elt = typename shared_ptr<_Tp>::element_type; + return less<_Tp_elt*>()(nullptr, __a.get()); + } + + + template + [[__nodiscard__]] inline bool + operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return !(__b < __a); } + + + template + [[__nodiscard__]] inline bool + operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !(nullptr < __a); } + + + template + [[__nodiscard__]] inline bool + operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !(__a < nullptr); } + + + template + [[__nodiscard__]] inline bool + operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return (__b < __a); } + + + template + [[__nodiscard__]] inline bool + operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return nullptr < __a; } + + + template + [[__nodiscard__]] inline bool + operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return __a < nullptr; } + + + template + [[__nodiscard__]] inline bool + operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return !(__a < __b); } + + + template + [[__nodiscard__]] inline bool + operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !(__a < nullptr); } + + + template + [[__nodiscard__]] inline bool + operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !(nullptr < __a); } + + + + + + template + inline void + swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept + { __a.swap(__b); } + + + + + template + inline shared_ptr<_Tp> + static_pointer_cast(const shared_ptr<_Up>& __r) noexcept + { + using _Sp = shared_ptr<_Tp>; + return _Sp(__r, static_cast(__r.get())); + } + + + template + inline shared_ptr<_Tp> + const_pointer_cast(const shared_ptr<_Up>& __r) noexcept + { + using _Sp = shared_ptr<_Tp>; + return _Sp(__r, const_cast(__r.get())); + } + + + template + inline shared_ptr<_Tp> + dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept + { + using _Sp = shared_ptr<_Tp>; + if (auto* __p = dynamic_cast(__r.get())) + return _Sp(__r, __p); + return _Sp(); + } + + + + + template + inline shared_ptr<_Tp> + reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept + { + using _Sp = shared_ptr<_Tp>; + return _Sp(__r, reinterpret_cast(__r.get())); + } +# 810 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + class weak_ptr : public __weak_ptr<_Tp> + { + template + using _Constructible = typename enable_if< + is_constructible<__weak_ptr<_Tp>, _Arg>::value + >::type; + + template + using _Assignable = typename enable_if< + is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr& + >::type; + + public: + constexpr weak_ptr() noexcept = default; + + template&>> + weak_ptr(const shared_ptr<_Yp>& __r) noexcept + : __weak_ptr<_Tp>(__r) { } + + weak_ptr(const weak_ptr&) noexcept = default; + + template&>> + weak_ptr(const weak_ptr<_Yp>& __r) noexcept + : __weak_ptr<_Tp>(__r) { } + + weak_ptr(weak_ptr&&) noexcept = default; + + template>> + weak_ptr(weak_ptr<_Yp>&& __r) noexcept + : __weak_ptr<_Tp>(std::move(__r)) { } + + weak_ptr& + operator=(const weak_ptr& __r) noexcept = default; + + template + _Assignable&> + operator=(const weak_ptr<_Yp>& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=(__r); + return *this; + } + + template + _Assignable&> + operator=(const shared_ptr<_Yp>& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=(__r); + return *this; + } + + weak_ptr& + operator=(weak_ptr&& __r) noexcept = default; + + template + _Assignable> + operator=(weak_ptr<_Yp>&& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + shared_ptr<_Tp> + lock() const noexcept + { return shared_ptr<_Tp>(*this, std::nothrow); } + }; + + + template + weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; + + + + + + template + inline void + swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept + { __a.swap(__b); } + + + + template + struct owner_less; + + + template<> + struct owner_less : _Sp_owner_less + { }; + + + template + struct owner_less> + : public _Sp_owner_less, weak_ptr<_Tp>> + { }; + + + template + struct owner_less> + : public _Sp_owner_less, shared_ptr<_Tp>> + { }; + + + + + + + template + class enable_shared_from_this + { + protected: + constexpr enable_shared_from_this() noexcept { } + + enable_shared_from_this(const enable_shared_from_this&) noexcept { } + + enable_shared_from_this& + operator=(const enable_shared_from_this&) noexcept + { return *this; } + + ~enable_shared_from_this() { } + + public: + shared_ptr<_Tp> + shared_from_this() + { return shared_ptr<_Tp>(this->_M_weak_this); } + + shared_ptr + shared_from_this() const + { return shared_ptr(this->_M_weak_this); } + + + + + + + + weak_ptr<_Tp> + weak_from_this() noexcept + { return this->_M_weak_this; } + + weak_ptr + weak_from_this() const noexcept + { return this->_M_weak_this; } + + + + private: + template + void + _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept + { _M_weak_this._M_assign(__p, __n); } + + + friend const enable_shared_from_this* + __enable_shared_from_this_base(const __shared_count<>&, + const enable_shared_from_this* __p) + { return __p; } + + template + friend class __shared_ptr; + + mutable weak_ptr<_Tp> _M_weak_this; + }; +# 988 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + inline shared_ptr<_NonArray<_Tp>> + allocate_shared(const _Alloc& __a, _Args&&... __args) + { + return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, + std::forward<_Args>(__args)...); + } +# 1003 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + inline shared_ptr<_NonArray<_Tp>> + make_shared(_Args&&... __args) + { + using _Alloc = allocator; + _Alloc __a; + return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, + std::forward<_Args>(__args)...); + } +# 1152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + struct hash> + : public __hash_base> + { + size_t + operator()(const shared_ptr<_Tp>& __s) const noexcept + { + return std::hash::element_type*>()(__s.get()); + } + }; + + + + + + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + } + + + +} +# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_lockfree_defines.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_lockfree_defines.h" 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 2 3 +# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + typedef enum memory_order + { + memory_order_relaxed, + memory_order_consume, + memory_order_acquire, + memory_order_release, + memory_order_acq_rel, + memory_order_seq_cst + } memory_order; + + + + enum __memory_order_modifier + { + __memory_order_mask = 0x0ffff, + __memory_order_modifier_mask = 0xffff0000, + __memory_order_hle_acquire = 0x10000, + __memory_order_hle_release = 0x20000 + }; + + + constexpr memory_order + operator|(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(int(__m) | int(__mod)); + } + + constexpr memory_order + operator&(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(int(__m) & int(__mod)); + } + + + + + constexpr memory_order + __cmpexch_failure_order2(memory_order __m) noexcept + { + return __m == memory_order_acq_rel ? memory_order_acquire + : __m == memory_order_release ? memory_order_relaxed : __m; + } + + constexpr memory_order + __cmpexch_failure_order(memory_order __m) noexcept + { + return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask) + | __memory_order_modifier(__m & __memory_order_modifier_mask)); + } + + constexpr bool + __is_valid_cmpexch_failure_order(memory_order __m) noexcept + { + return (__m & __memory_order_mask) != memory_order_release + && (__m & __memory_order_mask) != memory_order_acq_rel; + } + + + template + struct __atomic_base; + + + + inline __attribute__((__always_inline__)) void + atomic_thread_fence(memory_order __m) noexcept + { __atomic_thread_fence(int(__m)); } + + inline __attribute__((__always_inline__)) void + atomic_signal_fence(memory_order __m) noexcept + { __atomic_signal_fence(int(__m)); } + + + template + inline _Tp + kill_dependency(_Tp __y) noexcept + { + _Tp __ret(__y); + return __ret; + } +# 173 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + template + struct atomic; + + template + struct atomic<_Tp*>; + + + + typedef bool __atomic_flag_data_type; +# 198 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + extern "C" { + + struct __atomic_flag_base + { + __atomic_flag_data_type _M_i ; + }; + + } + + + + + + + struct atomic_flag : public __atomic_flag_base + { + atomic_flag() noexcept = default; + ~atomic_flag() noexcept = default; + atomic_flag(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) volatile = delete; + + + constexpr atomic_flag(bool __i) noexcept + : __atomic_flag_base{ _S_init(__i) } + { } + + inline __attribute__((__always_inline__)) bool + test_and_set(memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_test_and_set (&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) bool + test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_test_and_set (&_M_i, int(__m)); + } +# 284 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + inline __attribute__((__always_inline__)) void + clear(memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + __atomic_clear (&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) void + clear(memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + __atomic_clear (&_M_i, int(__m)); + } + + private: + static constexpr __atomic_flag_data_type + _S_init(bool __i) + { return __i ? 1 : 0; } + }; +# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + template + struct __atomic_base + { + using value_type = _ITp; + using difference_type = value_type; + + private: + typedef _ITp __int_type; + + static constexpr int _S_alignment = + sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); + + alignas(_S_alignment) __int_type _M_i ; + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + + constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } + + operator __int_type() const noexcept + { return load(); } + + operator __int_type() const volatile noexcept + { return load(); } + + __int_type + operator=(__int_type __i) noexcept + { + store(__i); + return __i; + } + + __int_type + operator=(__int_type __i) volatile noexcept + { + store(__i); + return __i; + } + + __int_type + operator++(int) noexcept + { return fetch_add(1); } + + __int_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __int_type + operator--(int) noexcept + { return fetch_sub(1); } + + __int_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __int_type + operator++() noexcept + { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + + __int_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + + __int_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + + __int_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + + __int_type + operator+=(__int_type __i) noexcept + { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator+=(__int_type __i) volatile noexcept + { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator-=(__int_type __i) noexcept + { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator-=(__int_type __i) volatile noexcept + { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator&=(__int_type __i) noexcept + { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator&=(__int_type __i) volatile noexcept + { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator|=(__int_type __i) noexcept + { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator|=(__int_type __i) volatile noexcept + { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator^=(__int_type __i) noexcept + { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator^=(__int_type __i) volatile noexcept + { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + bool + is_lock_free() const noexcept + { + + return __atomic_is_lock_free(sizeof(_M_i), + reinterpret_cast(-_S_alignment)); + } + + bool + is_lock_free() const volatile noexcept + { + + return __atomic_is_lock_free(sizeof(_M_i), + reinterpret_cast(-_S_alignment)); + } + + inline __attribute__((__always_inline__)) void + store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_i, __i, int(__m)); + } + + inline __attribute__((__always_inline__)) void + store(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_i, __i, int(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_i, __i, int(__m)); + } + + + inline __attribute__((__always_inline__)) __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_i, __i, int(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } +# 632 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + inline __attribute__((__always_inline__)) __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_and(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_and(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_or(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_or(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } + }; + + + + template + struct __atomic_base<_PTp*> + { + private: + typedef _PTp* __pointer_type; + + __pointer_type _M_p ; + + + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } + + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); } + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + + constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } + + operator __pointer_type() const noexcept + { return load(); } + + operator __pointer_type() const volatile noexcept + { return load(); } + + __pointer_type + operator=(__pointer_type __p) noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator=(__pointer_type __p) volatile noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator++(int) noexcept + { return fetch_add(1); } + + __pointer_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __pointer_type + operator--(int) noexcept + { return fetch_sub(1); } + + __pointer_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __pointer_type + operator++() noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator+=(ptrdiff_t __d) noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + __pointer_type + operator+=(ptrdiff_t __d) volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + __pointer_type + operator-=(ptrdiff_t __d) noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + __pointer_type + operator-=(ptrdiff_t __d) volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + bool + is_lock_free() const noexcept + { + + return __atomic_is_lock_free(sizeof(_M_p), + reinterpret_cast(-__alignof(_M_p))); + } + + bool + is_lock_free() const volatile noexcept + { + + return __atomic_is_lock_free(sizeof(_M_p), + reinterpret_cast(-__alignof(_M_p))); + } + + inline __attribute__((__always_inline__)) void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_p, __p, int(__m)); + } + + inline __attribute__((__always_inline__)) void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_p, __p, int(__m)); + } + + inline __attribute__((__always_inline__)) __pointer_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_p, int(__m)); + } + + inline __attribute__((__always_inline__)) __pointer_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_p, int(__m)); + } + + inline __attribute__((__always_inline__)) __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_p, __p, int(__m)); + } + + + inline __attribute__((__always_inline__)) __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_p, __p, int(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, + int(__m1), int(__m2)); + } +# 935 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + inline __attribute__((__always_inline__)) __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } + }; + + namespace __atomic_impl + { + + + template + constexpr bool + __maybe_has_padding() + { + + return false; + + + + + + + } + + template + inline __attribute__((__always_inline__)) _Tp* + __clear_padding(_Tp& __val) noexcept + { + auto* __ptr = std::__addressof(__val); + + + + + return __ptr; + } + + + template + using _Val = typename remove_volatile<_Tp>::type; + + template + inline __attribute__((__always_inline__)) bool + __compare_exchange(_Tp& __val, _Val<_Tp>& __e, _Val<_Tp>& __i, + bool __is_weak, + memory_order __s, memory_order __f) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__f))) __builtin_unreachable(); } while (false); + + using _Vp = _Val<_Tp>; + + if constexpr (__atomic_impl::__maybe_has_padding<_Vp>()) + { + + + alignas(_Vp) unsigned char __buf[sizeof(_Vp)]; + _Vp* __exp = ::new((void*)__buf) _Vp(__e); + __atomic_impl::__clear_padding(*__exp); + if (__atomic_compare_exchange(std::__addressof(__val), __exp, + __atomic_impl::__clear_padding(__i), + __is_weak, int(__s), int(__f))) + return true; + __builtin_memcpy(std::__addressof(__e), __exp, sizeof(_Vp)); + return false; + } + else + return __atomic_compare_exchange(std::__addressof(__val), + std::__addressof(__e), + std::__addressof(__i), + __is_weak, int(__s), int(__f)); + } + } +# 2021 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 +} +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 2 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + struct _Sp_locker + { + _Sp_locker(const _Sp_locker&) = delete; + _Sp_locker& operator=(const _Sp_locker&) = delete; + + + explicit + _Sp_locker(const void*) noexcept; + _Sp_locker(const void*, const void*) noexcept; + ~_Sp_locker(); + + private: + unsigned char _M_key1; + unsigned char _M_key2; + + + + }; +# 100 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + inline bool + atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p) + { + + return __gthread_active_p() == 0; + + + + } + + template + inline bool + atomic_is_lock_free(const shared_ptr<_Tp>* __p) + { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); } +# 127 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + inline shared_ptr<_Tp> + atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) + { + _Sp_locker __lock{__p}; + return *__p; + } + + template + inline shared_ptr<_Tp> + atomic_load(const shared_ptr<_Tp>* __p) + { return std::atomic_load_explicit(__p, memory_order_seq_cst); } + + template + inline __shared_ptr<_Tp, _Lp> + atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order) + { + _Sp_locker __lock{__p}; + return *__p; + } + + template + inline __shared_ptr<_Tp, _Lp> + atomic_load(const __shared_ptr<_Tp, _Lp>* __p) + { return std::atomic_load_explicit(__p, memory_order_seq_cst); } +# 163 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + inline void + atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, + memory_order) + { + _Sp_locker __lock{__p}; + __p->swap(__r); + } + + template + inline void + atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) + { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } + + template + inline void + atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp> __r, + memory_order) + { + _Sp_locker __lock{__p}; + __p->swap(__r); + } + + template + inline void + atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) + { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } +# 200 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + inline shared_ptr<_Tp> + atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, + memory_order) + { + _Sp_locker __lock{__p}; + __p->swap(__r); + return __r; + } + + template + inline shared_ptr<_Tp> + atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) + { + return std::atomic_exchange_explicit(__p, std::move(__r), + memory_order_seq_cst); + } + + template + inline __shared_ptr<_Tp, _Lp> + atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp> __r, + memory_order) + { + _Sp_locker __lock{__p}; + __p->swap(__r); + return __r; + } + + template + inline __shared_ptr<_Tp, _Lp> + atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) + { + return std::atomic_exchange_explicit(__p, std::move(__r), + memory_order_seq_cst); + } +# 249 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + bool + atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, + shared_ptr<_Tp>* __v, + shared_ptr<_Tp> __w, + memory_order, + memory_order) + { + shared_ptr<_Tp> __x; + _Sp_locker __lock{__p, __v}; + owner_less> __less; + if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) + { + __x = std::move(*__p); + *__p = std::move(__w); + return true; + } + __x = std::move(*__v); + *__v = *__p; + return false; + } + + template + inline bool + atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, + shared_ptr<_Tp> __w) + { + return std::atomic_compare_exchange_strong_explicit(__p, __v, + std::move(__w), memory_order_seq_cst, memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, + shared_ptr<_Tp>* __v, + shared_ptr<_Tp> __w, + memory_order __success, + memory_order __failure) + { + return std::atomic_compare_exchange_strong_explicit(__p, __v, + std::move(__w), __success, __failure); + } + + template + inline bool + atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, + shared_ptr<_Tp> __w) + { + return std::atomic_compare_exchange_weak_explicit(__p, __v, + std::move(__w), memory_order_seq_cst, memory_order_seq_cst); + } + + template + bool + atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp>* __v, + __shared_ptr<_Tp, _Lp> __w, + memory_order, + memory_order) + { + __shared_ptr<_Tp, _Lp> __x; + _Sp_locker __lock{__p, __v}; + owner_less<__shared_ptr<_Tp, _Lp>> __less; + if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) + { + __x = std::move(*__p); + *__p = std::move(__w); + return true; + } + __x = std::move(*__v); + *__v = *__p; + return false; + } + + template + inline bool + atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp>* __v, + __shared_ptr<_Tp, _Lp> __w) + { + return std::atomic_compare_exchange_strong_explicit(__p, __v, + std::move(__w), memory_order_seq_cst, memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp>* __v, + __shared_ptr<_Tp, _Lp> __w, + memory_order __success, + memory_order __failure) + { + return std::atomic_compare_exchange_strong_explicit(__p, __v, + std::move(__w), __success, __failure); + } + + template + inline bool + atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp>* __v, + __shared_ptr<_Tp, _Lp> __w) + { + return std::atomic_compare_exchange_weak_explicit(__p, __v, + std::move(__w), memory_order_seq_cst, memory_order_seq_cst); + } +# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 +} +# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + template + struct auto_ptr_ref + { + _Tp1* _M_ptr; + + explicit + auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } + } __attribute__ ((__deprecated__)); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 92 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + template + class auto_ptr + { + private: + _Tp* _M_ptr; + + public: + + typedef _Tp element_type; + + + + + + + + explicit + auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } +# 118 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } +# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + template + auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } +# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + auto_ptr& + operator=(auto_ptr& __a) throw() + { + reset(__a.release()); + return *this; + } +# 158 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + template + auto_ptr& + operator=(auto_ptr<_Tp1>& __a) throw() + { + reset(__a.release()); + return *this; + } +# 176 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + ~auto_ptr() { delete _M_ptr; } +# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + element_type& + operator*() const throw() + { + do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) __builtin_unreachable(); } while (false); + return *_M_ptr; + } + + + + + + + + element_type* + operator->() const throw() + { + do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) __builtin_unreachable(); } while (false); + return _M_ptr; + \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_bridge.cpp-eb644723.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_bridge.cpp-eb644723.cpp.tmp new file mode 100644 index 0000000..08aaa89 --- /dev/null +++ b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_bridge.cpp-eb644723.cpp.tmp @@ -0,0 +1,6401 @@ +# 1 "src/core/bridge.cpp" +# 1 "" 1 +# 1 "" 3 +# 433 "" 3 +# 1 "" 1 +# 1 "" 2 +# 1 "src/core/bridge.cpp" 2 +# 13 "src/core/bridge.cpp" +# 1 "/usr/include/SDL2/SDL.h" 1 3 4 +# 32 "/usr/include/SDL2/SDL.h" 3 4 +# 1 "/usr/include/SDL2/SDL_main.h" 1 3 4 +# 25 "/usr/include/SDL2/SDL_main.h" 3 4 +# 1 "/usr/include/SDL2/SDL_stdinc.h" 1 3 4 +# 31 "/usr/include/SDL2/SDL_stdinc.h" 3 4 +# 1 "/usr/include/SDL2/SDL_config.h" 1 3 4 +# 32 "/usr/include/SDL2/SDL_config.h" 3 4 +# 1 "/usr/include/SDL2/SDL_platform.h" 1 3 4 +# 229 "/usr/include/SDL2/SDL_platform.h" 3 4 +# 1 "/usr/include/SDL2/begin_code.h" 1 3 4 +# 230 "/usr/include/SDL2/SDL_platform.h" 2 3 4 + + +extern "C" { +# 251 "/usr/include/SDL2/SDL_platform.h" 3 4 +extern __attribute__ ((visibility("default"))) const char * SDL_GetPlatform (void); + + + +} + +# 1 "/usr/include/SDL2/close_code.h" 1 3 4 +# 258 "/usr/include/SDL2/SDL_platform.h" 2 3 4 +# 33 "/usr/include/SDL2/SDL_config.h" 2 3 4 +# 32 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 25 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/features.h" 1 3 4 +# 394 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 395 "/usr/include/features.h" 2 3 4 +# 481 "/usr/include/features.h" 3 4 +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 482 "/usr/include/features.h" 2 3 4 +# 503 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 576 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 577 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 578 "/usr/include/sys/cdefs.h" 2 3 4 +# 504 "/usr/include/features.h" 2 3 4 +# 527 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 528 "/usr/include/features.h" 2 3 4 +# 26 "/usr/include/sys/types.h" 2 3 4 + +extern "C" { + +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 30 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; + + + + +# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/sys/types.h" 2 3 4 + +# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 145 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/sys/types.h" 2 3 4 + + +typedef __uint8_t u_int8_t; +typedef __uint16_t u_int16_t; +typedef __uint32_t u_int32_t; +typedef __uint64_t u_int64_t; + + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 176 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 24 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 35 "/usr/include/bits/endian.h" 3 4 +# 1 "/usr/include/bits/endianness.h" 1 3 4 +# 36 "/usr/include/bits/endian.h" 2 3 4 +# 25 "/usr/include/endian.h" 2 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + + + return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8))); + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + + + return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); + +} +# 69 "/usr/include/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + + + return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56)); + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 5 "/usr/include/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/sys/select.h" 2 3 4 + +# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/sys/select.h" 2 3 4 +# 49 "/usr/include/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/sys/select.h" 3 4 +} +# 180 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/sys/types.h" 2 3 4 + + +} +# 35 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + +# 1 "/usr/include/stdio.h" 1 3 4 +# 27 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/stdio.h" 2 3 4 + +extern "C" { + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 34 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 +# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 37 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4 + + + + +# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 +# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 +typedef struct +{ + int __count; + union + { + unsigned int __wch; + char __wchb[4]; + } __value; +} __mbstate_t; +# 6 "/usr/include/bits/types/__fpos_t.h" 2 3 4 + + + + +typedef struct _G_fpos_t +{ + __off_t __pos; + __mbstate_t __state; +} __fpos_t; +# 40 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4 +# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4 +typedef struct _G_fpos64_t +{ + __off64_t __pos; + __mbstate_t __state; +} __fpos64_t; +# 41 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 + + + +struct _IO_FILE; +typedef struct _IO_FILE __FILE; +# 42 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/FILE.h" 1 3 4 + + + +struct _IO_FILE; + + +typedef struct _IO_FILE FILE; +# 43 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4 +# 35 "/usr/include/bits/types/struct_FILE.h" 3 4 +struct _IO_FILE; +struct _IO_marker; +struct _IO_codecvt; +struct _IO_wide_data; + + + + +typedef void _IO_lock_t; + + + + + +struct _IO_FILE +{ + int _flags; + + + char *_IO_read_ptr; + char *_IO_read_end; + char *_IO_read_base; + char *_IO_write_base; + char *_IO_write_ptr; + char *_IO_write_end; + char *_IO_buf_base; + char *_IO_buf_end; + + + char *_IO_save_base; + char *_IO_backup_base; + char *_IO_save_end; + + struct _IO_marker *_markers; + + struct _IO_FILE *_chain; + + int _fileno; + int _flags2; + __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/bits/types/cookie_io_functions_t.h" 1 3 4 +# 27 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4 +typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, + size_t __nbytes); + + + + + + + +typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, + size_t __nbytes); + + + + + + + +typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); + + +typedef int cookie_close_function_t (void *__cookie); + + + + + + +typedef struct _IO_cookie_io_functions_t +{ + cookie_read_function_t *read; + cookie_write_function_t *write; + cookie_seek_function_t *seek; + cookie_close_function_t *close; +} cookie_io_functions_t; +# 47 "/usr/include/stdio.h" 2 3 4 + + + + + +typedef __gnuc_va_list va_list; +# 84 "/usr/include/stdio.h" 3 4 +typedef __fpos_t fpos_t; + + + + +typedef __fpos64_t fpos64_t; +# 128 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 +# 129 "/usr/include/stdio.h" 2 3 4 +# 148 "/usr/include/stdio.h" 3 4 +extern FILE *stdin; +extern FILE *stdout; +extern FILE *stderr; + + + + + + +extern int remove (const char *__filename) noexcept (true); + +extern int rename (const char *__old, const char *__new) noexcept (true); + + + +extern int renameat (int __oldfd, const char *__old, int __newfd, + const char *__new) noexcept (true); +# 175 "/usr/include/stdio.h" 3 4 +extern int renameat2 (int __oldfd, const char *__old, int __newfd, + const char *__new, unsigned int __flags) noexcept (true); + + + + + + +extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 193 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile (void) + __attribute__ ((__malloc__)) ; +# 205 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile64 (void) + __attribute__ ((__malloc__)) ; + + + +extern char *tmpnam (char[20]) noexcept (true) ; + + + + +extern char *tmpnam_r (char __s[20]) noexcept (true) ; +# 227 "/usr/include/stdio.h" 3 4 +extern char *tempnam (const char *__dir, const char *__pfx) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + + + +extern int fflush (FILE *__stream); +# 244 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 254 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); +# 263 "/usr/include/stdio.h" 3 4 +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) ; + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); +# 288 "/usr/include/stdio.h" 3 4 +extern FILE *fopen64 (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) ; +extern FILE *freopen64 (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); + + + + +extern FILE *fdopen (int __fd, const char *__modes) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern FILE *fopencookie (void *__restrict __magic_cookie, + const char *__restrict __modes, + cookie_io_functions_t __io_funcs) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + +extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + +extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) ; +# 333 "/usr/include/stdio.h" 3 4 +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) noexcept (true); + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) noexcept (true); + + +extern void setlinebuf (FILE *__stream) noexcept (true); + + + + + + + +extern int fprintf (FILE *__restrict __stream, + const char *__restrict __format, ...); + + + + +extern int printf (const char *__restrict __format, ...); + +extern int sprintf (char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); + + + + + +extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg); + + + + +extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); + +extern int vsprintf (char *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) noexcept (true); + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); + + + + + +extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, + __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ; +extern int __asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; +extern int asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; + + + + +extern int vdprintf (int __fd, const char *__restrict __fmt, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__printf__, 2, 0))); +extern int dprintf (int __fd, const char *__restrict __fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); + + + + + + + +extern int fscanf (FILE *__restrict __stream, + const char *__restrict __format, ...) ; + + + + +extern int scanf (const char *__restrict __format, ...) ; + +extern int sscanf (const char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); + + + + + +# 1 "/usr/include/bits/floatn.h" 1 3 4 +# 119 "/usr/include/bits/floatn.h" 3 4 +# 1 "/usr/include/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/bits/floatn-common.h" 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 25 "/usr/include/bits/floatn-common.h" 2 3 4 +# 214 "/usr/include/bits/floatn-common.h" 3 4 +typedef float _Float32; +# 251 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float64; +# 268 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float32x; +# 285 "/usr/include/bits/floatn-common.h" 3 4 +typedef long double _Float64x; +# 120 "/usr/include/bits/floatn.h" 2 3 4 +# 436 "/usr/include/stdio.h" 2 3 4 + + + + +extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") ; + + +extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") ; + +extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf"); +# 486 "/usr/include/stdio.h" 3 4 +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 2, 0))) ; + + + + + +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 1, 0))) ; + + +extern int vsscanf (const char *__restrict __s, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0))); + + + + + + +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))) ; +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf") + + __attribute__ ((__format__ (__scanf__, 1, 0))) ; +extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))); +# 571 "/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); +# 596 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream); +# 607 "/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); +# 623 "/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) + ; +# 673 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) + ; +# 690 "/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); +# 749 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream); +# 760 "/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); +# 794 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence); + + + + +extern __off_t ftello (FILE *__stream) ; +# 818 "/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); +# 837 "/usr/include/stdio.h" 3 4 +extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); +extern __off64_t ftello64 (FILE *__stream) ; +extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); +extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); + + + +extern void clearerr (FILE *__stream) noexcept (true); + +extern int feof (FILE *__stream) noexcept (true) ; + +extern int ferror (FILE *__stream) noexcept (true) ; + + + +extern void clearerr_unlocked (FILE *__stream) noexcept (true); +extern int feof_unlocked (FILE *__stream) noexcept (true) ; +extern int ferror_unlocked (FILE *__stream) noexcept (true) ; + + + + + + + +extern void perror (const char *__s) __attribute__ ((__cold__)); + + + + +extern int fileno (FILE *__stream) noexcept (true) ; + + + + +extern int fileno_unlocked (FILE *__stream) noexcept (true) ; +# 881 "/usr/include/stdio.h" 3 4 +extern int pclose (FILE *__stream); + + + + + +extern FILE *popen (const char *__command, const char *__modes) + __attribute__ ((__malloc__)) ; + + + + + + +extern char *ctermid (char *__s) noexcept (true) + ; + + + + + +extern char *cuserid (char *__s) + ; + + + + +struct obstack; + + +extern int obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); +extern int obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __format, + __gnuc_va_list __args) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); + + + + + + + +extern void flockfile (FILE *__stream) noexcept (true); + + + +extern int ftrylockfile (FILE *__stream) noexcept (true) ; + + +extern void funlockfile (FILE *__stream) noexcept (true); +# 943 "/usr/include/stdio.h" 3 4 +extern int __uflow (FILE *); +extern int __overflow (FILE *, int); +# 960 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio.h" 1 3 4 +# 38 "/usr/include/bits/stdio.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) int +vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) +{ + return vfprintf (stdout, __fmt, __arg); +} + + + +extern __inline __attribute__ ((__gnu_inline__)) int +getchar (void) +{ + return getc (stdin); +} + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +fgetc_unlocked (FILE *__fp) +{ + return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +getc_unlocked (FILE *__fp) +{ + return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int +getchar_unlocked (void) +{ + return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++); +} + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +putchar (int __c) +{ + return putc (__c, stdout); +} + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +fputc_unlocked (int __c, FILE *__stream) +{ + return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +putc_unlocked (int __c, FILE *__stream) +{ + return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int +putchar_unlocked (int __c) +{ + return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c))); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) __ssize_t +getline (char **__lineptr, size_t *__n, FILE *__stream) +{ + return __getdelim (__lineptr, __n, '\n', __stream); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int + feof_unlocked (FILE *__stream) noexcept (true) +{ + return (((__stream)->_flags & 0x0010) != 0); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int + ferror_unlocked (FILE *__stream) noexcept (true) +{ + return (((__stream)->_flags & 0x0020) != 0); +} +# 961 "/usr/include/stdio.h" 2 3 4 + + + + + + +} +# 38 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 1 3 4 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 3 4 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 1 3 4 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__)); + terminate(); + } +#pragma GCC visibility pop +} +# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 +# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 59 "/usr/include/stdlib.h" 3 4 +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 159 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") + + + __attribute__ ((__nonnull__ (1))); +extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); +# 278 "/usr/include/stdlib.h" 3 4 +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 298 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 316 "/usr/include/stdlib.h" 3 4 +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 338 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 339 "/usr/include/stdlib.h" 2 3 4 + +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + + + + + +extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") + + + + __attribute__ ((__nonnull__ (1, 4))); +extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +# 415 "/usr/include/stdlib.h" 3 4 +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 436 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 457 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 480 "/usr/include/stdlib.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) int + atoi (const char *__nptr) noexcept (true) +{ + return (int) strtol (__nptr, (char **) __null, 10); +} +extern __inline __attribute__ ((__gnu_inline__)) long int + atol (const char *__nptr) noexcept (true) +{ + return strtol (__nptr, (char **) __null, 10); +} + + +__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int + atoll (const char *__nptr) noexcept (true) +{ + return strtoll (__nptr, (char **) __null, 10); +} +# 505 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; +# 521 "/usr/include/stdlib.h" 3 4 +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern __uint32_t arc4random (void) + noexcept (true) ; + + +extern void arc4random_buf (void *__buf, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) + noexcept (true) ; + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) ; + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + + ; + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) ; + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 707 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) + ; + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)); + + + +extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 749 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) noexcept (true); +# 814 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 827 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 837 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 849 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 859 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 870 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 881 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 891 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 901 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 913 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 923 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) + ; +# 940 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + +# 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4 +# 19 "/usr/include/bits/stdlib-bsearch.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) void * +bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) +{ + size_t __l, __u, __idx; + const void *__p; + int __comparison; + + __l = 0; + __u = __nmemb; + while (__l < __u) + { + __idx = (__l + __u) / 2; + __p = (const void *) (((const char *) __base) + (__idx * __size)); + __comparison = (*__compar) (__key, __p); + if (__comparison < 0) + __u = __idx; + else if (__comparison > 0) + __l = __idx + 1; + else + { + + + + + return (void *) __p; + + + + } + } + + return __null; +} +# 966 "/usr/include/stdlib.h" 2 3 4 + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; +extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) ; +# 1012 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) noexcept (true); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) noexcept (true); + + +extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) noexcept (true) + ; + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + noexcept (true) + + ; + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 1099 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) noexcept (true); + + + +extern int unlockpt (int __fd) noexcept (true); + + + + +extern char *ptsname (int __fd) noexcept (true) ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) ; + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1155 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 +# 24 "/usr/include/bits/stdlib-float.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) double + atof (const char *__nptr) noexcept (true) +{ + return strtod (__nptr, (char **) __null); +} +# 1156 "/usr/include/stdlib.h" 2 3 4 +# 1167 "/usr/include/stdlib.h" 3 4 +} +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::abs; + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 + inline constexpr double + abs(double __x) + { return __builtin_fabs(__x); } + + inline constexpr float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + abs(long double __x) + { return __builtin_fabsl(__x); } +# 151 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 +} +} +# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + + using ::aligned_alloc; + + using ::atexit; + + + using ::at_quick_exit; + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + using ::quick_exit; + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline ldiv_t + div(long __i, long __j) noexcept { return ldiv(__i, __j); } + + + + +} +# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +# 231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 2 3 4 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + using std::_Exit; + + + + +using std::div_t; +using std::ldiv_t; + +using std::abs; +using std::atof; +using std::atoi; +using std::atol; +using std::bsearch; +using std::calloc; +using std::div; +using std::free; +using std::getenv; +using std::labs; +using std::ldiv; +using std::malloc; + +using std::mblen; +using std::mbstowcs; +using std::mbtowc; + +using std::qsort; +using std::rand; +using std::realloc; +using std::srand; +using std::strtod; +using std::strtol; +using std::strtoul; +using std::system; + +using std::wcstombs; +using std::wctomb; +# 41 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 35 "/usr/lib/clang/16/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 109 "/usr/lib/clang/16/include/stddef.h" 3 4 +# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 4 +# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 4 +typedef struct { + long long __clang_max_align_nonce1 + __attribute__((__aligned__(__alignof__(long long)))); + long double __clang_max_align_nonce2 + __attribute__((__aligned__(__alignof__(long double)))); +} max_align_t; +# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 4 +# 42 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 +# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 +# 22 "/usr/lib/clang/16/include/stdarg.h" 3 4 +typedef __builtin_va_list va_list; +# 43 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 +# 60 "/usr/include/SDL2/SDL_stdinc.h" 3 4 +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/string.h" 2 3 4 + +extern "C" { + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 34 "/usr/include/string.h" 2 3 4 +# 43 "/usr/include/string.h" 3 4 +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + + +extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 80 "/usr/include/string.h" 3 4 +extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void * +memchr (void *__s, int __c, size_t __n) noexcept (true) +{ + return __builtin_memchr (__s, __c, __n); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void * +memchr (const void *__s, int __c, size_t __n) noexcept (true) +{ + return __builtin_memchr (__s, __c, __n); +} + +} +# 115 "/usr/include/string.h" 3 4 +extern "C++" void *rawmemchr (void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + ; +extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + ; +# 141 "/usr/include/string.h" 3 4 +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (2))) ; + + + + + + +extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) + ; + + + + + +extern char *strdup (const char *__s) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 224 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * +strchr (char *__s, int __c) noexcept (true) +{ + return __builtin_strchr (__s, __c); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * +strchr (const char *__s, int __c) noexcept (true) +{ + return __builtin_strchr (__s, __c); +} + +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * +strrchr (char *__s, int __c) noexcept (true) +{ + return __builtin_strrchr (__s, __c); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * +strrchr (const char *__s, int __c) noexcept (true) +{ + return __builtin_strrchr (__s, __c); +} + +} +# 281 "/usr/include/string.h" 3 4 +extern "C++" char *strchrnul (char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 293 "/usr/include/string.h" 3 4 +extern size_t strcspn (const char *__s, const char *__reject) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * +strpbrk (char *__s, const char *__accept) noexcept (true) +{ + return __builtin_strpbrk (__s, __accept); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * +strpbrk (const char *__s, const char *__accept) noexcept (true) +{ + return __builtin_strpbrk (__s, __accept); +} + +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * +strstr (char *__haystack, const char *__needle) noexcept (true) +{ + return __builtin_strstr (__haystack, __needle); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * +strstr (const char *__haystack, const char *__needle) noexcept (true) +{ + return __builtin_strstr (__haystack, __needle); +} + +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 389 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) + + ; + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlen (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern char *strerror (int __errnum) noexcept (true); +# 444 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) ; + + + + +extern const char *strerrordesc_np (int __err) noexcept (true); + +extern const char *strerrorname_np (int __err) noexcept (true); + + + + + +extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); + + + +# 1 "/usr/include/strings.h" 1 3 4 +# 23 "/usr/include/strings.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 24 "/usr/include/strings.h" 2 3 4 + + + + + + +extern "C" { + + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 68 "/usr/include/strings.h" 3 4 +extern char *index (const char *__s, int __c) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 96 "/usr/include/strings.h" 3 4 +extern char *rindex (const char *__s, int __c) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); + + + + + +extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + noexcept (true) __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + +} +# 463 "/usr/include/string.h" 2 3 4 + + + +extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + ; + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) noexcept (true); + + + +extern const char *sigabbrev_np (int __sig) noexcept (true); + + +extern const char *sigdescr_np (int __sig) noexcept (true); + + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlcpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern size_t strlcat (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + + +extern int strverscmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + ; + + + + + + + +extern "C++" char *basename (char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 552 "/usr/include/string.h" 3 4 +} +# 61 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 27 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/wchar.h" 2 3 4 + + + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 36 "/usr/include/wchar.h" 2 3 4 +# 51 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/bits/wchar.h" 1 3 4 +# 52 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 +# 20 "/usr/include/bits/types/wint_t.h" 3 4 +typedef unsigned int wint_t; +# 53 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 + + + + + +typedef __mbstate_t mbstate_t; +# 54 "/usr/include/wchar.h" 2 3 4 +# 90 "/usr/include/wchar.h" 3 4 +extern "C" { + + + +struct tm; + + + +extern wchar_t *wcscpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern wchar_t *wcsncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern size_t wcslcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern size_t wcslcat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern wchar_t *wcscat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern wchar_t *wcsncat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + +extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, + size_t __n) noexcept (true); + + + +extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + +extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + + + +extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + + +extern size_t wcsxfrm (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + + + + + +extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + + + + +extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + +extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) + __attribute__ ((__malloc__)) ; +# 189 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); +# 199 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + +extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) + noexcept (true) __attribute__ ((__pure__)); + + +extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 226 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 237 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + +extern wchar_t *wcstok (wchar_t *__restrict __s, + const wchar_t *__restrict __delim, + wchar_t **__restrict __ptr) noexcept (true); + + +extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); +# 258 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)); +# 278 "/usr/include/wchar.h" 3 4 +extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + + +extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + +extern wchar_t *wmemcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + +extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true); + + +extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); + + + + +extern wchar_t *wmempcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) + noexcept (true); + + + + + +extern wint_t btowc (int __c) noexcept (true); + + + +extern int wctob (wint_t __c) noexcept (true); + + + +extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); + + + +extern size_t mbrtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n, + mbstate_t *__restrict __p) noexcept (true); + + +extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, + mbstate_t *__restrict __ps) noexcept (true); + + +extern size_t __mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); +extern size_t mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + + +extern wint_t __btowc_alias (int __c) __asm ("btowc"); +extern __inline __attribute__ ((__gnu_inline__)) wint_t + btowc (int __c) noexcept (true) +{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' + ? (wint_t) __c : __btowc_alias (__c)); } + +extern int __wctob_alias (wint_t __c) __asm ("wctob"); +extern __inline __attribute__ ((__gnu_inline__)) int + wctob (wint_t __wc) noexcept (true) +{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' + ? (int) __wc : __wctob_alias (__wc)); } + +extern __inline __attribute__ ((__gnu_inline__)) size_t + mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) + +{ return (__ps != __null + ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } + + + + +extern size_t mbsrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + +extern size_t mbsnrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsnrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + +extern int wcwidth (wchar_t __c) noexcept (true); + + + +extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); + + + + + +extern double wcstod (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern float wcstof (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +extern long double wcstold (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 422 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 437 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 455 "/usr/include/wchar.h" 3 4 +extern long int wcstol (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) noexcept (true); + + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + + +extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); +# 561 "/usr/include/wchar.h" 3 4 +extern long int wcstol_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base, + locale_t __loc) noexcept (true); + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true); + + + + + +extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); + + + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); + + + + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); + + + + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); +# 630 "/usr/include/wchar.h" 3 4 +extern double wcstod_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern float wcstof_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern long double wcstold_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 649 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 667 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 689 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcpcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) noexcept (true); + + + +extern wchar_t *wcpncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true); +# 718 "/usr/include/wchar.h" 3 4 +extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern int fwide (__FILE *__fp, int __mode) noexcept (true); + + + + + + +extern int fwprintf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wprintf (const wchar_t *__restrict __format, ...) + ; + +extern int swprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, ...) + noexcept (true) ; + + + + + +extern int vfwprintf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwprintf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + +extern int vswprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; + + + + + + +extern int fwscanf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wscanf (const wchar_t *__restrict __format, ...) + ; + +extern int swscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, ...) + noexcept (true) ; +# 795 "/usr/include/wchar.h" 3 4 +extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") + + + ; +extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") + + ; +extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") + + + ; +# 851 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwscanf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + +extern int vswscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; +# 875 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") + + + ; +extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") + + ; +extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") + + + ; +# 935 "/usr/include/wchar.h" 3 4 +extern wint_t fgetwc (__FILE *__stream); +extern wint_t getwc (__FILE *__stream); + + + + + +extern wint_t getwchar (void); + + + + + + +extern wint_t fputwc (wchar_t __wc, __FILE *__stream); +extern wint_t putwc (wchar_t __wc, __FILE *__stream); + + + + + +extern wint_t putwchar (wchar_t __wc); + + + + + + + +extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + +extern int fputws (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern wint_t ungetwc (wint_t __wc, __FILE *__stream); +# 990 "/usr/include/wchar.h" 3 4 +extern wint_t getwc_unlocked (__FILE *__stream); +extern wint_t getwchar_unlocked (void); + + + + + + + +extern wint_t fgetwc_unlocked (__FILE *__stream); + + + + + + + +extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); +# 1016 "/usr/include/wchar.h" 3 4 +extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); +extern wint_t putwchar_unlocked (wchar_t __wc); +# 1026 "/usr/include/wchar.h" 3 4 +extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + + + +extern int fputws_unlocked (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp) noexcept (true); + + + + +extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); +# 1073 "/usr/include/wchar.h" 3 4 +} +# 67 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + +# 1 "/usr/lib/clang/16/include/inttypes.h" 1 3 4 +# 21 "/usr/lib/clang/16/include/inttypes.h" 3 4 +# 1 "/usr/include/inttypes.h" 1 3 4 +# 27 "/usr/include/inttypes.h" 3 4 +# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 4 +# 52 "/usr/lib/clang/16/include/stdint.h" 3 4 +# 1 "/usr/include/stdint.h" 1 3 4 +# 26 "/usr/include/stdint.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdint.h" 2 3 4 + + +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 30 "/usr/include/stdint.h" 2 3 4 + + + + + + + +# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-uintn.h" 3 4 +typedef __uint8_t uint8_t; +typedef __uint16_t uint16_t; +typedef __uint32_t uint32_t; +typedef __uint64_t uint64_t; +# 38 "/usr/include/stdint.h" 2 3 4 + + + + + +typedef __int_least8_t int_least8_t; +typedef __int_least16_t int_least16_t; +typedef __int_least32_t int_least32_t; +typedef __int_least64_t int_least64_t; + + +typedef __uint_least8_t uint_least8_t; +typedef __uint_least16_t uint_least16_t; +typedef __uint_least32_t uint_least32_t; +typedef __uint_least64_t uint_least64_t; + + + + + +typedef signed char int_fast8_t; + +typedef long int int_fast16_t; +typedef long int int_fast32_t; +typedef long int int_fast64_t; +# 71 "/usr/include/stdint.h" 3 4 +typedef unsigned char uint_fast8_t; + +typedef unsigned long int uint_fast16_t; +typedef unsigned long int uint_fast32_t; +typedef unsigned long int uint_fast64_t; +# 87 "/usr/include/stdint.h" 3 4 +typedef long int intptr_t; + + +typedef unsigned long int uintptr_t; +# 101 "/usr/include/stdint.h" 3 4 +typedef __intmax_t intmax_t; +typedef __uintmax_t uintmax_t; +# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 4 +# 28 "/usr/include/inttypes.h" 2 3 4 +# 327 "/usr/include/inttypes.h" 3 4 +extern "C" { + + + + +typedef struct + { + long int quot; + long int rem; + } imaxdiv_t; +# 351 "/usr/include/inttypes.h" 3 4 +extern intmax_t imaxabs (intmax_t __n) noexcept (true) __attribute__ ((__const__)); + + +extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom) + noexcept (true) __attribute__ ((__const__)); + + +extern intmax_t strtoimax (const char *__restrict __nptr, + char **__restrict __endptr, int __base) noexcept (true); + + +extern uintmax_t strtoumax (const char *__restrict __nptr, + char ** __restrict __endptr, int __base) noexcept (true); + + +extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + +extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, + wchar_t ** __restrict __endptr, int __base) + noexcept (true); + + + + + +extern intmax_t strtoimax (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoimax"); + + +extern uintmax_t strtoumax (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoumax"); + + +extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoimax"); + + + +extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoumax"); +# 415 "/usr/include/inttypes.h" 3 4 +} +# 22 "/usr/lib/clang/16/include/inttypes.h" 2 3 4 +# 70 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + + + +# 1 "/usr/include/ctype.h" 1 3 4 +# 28 "/usr/include/ctype.h" 3 4 +extern "C" { +# 46 "/usr/include/ctype.h" 3 4 +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 251 "/usr/include/ctype.h" 3 4 +extern int isalnum_l (int, locale_t) noexcept (true); +extern int isalpha_l (int, locale_t) noexcept (true); +extern int iscntrl_l (int, locale_t) noexcept (true); +extern int isdigit_l (int, locale_t) noexcept (true); +extern int islower_l (int, locale_t) noexcept (true); +extern int isgraph_l (int, locale_t) noexcept (true); +extern int isprint_l (int, locale_t) noexcept (true); +extern int ispunct_l (int, locale_t) noexcept (true); +extern int isspace_l (int, locale_t) noexcept (true); +extern int isupper_l (int, locale_t) noexcept (true); +extern int isxdigit_l (int, locale_t) noexcept (true); + +extern int isblank_l (int, locale_t) noexcept (true); + + + +extern int __tolower_l (int __c, locale_t __l) noexcept (true); +extern int tolower_l (int __c, locale_t __l) noexcept (true); + + +extern int __toupper_l (int __c, locale_t __l) noexcept (true); +extern int toupper_l (int __c, locale_t __l) noexcept (true); +# 327 "/usr/include/ctype.h" 3 4 +} +# 75 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 +# 86 "/usr/include/SDL2/SDL_stdinc.h" 3 4 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/math.h" 1 3 4 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/math.h" 3 4 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 1 3 4 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; + }; +# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 +} +} +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + +extern "C" { + + + + + +# 1 "/usr/include/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/bits/math-vector.h" 3 4 +# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 152 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4 +# 153 "/usr/include/math.h" 2 3 4 +# 163 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 204 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-logb.h" 1 3 4 +# 205 "/usr/include/math.h" 2 3 4 +# 247 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-fast.h" 1 3 4 +# 248 "/usr/include/math.h" 2 3 4 + + + +enum + { + FP_INT_UPWARD = + + 0, + FP_INT_DOWNWARD = + + 1, + FP_INT_TOWARDZERO = + + 2, + FP_INT_TONEARESTFROMZERO = + + 3, + FP_INT_TONEAREST = + + 4, + }; +# 312 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 313 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true); + + extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true); + + extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true); + + extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true); + + + extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true); + + extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true); + + extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true); + + + + + extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true); + + extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true); + + extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true); + + + + extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true); + + + + + + extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true); + + extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true); + + extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true); + + + + + + extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true); + + +extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true); + + +extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true); + + + extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true); + + + extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true); + + +extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true); + + + + + extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true); + + + extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true); + + +extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true); + + + + + extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true); + + + extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true); + + + + + + + extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true); + + +extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true); + + + + extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true); + + + + + extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true); + + + + + + +extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); extern double __ceil (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); extern double __fabs (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); extern double __floor (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true); +# 183 "/usr/include/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true); +# 220 "/usr/include/bits/mathcalls.h" 3 4 +extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true); +extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true); +extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true); +extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true); +extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true); +extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true); + + + + + + extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true); + extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true); +extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true); + + + + +extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true); + + + + + +extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true); + + + + + + + +extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true); + + + + + + +extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true); + + +extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true); + +extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true); + + + + +extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true); + +extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true); + + + +extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true); + + + +extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true); + + + +extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true); + + + + +extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true); + + + + +extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true); + + + +extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true); + + + +extern double round (double __x) noexcept (true) __attribute__ ((__const__)); extern double __round (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); extern double __trunc (double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true); +__extension__ +extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true); + + + +extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true); +__extension__ +extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true); + + + +extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true); + + + +extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); extern double __roundeven (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalize (double *__cx, const double *__x) noexcept (true); + + + + + + +extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorder (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermag (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true); + + +extern int setpayload (double *__x, double __payload) noexcept (true); + + +extern int setpayloadsig (double *__x, double __payload) noexcept (true); + + + + + + + +extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true); +# 314 "/usr/include/math.h" 2 3 4 +# 329 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 330 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true); + + extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true); + + extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true); + + extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true); + + + extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true); + + extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true); + + extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true); + + + + + extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true); + + extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true); + + extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true); + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); + + + + + + extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true); + + extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true); + + extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true); + + + + + + extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true); + + +extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true); + + +extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true); + + + extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true); + + + extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true); + + +extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true); + + + + + extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true); + + + extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true); + + +extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true); + + + + + extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true); + + + extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true); + + + + + + + extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true); + + +extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true); + + + + extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true); + + + + + extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true); + + + + + + +extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __ceilf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); +# 177 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); +# 213 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true); +extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true); +extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true); +extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true); +extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true); +extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true); + + + + + + extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true); + extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true); +extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true); + + + + +extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true); + + + + + +extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true); + + + + + + + +extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true); + + + + + + +extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true); + + +extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true); + +extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true); + + + + +extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true); + +extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true); + + + +extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true); + + + +extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true); + + + +extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true); + + + + +extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true); + + + + +extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true); + + + +extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true); + + + +extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __truncf (float __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true); +__extension__ +extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true); + + + +extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true); +__extension__ +extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true); + + + +extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true); + + + +extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalizef (float *__cx, const float *__x) noexcept (true); + + + + + + +extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true); + + +extern int setpayloadf (float *__x, float __payload) noexcept (true); + + +extern int setpayloadsigf (float *__x, float __payload) noexcept (true); + + + + + + + +extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true); +# 331 "/usr/include/math.h" 2 3 4 +# 398 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 399 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true); + + extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true); + + extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true); + + extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true); + + + extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true); + + extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true); + + extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true); + + + + + extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true); + + extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true); + + extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true); + + + + extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); + + + + + + extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true); + + extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true); + + extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true); + + + + + + extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true); + + +extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true); + + +extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true); + + + extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true); + + + extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true); + + +extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true); + + + + + extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true); + + + extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true); + + +extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true); + + + + + extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true); + + + extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true); + + + + + + + extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true); + + +extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true); + + + + extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true); + + + + + extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true); + + + + + + +extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __ceill (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); +# 177 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); + + + +extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true); +# 213 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true); +extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true); +extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true); +extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true); + + + + + + extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true); + extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true); +extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true); + + + + +extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true); + + + + + +extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true); + + + + + + + +extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true); + + + + + + +extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true); + + +extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true); + +extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true); + + + + +extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true); + +extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true); + + + +extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true); + + + +extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true); + + + +extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true); + + + + +extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true); + + + + +extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true); + + + +extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true); + + + +extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true); + + + +extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true); +__extension__ +extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true); + + + +extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true); + + + +extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true); + + + + + + +extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true); + + +extern int setpayloadl (long double *__x, long double __payload) noexcept (true); + + +extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true); + + + + + + + +extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true); +# 400 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true); + + + + extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); + + + + + + extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true); + + +extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); + + +extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); + + + extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true); + + + extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true); + + +extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true); + + + + + + + extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); + + +extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true); + + + + extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true); + + + + + + +extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); +# 198 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true); +# 220 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true); +extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true); +extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true); +extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true); + + + + + + extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true); + extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true); +extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true); + + + + +extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true); +# 252 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); + + + + + + +extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true); + + +extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + + +extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true); + +extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); + + + +extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true); + + + + +extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true); + + + + +extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); + + + +extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true); + + + +extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); + + + + +extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true); + + + + + + +extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); + + +extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true); + + +extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true); +# 451 "/usr/include/math.h" 2 3 4 +# 467 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 _ \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/platform/__cpp_inputs.cpp-7e53d83f.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/platform/__cpp_inputs.cpp-7e53d83f.cpp.tmp new file mode 100644 index 0000000..98b8862 --- /dev/null +++ b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/platform/__cpp_inputs.cpp-7e53d83f.cpp.tmp @@ -0,0 +1,38940 @@ +# 1 "src/platform/inputs.cpp" +# 1 "" 1 +# 1 "" 3 +# 433 "" 3 +# 1 "" 1 +# 1 "" 2 +# 1 "src/platform/inputs.cpp" 2 +# 13 "src/platform/inputs.cpp" +# 1 "src/platform/inputs.h" 1 +# 13 "src/platform/inputs.h" +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/compare" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/compare" 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 3 + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__)); + terminate(); + } +#pragma GCC visibility pop +} +# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 3 +# 1 "/usr/include/features.h" 1 3 4 +# 394 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 395 "/usr/include/features.h" 2 3 4 +# 481 "/usr/include/features.h" 3 4 +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 482 "/usr/include/features.h" 2 3 4 +# 503 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 576 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 577 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 578 "/usr/include/sys/cdefs.h" 2 3 4 +# 504 "/usr/include/features.h" 2 3 4 +# 527 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 528 "/usr/include/features.h" 2 3 4 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3 +# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } + + }; + + + + + + + + using true_type = integral_constant; + + + using false_type = integral_constant; + + + + template + using __bool_constant = integral_constant; + + + + + + + template + using bool_constant = integral_constant; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + template + struct is_reference + : public false_type + { }; + + template + struct is_reference<_Tp&> + : public true_type + { }; + + template + struct is_reference<_Tp&&> + : public true_type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long +# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long +# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __is_nothrow_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + template + struct is_same + + : public integral_constant + + + + { }; +# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; +# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_reference + { using type = _Tp; }; + + template + struct remove_reference<_Tp&> + { using type = _Tp; }; + + template + struct remove_reference<_Tp&&> + { using type = _Tp; }; + + + + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { 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; }; +# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; +# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __type; + }; + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; +# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template::value> + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + + template using void_t = void; +# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + + + bool _Dangle = false + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + +template + inline constexpr bool is_array_v = false; +template + inline constexpr bool is_array_v<_Tp[]> = true; +template + inline constexpr bool is_array_v<_Tp[_Num]> = true; + +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; +template + inline constexpr bool is_member_object_pointer_v = + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v = + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); +template + inline constexpr bool is_function_v = is_function<_Tp>::value; +template + inline constexpr bool is_reference_v = false; +template + inline constexpr bool is_reference_v<_Tp&> = true; +template + inline constexpr bool is_reference_v<_Tp&&> = true; +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; +template + inline constexpr bool is_object_v = is_object<_Tp>::value; +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); +# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; + }; +# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 +} +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; + + + + + + + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 +} +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + + inline + + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + + + + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + + + + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { + + template + using _IdxTuple = _Index_tuple<_Indices...>; + + + using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; + + + + + }; + + + + + + + template + struct integer_sequence + { + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + = __make_integer_seq; + + + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + + + + template + struct _Nth_type + { }; + + template + struct _Nth_type<0, _Tp0, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Rest...> + { using type = _Tp1; }; + + template + struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp2; }; + + template + + + + struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> + : _Nth_type<_Np - 3, _Rest...> + { }; + + + template + struct _Nth_type<0, _Tp0, _Tp1, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp1; }; + + + + + + + +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + class tuple; + + template + struct _Index_tuple; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; + + + + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } +# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } +# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iterator_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 +# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 +# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + namespace __detail + { +# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + } +# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } +# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + typename iterator_traits<_InputIterator>::value_type::first_type>; + + template + using __iter_val_t + = typename iterator_traits<_InputIterator>::value_type::second_type; + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +} +# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__res - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } +# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + } +# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { +# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template + + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +} +# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(_Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(const _Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(_Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(const _Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr _Tp* + begin(_Tp (&__arr)[_Nm]) noexcept + { return __arr; } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr _Tp* + end(_Tp (&__arr)[_Nm]) noexcept + { return __arr + _Nm; } + + + + template class valarray; + + template _Tp* begin(valarray<_Tp>&) noexcept; + template const _Tp* begin(const valarray<_Tp>&) noexcept; + template _Tp* end(valarray<_Tp>&) noexcept; + template const _Tp* end(const valarray<_Tp>&) noexcept; + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + constexpr auto + cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) + -> decltype(std::begin(__cont)) + { return std::begin(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + constexpr auto + cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) + -> decltype(std::end(__cont)) + { return std::end(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rbegin(_Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(_Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(const _Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Tp*> + rbegin(_Tp (&__arr)[_Nm]) noexcept + { return reverse_iterator<_Tp*>(__arr + _Nm); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Tp*> + rend(_Tp (&__arr)[_Nm]) noexcept + { return reverse_iterator<_Tp*>(__arr); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator + rbegin(initializer_list<_Tp> __il) noexcept + { return reverse_iterator(__il.end()); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator + rend(initializer_list<_Tp> __il) noexcept + { return reverse_iterator(__il.begin()); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) + { return std::rbegin(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + crend(const _Container& __cont) -> decltype(std::rend(__cont)) + { return std::rend(__cont); } +# 261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + size(const _Container& __cont) noexcept(noexcept(__cont.size())) + -> decltype(__cont.size()) + { return __cont.size(); } + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr size_t + size(const _Tp (&)[_Nm]) noexcept + { return _Nm; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) + -> decltype(__cont.empty()) + { return __cont.empty(); } + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr bool + empty(const _Tp (&)[_Nm]) noexcept + { return false; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr bool + empty(initializer_list<_Tp> __il) noexcept + { return __il.size() == 0;} + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + data(_Container& __cont) noexcept(noexcept(__cont.data())) + -> decltype(__cont.data()) + { return __cont.data(); } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + data(const _Container& __cont) noexcept(noexcept(__cont.data())) + -> decltype(__cont.data()) + { return __cont.data(); } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr _Tp* + data(_Tp (&__array)[_Nm]) noexcept + { return __array; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr const _Tp* + data(initializer_list<_Tp> __il) noexcept + { return __il.begin(); } +# 371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + struct __array_traits + { + using _Type = _Tp[_Nm]; + using _Is_swappable = __is_swappable<_Tp>; + using _Is_nothrow_swappable = __is_nothrow_swappable<_Tp>; + }; + + template + struct __array_traits<_Tp, 0> + { + + struct _Type + { + + __attribute__((__always_inline__,__noreturn__)) + _Tp& operator[](size_t) const noexcept { __builtin_trap(); } + + + __attribute__((__always_inline__)) + constexpr explicit operator _Tp*() const noexcept { return nullptr; } + }; + + using _Is_swappable = true_type; + using _Is_nothrow_swappable = true_type; + }; +# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 + template + struct array + { + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef value_type* iterator; + typedef const value_type* const_iterator; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + + typename __array_traits<_Tp, _Nm>::_Type _M_elems; + + + + + void + fill(const value_type& __u) + { std::fill_n(begin(), size(), __u); } + + void + swap(array& __other) + noexcept(__array_traits<_Tp, _Nm>::_Is_nothrow_swappable::value) + { std::swap_ranges(begin(), end(), __other.begin()); } + + + [[__gnu__::__const__, __nodiscard__]] + constexpr iterator + begin() noexcept + { return iterator(data()); } + + [[__nodiscard__]] + constexpr const_iterator + begin() const noexcept + { return const_iterator(data()); } + + [[__gnu__::__const__, __nodiscard__]] + constexpr iterator + end() noexcept + { return iterator(data() + _Nm); } + + [[__nodiscard__]] + constexpr const_iterator + end() const noexcept + { return const_iterator(data() + _Nm); } + + [[__gnu__::__const__, __nodiscard__]] + constexpr reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + [[__nodiscard__]] + constexpr const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + [[__gnu__::__const__, __nodiscard__]] + constexpr reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + [[__nodiscard__]] + constexpr const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + [[__nodiscard__]] + constexpr const_iterator + cbegin() const noexcept + { return const_iterator(data()); } + + [[__nodiscard__]] + constexpr const_iterator + cend() const noexcept + { return const_iterator(data() + _Nm); } + + [[__nodiscard__]] + constexpr const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + [[__nodiscard__]] + constexpr const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + + [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] + constexpr size_type + size() const noexcept { return _Nm; } + + [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] + constexpr size_type + max_size() const noexcept { return _Nm; } + + [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] + constexpr bool + empty() const noexcept { return size() == 0; } + + + [[__nodiscard__]] + constexpr reference + operator[](size_type __n) noexcept + { + ; + return _M_elems[__n]; + } + + [[__nodiscard__]] + constexpr const_reference + operator[](size_type __n) const noexcept + { + + ; + + return _M_elems[__n]; + } + + constexpr reference + at(size_type __n) + { + if (__n >= _Nm) + std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), + + __n, _Nm); + return _M_elems[__n]; + } + + constexpr const_reference + at(size_type __n) const + { + + + return __n < _Nm ? _M_elems[__n] + : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), + + __n, _Nm), + _M_elems[__n]); + } + + [[__nodiscard__]] + constexpr reference + front() noexcept + { + ; + return _M_elems[(size_type)0]; + } + + [[__nodiscard__]] + constexpr const_reference + front() const noexcept + { + + ; + + return _M_elems[(size_type)0]; + } + + [[__nodiscard__]] + constexpr reference + back() noexcept + { + ; + return _M_elems[_Nm - 1]; + } + + [[__nodiscard__]] + constexpr const_reference + back() const noexcept + { + + ; + + return _M_elems[_Nm - 1]; + } + + [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] + constexpr pointer + data() noexcept + { return static_cast(_M_elems); } + + [[__nodiscard__]] + constexpr const_pointer + data() const noexcept + { return static_cast(_M_elems); } + }; + + + template + array(_Tp, _Up...) + -> array && ...), _Tp>, + 1 + sizeof...(_Up)>; + + + + template + [[__nodiscard__]] + + inline bool + operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return std::equal(__one.begin(), __one.end(), __two.begin()); } +# 322 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 + template + [[__nodiscard__]] + + inline bool + operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one == __two); } + + template + [[__nodiscard__]] + + inline bool + operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) + { + return std::lexicographical_compare(__a.begin(), __a.end(), + __b.begin(), __b.end()); + } + + template + [[__nodiscard__]] + + inline bool + operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return __two < __one; } + + template + [[__nodiscard__]] + + inline bool + operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one > __two); } + + template + [[__nodiscard__]] + + inline bool + operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one < __two); } + + + + template + + inline + + + __enable_if_t<__array_traits<_Tp, _Nm>::_Is_swappable::value> + + + + swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) + noexcept(noexcept(__one.swap(__two))) + { __one.swap(__two); } + + + template + __enable_if_t::_Is_swappable::value> + swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete; + + + template + [[__nodiscard__]] + constexpr _Tp& + get(array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "array index is within bounds"); + return __arr._M_elems[_Int]; + } + + template + [[__nodiscard__]] + constexpr _Tp&& + get(array<_Tp, _Nm>&& __arr) noexcept + { + static_assert(_Int < _Nm, "array index is within bounds"); + return std::move(std::get<_Int>(__arr)); + } + + template + [[__nodiscard__]] + constexpr const _Tp& + get(const array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "array index is within bounds"); + return __arr._M_elems[_Int]; + } + + template + [[__nodiscard__]] + constexpr const _Tp&& + get(const array<_Tp, _Nm>&& __arr) noexcept + { + static_assert(_Int < _Nm, "array index is within bounds"); + return std::move(std::get<_Int>(__arr)); + } +# 460 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<_Ind, array<_Tp, _Nm>> + { + static_assert(_Ind < _Nm, "array index is in range"); + using type = _Tp; + }; + + + template + inline constexpr size_t tuple_size_v> = _Nm; + + template + inline constexpr size_t tuple_size_v> = _Nm; + + + template + struct __is_tuple_like_impl> : true_type + { }; + + +} +# 14 "src/platform/inputs.h" 2 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 1 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 1 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 + template + class allocator; + + template<> + class allocator; + + + + + template + struct uses_allocator; + + template + struct allocator_traits; + + + + + +} +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 1 3 +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 + class exception + { + public: + exception() noexcept { } + virtual ~exception() noexcept; + + exception(const exception&) = default; + exception& operator=(const exception&) = default; + exception(exception&&) = default; + exception& operator=(exception&&) = default; + + + + + virtual const char* + what() const noexcept; + }; + + + +} + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 2 3 + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace std +{ + + + + + + + class bad_alloc : public exception + { + public: + bad_alloc() throw() { } + + + bad_alloc(const bad_alloc&) = default; + bad_alloc& operator=(const bad_alloc&) = default; + + + + + virtual ~bad_alloc() throw(); + + + virtual const char* what() const throw(); + }; + + + class bad_array_new_length : public bad_alloc + { + public: + bad_array_new_length() throw() { } + + + + virtual ~bad_array_new_length() throw(); + + + virtual const char* what() const throw(); + }; + + + + enum class align_val_t: size_t {}; + + + struct nothrow_t + { + + explicit nothrow_t() = default; + + }; + + extern const nothrow_t nothrow; + + + + typedef void (*new_handler)(); + + + + new_handler set_new_handler(new_handler) throw(); + + + + new_handler get_new_handler() noexcept; + +} +# 126 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +[[__nodiscard__]] void* operator new(std::size_t) + __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t) + __attribute__((__externally_visible__)); +void operator delete(void*) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*) noexcept + __attribute__((__externally_visible__)); + + + + + + +[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); + +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete(void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete[](void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete[](void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept +{ return __p; } +[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept +{ return __p; } + + +inline void operator delete (void*, void*) noexcept { } +inline void operator delete[](void*, void*) noexcept { } + +} + + +namespace std +{ + + + + template + [[nodiscard]] constexpr _Tp* + launder(_Tp* __p) noexcept + { return __builtin_launder(__p); } + + + + + template + void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; + template + void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; + + void launder(void*) = delete; + void launder(const void*) = delete; + void launder(volatile void*) = delete; + void launder(const volatile void*) = delete; + + + + + + + +} +# 236 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +#pragma GCC visibility pop +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + template + class __new_allocator + { + public: + typedef _Tp value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + + template + struct rebind + { typedef __new_allocator<_Tp1> other; }; + + + + + + typedef std::true_type propagate_on_container_move_assignment; + + + __attribute__((__always_inline__)) + + __new_allocator() noexcept { } + + __attribute__((__always_inline__)) + + __new_allocator(const __new_allocator&) noexcept { } + + template + __attribute__((__always_inline__)) + + __new_allocator(const __new_allocator<_Tp1>&) noexcept { } + + + ~__new_allocator() noexcept { } + + pointer + address(reference __x) const noexcept + { return std::__addressof(__x); } + + const_pointer + address(const_reference __x) const noexcept + { return std::__addressof(__x); } +# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + [[__nodiscard__]] _Tp* + allocate(size_type __n, const void* = static_cast(0)) + { + + + + static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); + + + if (__builtin_expect(__n > this->_M_max_size(), false)) + { + + + if (__n > (std::size_t(-1) / sizeof(_Tp))) + std::__throw_bad_array_new_length(); + std::__throw_bad_alloc(); + } + + + if (alignof(_Tp) > 16UL) + { + std::align_val_t __al = std::align_val_t(alignof(_Tp)); + return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp), + __al)); + } + + return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp))); + } + + + void + deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) + { + + + + + + + + if (alignof(_Tp) > 16UL) + { + __builtin_operator_delete((__p), + std::align_val_t(alignof(_Tp))); + return; + } + + __builtin_operator_delete((__p)); + } + + + + + + + __attribute__((__always_inline__)) + size_type + max_size() const noexcept + { return _M_max_size(); } + + + template + __attribute__((__always_inline__)) + void + construct(_Up* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + __attribute__((__always_inline__)) + void + destroy(_Up* __p) + noexcept(std::is_nothrow_destructible<_Up>::value) + { __p->~_Up(); } +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + template + friend __attribute__((__always_inline__)) bool + operator==(const __new_allocator&, const __new_allocator<_Up>&) + noexcept + { return true; } + + + template + friend __attribute__((__always_inline__)) bool + operator!=(const __new_allocator&, const __new_allocator<_Up>&) + noexcept + { return false; } + + + private: + __attribute__((__always_inline__)) + constexpr size_type + _M_max_size() const noexcept + { + + return std::size_t(9223372036854775807L) / sizeof(_Tp); + + + + } + }; + + +} +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3 + + +namespace std +{ +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 + template + using __allocator_base = __new_allocator<_Tp>; +} +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + template<> + class allocator + { + public: + typedef void value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + + + typedef void* pointer; + typedef const void* const_pointer; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + using propagate_on_container_move_assignment = true_type; + + using is_always_equal + + = true_type; +# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + }; +# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + template + class allocator : public __allocator_base<_Tp> + { + public: + typedef _Tp value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + + + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + using propagate_on_container_move_assignment = true_type; + + using is_always_equal + + = true_type; + + + + + __attribute__((__always_inline__)) + + allocator() noexcept { } + + __attribute__((__always_inline__)) + + allocator(const allocator& __a) noexcept + : __allocator_base<_Tp>(__a) { } + + + + allocator& operator=(const allocator&) = default; + + + template + __attribute__((__always_inline__)) + + allocator(const allocator<_Tp1>&) noexcept { } + + __attribute__((__always_inline__)) + + + + ~allocator() noexcept { } +# 214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + friend __attribute__((__always_inline__)) + bool + operator==(const allocator&, const allocator&) noexcept + { return true; } + + + friend __attribute__((__always_inline__)) + bool + operator!=(const allocator&, const allocator&) noexcept + { return false; } + + + + }; + + + + + + + template + __attribute__((__always_inline__)) + inline bool + operator==(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return true; } + + + template + __attribute__((__always_inline__)) + inline bool + operator!=(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return false; } + + + + + + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + + + + + + + extern template class allocator; + extern template class allocator; + + + + + + +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 1 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 1 3 +# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + inline void + destroy_at(_Tp* __location) + { + if constexpr (201703L > 201703L && is_array_v<_Tp>) + { + for (auto& __x : *__location) + std::destroy_at(std::__addressof(__x)); + } + else + __location->~_Tp(); + } +# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + template + + inline void + _Construct(_Tp* __p, _Args&&... __args) + { +# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + } +# 132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + template + inline void + _Construct_novalue(_T1* __p) + { ::new((void*)__p) _T1; } + + template + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last); + + + + + template + constexpr inline void + _Destroy(_Tp* __pointer) + { + + + + __pointer->~_Tp(); + + } + + template + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator __first, _ForwardIterator __last) + { + for (; __first != __last; ++__first) + std::_Destroy(std::__addressof(*__first)); + } + }; + + template<> + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator, _ForwardIterator) { } + }; + + + + + + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: + __destroy(__first, __last); + } + + template + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + for (; __count > 0; (void)++__first, --__count) + std::_Destroy(std::__addressof(*__first)); + return __first; + } + }; + + template<> + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + std::advance(__first, __count); + return __first; + } + }; + + + + + + + template + inline _ForwardIterator + _Destroy_n(_ForwardIterator __first, _Size __count) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: + __destroy_n(__first, __count); + } + + + template + inline void + destroy(_ForwardIterator __first, _ForwardIterator __last) + { + std::_Destroy(__first, __last); + } + + template + inline _ForwardIterator + destroy_n(_ForwardIterator __first, _Size __count) + { + return std::_Destroy_n(__first, __count); + } + + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + namespace __detail + { + template + inline void + __return_temporary_buffer(_Tp* __p, + size_t __len __attribute__((__unused__))) + { + + + + ::operator delete(__p); + + } + } +# 101 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 + template + [[__deprecated__]] + pair<_Tp*, ptrdiff_t> + get_temporary_buffer(ptrdiff_t __len) noexcept + { + const ptrdiff_t __max = + __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); + if (__len > __max) + __len = __max; + + while (__len > 0) + { + _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), + std::nothrow)); + if (__tmp != 0) + return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); + __len = __len == 1 ? 0 : ((__len + 1) / 2); + } + return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); + } +# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 + template + inline void + return_temporary_buffer(_Tp* __p) + { ::operator delete(__p); } + + + + + + + template + class _Temporary_buffer + { + + + + public: + typedef _Tp value_type; + typedef value_type* pointer; + typedef pointer iterator; + typedef ptrdiff_t size_type; + + protected: + size_type _M_original_len; + size_type _M_len; + pointer _M_buffer; + + public: + + size_type + size() const + { return _M_len; } + + + size_type + requested_size() const + { return _M_original_len; } + + + iterator + begin() + { return _M_buffer; } + + + iterator + end() + { return _M_buffer + _M_len; } + + + + + + _Temporary_buffer(_ForwardIterator __seed, size_type __original_len); + + ~_Temporary_buffer() + { + std::_Destroy(_M_buffer, _M_buffer + _M_len); + std::__detail::__return_temporary_buffer(_M_buffer, _M_len); + } + + private: + + _Temporary_buffer(const _Temporary_buffer&); + + void + operator=(const _Temporary_buffer&); + }; + + + template + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + if (__first == __last) + return; + + _Pointer __cur = __first; + try + { + std::_Construct(std::__addressof(*__first), + std::move(*__seed)); + _Pointer __prev = __cur; + ++__cur; + for(; __cur != __last; ++__cur, ++__prev) + std::_Construct(std::__addressof(*__cur), + std::move(*__prev)); + *__seed = std::move(*__prev); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_construct_buf_dispatch + { + template + static void + __ucr(_Pointer, _Pointer, _ForwardIterator) { } + }; +# 247 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 + template + inline void + __uninitialized_construct_buf(_Pointer __first, _Pointer __last, + _ForwardIterator __seed) + { + typedef typename std::iterator_traits<_Pointer>::value_type + _ValueType; + + std::__uninitialized_construct_buf_dispatch< + __has_trivial_constructor(_ValueType)>:: + __ucr(__first, __last, __seed); + } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _Temporary_buffer<_ForwardIterator, _Tp>:: + _Temporary_buffer(_ForwardIterator __seed, size_type __original_len) + : _M_original_len(__original_len), _M_len(0), _M_buffer(0) + { + std::pair __p( + std::get_temporary_buffer(_M_original_len)); + + if (__p.first) + { + try + { + std::__uninitialized_construct_buf(__p.first, __p.first + __p.second, + __seed); + _M_buffer = __p.first; + _M_len = __p.second; + } + catch(...) + { + std::__detail::__return_temporary_buffer(__p.first, __p.second); + throw; + } + } + } +#pragma GCC diagnostic pop + + +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 1 3 +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 1 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + struct __allocator_traits_base + { + template + struct __rebind : __replace_first_arg<_Tp, _Up> + { + static_assert(is_same< + typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, + _Tp>::value, + "allocator_traits::rebind_alloc must be A"); + }; + + template + struct __rebind<_Tp, _Up, + __void_t::other>> + { + using type = typename _Tp::template rebind<_Up>::other; + + static_assert(is_same< + typename _Tp::template rebind::other, + _Tp>::value, + "allocator_traits::rebind_alloc must be A"); + }; + + protected: + template + using __pointer = typename _Tp::pointer; + template + using __c_pointer = typename _Tp::const_pointer; + template + using __v_pointer = typename _Tp::void_pointer; + template + using __cv_pointer = typename _Tp::const_void_pointer; + template + using __pocca = typename _Tp::propagate_on_container_copy_assignment; + template + using __pocma = typename _Tp::propagate_on_container_move_assignment; + template + using __pocs = typename _Tp::propagate_on_container_swap; + template + using __equal = __type_identity; + }; + + template + using __alloc_rebind + = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; +# 104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct allocator_traits : __allocator_traits_base + { + + typedef _Alloc allocator_type; + + typedef typename _Alloc::value_type value_type; + + + + + + + using pointer = __detected_or_t; + + private: + + template class _Func, typename _Tp, typename = void> + struct _Ptr + { + using type = typename pointer_traits::template rebind<_Tp>; + }; + + template class _Func, typename _Tp> + struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> + { + using type = _Func<_Alloc>; + }; + + + template + struct _Diff + { using type = typename pointer_traits<_PtrT>::difference_type; }; + + template + struct _Diff<_A2, _PtrT, __void_t> + { using type = typename _A2::difference_type; }; + + + template + struct _Size : make_unsigned<_DiffT> { }; + + template + struct _Size<_A2, _DiffT, __void_t> + { using type = typename _A2::size_type; }; + + public: + + + + + + + using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; + + + + + + + + using void_pointer = typename _Ptr<__v_pointer, void>::type; + + + + + + + + using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; + + + + + + + + using difference_type = typename _Diff<_Alloc, pointer>::type; + + + + + + + + using size_type = typename _Size<_Alloc, difference_type>::type; + + + + + + + + using propagate_on_container_copy_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_move_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_swap + = __detected_or_t; + + + + + + + + using is_always_equal + = typename __detected_or_t, __equal, _Alloc>::type; + + template + using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; + template + using rebind_traits = allocator_traits>; + + private: + template + static constexpr auto + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) + -> decltype(__a.allocate(__n, __hint)) + { return __a.allocate(__n, __hint); } + + template + static constexpr pointer + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) + { return __a.allocate(__n); } + + template + struct __construct_helper + { + template()->construct( + std::declval<_Tp*>(), std::declval<_Args>()...))> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc>(0)); + }; + + template + using __has_construct + = typename __construct_helper<_Tp, _Args...>::type; + + template + static constexpr _Require<__has_construct<_Tp, _Args...>> + _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) + { __a.construct(__p, std::forward<_Args>(__args)...); } + + template + static constexpr + _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, + is_constructible<_Tp, _Args...>>> + _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) + { + + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + + + + } + + template + static constexpr auto + _S_destroy(_Alloc2& __a, _Tp* __p, int) + noexcept(noexcept(__a.destroy(__p))) + -> decltype(__a.destroy(__p)) + { __a.destroy(__p); } + + template + static constexpr void + _S_destroy(_Alloc2&, _Tp* __p, ...) + noexcept(std::is_nothrow_destructible<_Tp>::value) + { std::_Destroy(__p); } + + template + static constexpr auto + _S_max_size(_Alloc2& __a, int) + -> decltype(__a.max_size()) + { return __a.max_size(); } + + template + static constexpr size_type + _S_max_size(_Alloc2&, ...) + { + + + return __gnu_cxx::__numeric_traits::__max + / sizeof(value_type); + } + + template + static constexpr auto + _S_select(_Alloc2& __a, int) + -> decltype(__a.select_on_container_copy_construction()) + { return __a.select_on_container_copy_construction(); } + + template + static constexpr _Alloc2 + _S_select(_Alloc2& __a, ...) + { return __a; } + + public: +# 331 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n) + { return __a.allocate(__n); } +# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) + { return _S_allocate(__a, __n, __hint, 0); } +# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static void + deallocate(_Alloc& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 373 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + static auto + construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(_S_construct(__a, __p, + std::forward<_Args>(__args)...))) + -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) + { _S_construct(__a, __p, std::forward<_Args>(__args)...); } +# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + static void + destroy(_Alloc& __a, _Tp* __p) + noexcept(noexcept(_S_destroy(__a, __p, 0))) + { _S_destroy(__a, __p, 0); } +# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static size_type + max_size(const _Alloc& __a) noexcept + { return _S_max_size(__a, 0); } +# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static _Alloc + select_on_container_copy_construction(const _Alloc& __rhs) + { return _S_select(__rhs, 0); } + }; +# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct allocator_traits> + { + + using allocator_type = allocator<_Tp>; + + + using value_type = _Tp; + + + using pointer = _Tp*; + + + using const_pointer = const _Tp*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + using propagate_on_container_copy_assignment = false_type; + + + using propagate_on_container_move_assignment = true_type; + + + using propagate_on_container_swap = false_type; + + + using is_always_equal = true_type; + + template + using rebind_alloc = allocator<_Up>; + + template + using rebind_traits = allocator_traits>; +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) + { + + return __a.allocate(__n, __hint); + + + + } +# 513 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__gnu__::__always_inline__]] + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, + _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { + + __a.construct(__p, std::forward<_Args>(__args)...); + + + + } +# 550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { + + __a.destroy(__p); + + + + } + + + + + + + [[__gnu__::__always_inline__]] + static size_type + max_size(const allocator_type& __a __attribute__((__unused__))) noexcept + { + + return __a.max_size(); + + + + } + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; + + + template<> + struct allocator_traits> + { + + using allocator_type = allocator; + + + using value_type = void; + + + using pointer = void*; + + + using const_pointer = const void*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + using propagate_on_container_copy_assignment = false_type; + + + using propagate_on_container_move_assignment = true_type; + + + using propagate_on_container_swap = false_type; + + + using is_always_equal = true_type; + + template + using rebind_alloc = allocator<_Up>; + + template + using rebind_traits = allocator_traits>; + + + static void* + allocate(allocator_type&, size_type, const void* = nullptr) = delete; + + + static void + deallocate(allocator_type&, void*, size_type) = delete; +# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type&, _Up* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { std::_Construct(__p, std::forward<_Args>(__args)...); } +# 669 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + destroy(allocator_type&, _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { std::_Destroy(__p); } + + + static size_type + max_size(const allocator_type&) = delete; + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; +# 707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_copy(_Alloc& __one, const _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocca = + typename __traits::propagate_on_container_copy_assignment::type; + + if constexpr (__pocca::value) + __one = __two; + + + + } + + template + [[__gnu__::__always_inline__]] + constexpr _Alloc + __alloc_on_copy(const _Alloc& __a) + { + typedef allocator_traits<_Alloc> __traits; + return __traits::select_on_container_copy_construction(__a); + } +# 744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_move(_Alloc& __one, _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocma + = typename __traits::propagate_on_container_move_assignment::type; + + if constexpr (__pocma::value) + __one = std::move(__two); + + + + } +# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_swap(_Alloc& __one, _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocs = typename __traits::propagate_on_container_swap::type; + + if constexpr (__pocs::value) + { + using std::swap; + swap(__one, __two); + } + + + + } + + template, + typename = void> + struct __is_alloc_insertable_impl + : false_type + { }; + + template + struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, + __void_t::construct( + std::declval<_Alloc&>(), std::declval<_ValueT*>(), + std::declval<_Tp>()))>> + : true_type + { }; + + + + + template + struct __is_copy_insertable + : __is_alloc_insertable_impl<_Alloc, + typename _Alloc::value_type const&>::type + { }; + + + + template + struct __is_copy_insertable> + : is_copy_constructible<_Tp> + { }; + + + + + + template + struct __is_move_insertable + : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type + { }; + + + + template + struct __is_move_insertable> + : is_move_constructible<_Tp> + { }; + + + + template + struct __is_allocator : false_type { }; + + template + struct __is_allocator<_Alloc, + __void_t().allocate(size_t{}))>> + : true_type { }; + + template + using _RequireAllocator + = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; + + template + using _RequireNotAllocator + = typename enable_if::value, _Alloc>::type; +# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct __alloc_swap + { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; + + template + struct __alloc_swap<_Alloc, false> + { + static void + _S_do_it(_Alloc& __one, _Alloc& __two) noexcept + { + + if (__one != __two) + swap(__one, __two); + } + }; + + + template, + is_nothrow_move_constructible>::value> + struct __shrink_to_fit_aux + { static bool _S_do_it(_Tp&) noexcept { return false; } }; + + template + struct __shrink_to_fit_aux<_Tp, true> + { + + static bool + _S_do_it(_Tp& __c) noexcept + { + + try + { + _Tp(__make_move_if_noexcept_iterator(__c.begin()), + __make_move_if_noexcept_iterator(__c.end()), + __c.get_allocator()).swap(__c); + return true; + } + catch(...) + { return false; } + + + + } + }; +# 925 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + _Allocator& __alloc) + { + for (; __first != __last; ++__first) + + + + allocator_traits<_Allocator>::destroy(__alloc, + std::__addressof(*__first)); + + } + + + template + __attribute__((__always_inline__)) + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + allocator<_Tp>&) + { + std::_Destroy(__first, __last); + } + + + + +} +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + + + +template + struct __alloc_traits + + : std::allocator_traits<_Alloc> + + { + typedef _Alloc allocator_type; + + typedef std::allocator_traits<_Alloc> _Base_type; + typedef typename _Base_type::value_type value_type; + typedef typename _Base_type::pointer pointer; + typedef typename _Base_type::const_pointer const_pointer; + typedef typename _Base_type::size_type size_type; + typedef typename _Base_type::difference_type difference_type; + + typedef value_type& reference; + typedef const value_type& const_reference; + using _Base_type::allocate; + using _Base_type::deallocate; + using _Base_type::construct; + using _Base_type::destroy; + using _Base_type::max_size; + + private: + template + using __is_custom_pointer + = std::__and_, + std::__not_>>; + + public: + + template + [[__gnu__::__always_inline__]] + static constexpr + std::__enable_if_t<__is_custom_pointer<_Ptr>::value> + construct(_Alloc& __a, _Ptr __p, _Args&&... __args) + noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), + std::forward<_Args>(__args)...))) + { + _Base_type::construct(__a, std::__to_address(__p), + std::forward<_Args>(__args)...); + } + + + template + [[__gnu__::__always_inline__]] + static constexpr + std::__enable_if_t<__is_custom_pointer<_Ptr>::value> + destroy(_Alloc& __a, _Ptr __p) + noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) + { _Base_type::destroy(__a, std::__to_address(__p)); } + + [[__gnu__::__always_inline__]] + static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) + { return _Base_type::select_on_container_copy_construction(__a); } + + [[__gnu__::__always_inline__]] + static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) + { std::__alloc_on_swap(__a, __b); } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_copy_assign() + { return _Base_type::propagate_on_container_copy_assignment::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_move_assign() + { return _Base_type::propagate_on_container_move_assignment::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_swap() + { return _Base_type::propagate_on_container_swap::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_always_equal() + { return _Base_type::is_always_equal::value; } + + __attribute__((__always_inline__)) + static constexpr bool _S_nothrow_move() + { return _S_propagate_on_move_assign() || _S_always_equal(); } + + template + struct rebind + { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; +# 180 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 + }; + + +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + constexpr bool + __check_constructible() + { + + + + + + static_assert(is_constructible<_ValueType, _Tp>::value, + "result type must be constructible from input type"); + + return true; + } +# 110 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + + _ForwardIterator + __do_uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + _ForwardIterator __cur = __result; + try + { + for (; __first != __last; ++__first, (void)++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + catch(...) + { + std::_Destroy(__result, __cur); + throw; + } + } + + template + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { return std::__do_uninit_copy(__first, __last, __result); } + }; + + template<> + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { return std::copy(__first, __last, __result); } + }; +# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + typedef typename iterator_traits<_InputIterator>::value_type + _ValueType1; + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType2; + + + + + const bool __can_memmove = __is_trivial(_ValueType1); + + + + + using _From = decltype(*__first); + + const bool __assignable + = __is_trivial(_ValueType2) && __is_assignable(_ValueType2&, _From) && std::__check_constructible<_ValueType2, _From>(); + + return std::__uninitialized_copy<__can_memmove && __assignable>:: + __uninit_copy(__first, __last, __result); + } + + + + template + void + __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + _ForwardIterator __cur = __first; + try + { + for (; __cur != __last; ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + + template + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { std::__do_uninit_fill(__first, __last, __x); } + }; + + template<> + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { std::fill(__first, __last, __x); } + }; +# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline void + uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + const bool __can_fill + = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>(); + + std::__uninitialized_fill<__can_fill>:: + __uninit_fill(__first, __last, __x); + } + + + + template + + _ForwardIterator + __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) + { + _ForwardIterator __cur = __first; + try + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + + template + struct __uninitialized_fill_n + { + template + static _ForwardIterator + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { return std::__do_uninit_fill_n(__first, __n, __x); } + }; + + template<> + struct __uninitialized_fill_n + { + template + static _ForwardIterator + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { return std::fill_n(__first, __n, __x); } + }; +# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + const bool __can_fill + = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>() + + + + && __is_integer<_Size>::__value; + + return __uninitialized_fill_n<__can_fill>:: + __uninit_fill_n(__first, __n, __x); + } +# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + + _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + { + _ForwardIterator __cur = __result; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __first != __last; ++__first, (void)++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), *__first); + return __cur; + } + catch(...) + { + std::_Destroy(__result, __cur, __alloc); + throw; + } + } + + + template + + inline _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, allocator<_Tp>&) + { + + + + + return std::uninitialized_copy(__first, __last, __result); + } + + + template + + inline _ForwardIterator + __uninitialized_move_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + { + return std::__uninitialized_copy_a(std::make_move_iterator(__first), + std::make_move_iterator(__last), + __result, __alloc); + } + + template + + inline _ForwardIterator + __uninitialized_move_if_noexcept_a(_InputIterator __first, + _InputIterator __last, + _ForwardIterator __result, + _Allocator& __alloc) + { + return std::__uninitialized_copy_a + (std::__make_move_if_noexcept_iterator(__first), + std::__make_move_if_noexcept_iterator(__last), __result, __alloc); + } + + template + + void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur != __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + template + + inline void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x, allocator<_Tp2>&) + { + + + + + std::uninitialized_fill(__first, __last, __x); + } + + + template + + _ForwardIterator + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, (void) ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + template + + inline _ForwardIterator + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, allocator<_Tp2>&) + { + + + + + return std::uninitialized_fill_n(__first, __n, __x); + } +# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + __uninitialized_copy_move(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _ForwardIterator __result, + _Allocator& __alloc) + { + _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, + __result, + __alloc); + try + { + return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); + } + catch(...) + { + std::_Destroy(__result, __mid, __alloc); + throw; + } + } + + + + + + template + inline _ForwardIterator + __uninitialized_move_copy(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _ForwardIterator __result, + _Allocator& __alloc) + { + _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, + __result, + __alloc); + try + { + return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); + } + catch(...) + { + std::_Destroy(__result, __mid, __alloc); + throw; + } + } + + + + + template + inline _ForwardIterator + __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, + const _Tp& __x, _InputIterator __first, + _InputIterator __last, _Allocator& __alloc) + { + std::__uninitialized_fill_a(__result, __mid, __x, __alloc); + try + { + return std::__uninitialized_move_a(__first, __last, __mid, __alloc); + } + catch(...) + { + std::_Destroy(__result, __mid, __alloc); + throw; + } + } + + + + + template + inline void + __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, + _ForwardIterator __last2, const _Tp& __x, + _Allocator& __alloc) + { + _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, + __first2, + __alloc); + try + { + std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); + } + catch(...) + { + std::_Destroy(__first2, __mid2, __alloc); + throw; + } + } +# 592 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + _ForwardIterator __cur = __first; + try + { + for (; __cur != __last; ++__cur) + std::_Construct(std::__addressof(*__cur)); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + if (__first == __last) + return; + + typename iterator_traits<_ForwardIterator>::value_type* __val + = std::__addressof(*__first); + std::_Construct(__val); + if (++__first != __last) + std::fill(__first, __last, *__val); + } + }; + + template + struct __uninitialized_default_n_1 + { + template + + static _ForwardIterator + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur = __first; + try + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct(std::__addressof(*__cur)); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_n_1 + { + template + + static _ForwardIterator + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + if (__n > 0) + { + typename iterator_traits<_ForwardIterator>::value_type* __val + = std::__addressof(*__first); + std::_Construct(__val); + ++__first; + __first = std::fill_n(__first, __n - 1, *__val); + } + return __first; + } + }; + + + + template + inline void + __uninitialized_default(_ForwardIterator __first, + _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + const bool __assignable = is_copy_assignable<_ValueType>::value; + + std::__uninitialized_default_1<__is_trivial(_ValueType) + && __assignable>:: + __uninit_default(__first, __last); + } + + + + template + + inline _ForwardIterator + __uninitialized_default_n(_ForwardIterator __first, _Size __n) + { + + + + + + + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + constexpr bool __can_fill + = __and_, is_copy_assignable<_ValueType>>::value; + + return __uninitialized_default_n_1<__is_trivial(_ValueType) + && __can_fill>:: + __uninit_default_n(__first, __n); + } + + + + + + template + void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur != __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + template + inline void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + allocator<_Tp>&) + { std::__uninitialized_default(__first, __last); } + + + + + + template + _ForwardIterator + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, (void) ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + + + template + + inline _ForwardIterator + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + allocator<_Tp>&) + { return std::__uninitialized_default_n(__first, __n); } + + + template + struct __uninitialized_default_novalue_1 + { + template + static void + __uninit_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + _ForwardIterator __cur = __first; + try + { + for (; __cur != __last; ++__cur) + std::_Construct_novalue(std::__addressof(*__cur)); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_novalue_1 + { + template + static void + __uninit_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + } + }; + + template + struct __uninitialized_default_novalue_n_1 + { + template + static _ForwardIterator + __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur = __first; + try + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct_novalue(std::__addressof(*__cur)); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_novalue_n_1 + { + template + static _ForwardIterator + __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) + { return std::next(__first, __n); } + }; + + + + template + inline void + __uninitialized_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::__uninitialized_default_novalue_1< + is_trivially_default_constructible<_ValueType>::value>:: + __uninit_default_novalue(__first, __last); + } + + + + template + inline _ForwardIterator + __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + return __uninitialized_default_novalue_n_1< + is_trivially_default_constructible<_ValueType>::value>:: + __uninit_default_novalue_n(__first, __n); + } + + template + _ForwardIterator + __uninitialized_copy_n(_InputIterator __first, _Size __n, + _ForwardIterator __result, input_iterator_tag) + { + _ForwardIterator __cur = __result; + try + { + for (; __n > 0; --__n, (void) ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + catch(...) + { + std::_Destroy(__result, __cur); + throw; + } + } + + template + inline _ForwardIterator + __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, + _ForwardIterator __result, + random_access_iterator_tag) + { return std::uninitialized_copy(__first, __first + __n, __result); } + + template + pair<_InputIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, + _ForwardIterator __result, input_iterator_tag) + { + _ForwardIterator __cur = __result; + try + { + for (; __n > 0; --__n, (void) ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return {__first, __cur}; + } + catch(...) + { + std::_Destroy(__result, __cur); + throw; + } + } + + template + inline pair<_RandomAccessIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, + _ForwardIterator __result, + random_access_iterator_tag) + { + auto __second_res = uninitialized_copy(__first, __first + __n, __result); + auto __first_res = std::next(__first, __n); + return {__first_res, __second_res}; + } +# 947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_copy_n(_InputIterator __first, _Size __n, + _ForwardIterator __result) + { return std::__uninitialized_copy_n(__first, __n, __result, + std::__iterator_category(__first)); } + + + template + inline pair<_InputIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, + _ForwardIterator __result) + { + return + std::__uninitialized_copy_n_pair(__first, __n, __result, + std::__iterator_category(__first)); + } +# 976 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline void + uninitialized_default_construct(_ForwardIterator __first, + _ForwardIterator __last) + { + __uninitialized_default_novalue(__first, __last); + } +# 991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) + { + return __uninitialized_default_novalue_n(__first, __count); + } + + + + + + + + template + inline void + uninitialized_value_construct(_ForwardIterator __first, + _ForwardIterator __last) + { + return __uninitialized_default(__first, __last); + } +# 1019 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) + { + return __uninitialized_default_n(__first, __count); + } +# 1034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_move(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + return std::uninitialized_copy + (std::make_move_iterator(__first), + std::make_move_iterator(__last), __result); + } +# 1052 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline pair<_InputIterator, _ForwardIterator> + uninitialized_move_n(_InputIterator __first, _Size __count, + _ForwardIterator __result) + { + auto __res = std::__uninitialized_copy_n_pair + (std::make_move_iterator(__first), + __count, __result); + return {__res.first.base(), __res.second}; + } + + + + + + template + + inline void + __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig, + _Allocator& __alloc) + noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, + __dest, std::move(*__orig))) + && noexcept(std::allocator_traits<_Allocator>::destroy( + __alloc, std::__addressof(*__orig)))) + { + typedef std::allocator_traits<_Allocator> __traits; + __traits::construct(__alloc, __dest, std::move(*__orig)); + __traits::destroy(__alloc, std::__addressof(*__orig)); + } + + + + template + struct __is_bitwise_relocatable + : is_trivial<_Tp> { }; + + template + + inline _ForwardIterator + __relocate_a_1(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), + std::addressof(*__first), + __alloc))) + { + typedef typename iterator_traits<_InputIterator>::value_type + _ValueType; + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType2; + static_assert(std::is_same<_ValueType, _ValueType2>::value, + "relocation is only possible for values of the same type"); + _ForwardIterator __cur = __result; + for (; __first != __last; ++__first, (void)++__cur) + std::__relocate_object_a(std::__addressof(*__cur), + std::__addressof(*__first), __alloc); + return __cur; + } + + + template + + inline __enable_if_t::value, _Tp*> + __relocate_a_1(_Tp* __first, _Tp* __last, + _Tp* __result, + [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept + { + ptrdiff_t __count = __last - __first; + if (__count > 0) + { +# 1132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + __builtin_memmove(__result, __first, __count * sizeof(_Tp)); + } + return __result + __count; + } + + + template + + inline _ForwardIterator + __relocate_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result), __alloc))) + { + return std::__relocate_a_1(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result), __alloc); + } + + + + + + + +} +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_raw_storage_iter.h" 1 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_raw_storage_iter.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + + + template + class [[__deprecated__]] raw_storage_iterator + : public iterator + { + protected: + _OutputIterator _M_iter; + + public: + explicit + raw_storage_iterator(_OutputIterator __x) + : _M_iter(__x) {} + + raw_storage_iterator& + operator*() { return *this; } + + raw_storage_iterator& + operator=(const _Tp& __element) + { + std::_Construct(std::__addressof(*_M_iter), __element); + return *this; + } + + + + + raw_storage_iterator& + operator=(_Tp&& __element) + { + std::_Construct(std::__addressof(*_M_iter), std::move(__element)); + return *this; + } + + + raw_storage_iterator& + operator++() + { + ++_M_iter; + return *this; + } + + raw_storage_iterator + operator++(int) + { + raw_storage_iterator __tmp = *this; + ++_M_iter; + return __tmp; + } + + + + _OutputIterator base() const { return _M_iter; } + }; +#pragma GCC diagnostic pop + + +} +# 71 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 +# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 +# 52 "/usr/lib/clang/16/include/stdint.h" 3 +# 1 "/usr/include/stdint.h" 1 3 4 +# 26 "/usr/include/stdint.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 28 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/wchar.h" 1 3 4 +# 29 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 30 "/usr/include/stdint.h" 2 3 4 + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 35 "/usr/include/stdint.h" 2 3 4 + + +# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-uintn.h" 3 4 +typedef __uint8_t uint8_t; +typedef __uint16_t uint16_t; +typedef __uint32_t uint32_t; +typedef __uint64_t uint64_t; +# 38 "/usr/include/stdint.h" 2 3 4 + + + + + +typedef __int_least8_t int_least8_t; +typedef __int_least16_t int_least16_t; +typedef __int_least32_t int_least32_t; +typedef __int_least64_t int_least64_t; + + +typedef __uint_least8_t uint_least8_t; +typedef __uint_least16_t uint_least16_t; +typedef __uint_least32_t uint_least32_t; +typedef __uint_least64_t uint_least64_t; + + + + + +typedef signed char int_fast8_t; + +typedef long int int_fast16_t; +typedef long int int_fast32_t; +typedef long int int_fast64_t; +# 71 "/usr/include/stdint.h" 3 4 +typedef unsigned char uint_fast8_t; + +typedef unsigned long int uint_fast16_t; +typedef unsigned long int uint_fast32_t; +typedef unsigned long int uint_fast64_t; +# 87 "/usr/include/stdint.h" 3 4 +typedef long int intptr_t; + + +typedef unsigned long int uintptr_t; +# 101 "/usr/include/stdint.h" 3 4 +typedef __intmax_t intmax_t; +typedef __uintmax_t uintmax_t; +# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 +inline void* +align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept +{ + if (__space < __size) + return nullptr; + const auto __intptr = reinterpret_cast(__ptr); + const auto __aligned = (__intptr - 1u + __align) & -__align; + const auto __diff = __aligned - __intptr; + if (__diff > (__space - __size)) + return nullptr; + else + { + __space -= __diff; + return __ptr = reinterpret_cast(__aligned); + } +} +# 109 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 +} +# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + struct __erased_type { }; + + + + + template + using __is_erased_or_convertible + = __or_, is_same<_Tp, __erased_type>>; + + + struct allocator_arg_t { explicit allocator_arg_t() = default; }; + + inline constexpr allocator_arg_t allocator_arg = + allocator_arg_t(); + + template> + struct __uses_allocator_helper + : false_type { }; + + template + struct __uses_allocator_helper<_Tp, _Alloc, + __void_t> + : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type + { }; + + + template + struct uses_allocator + : __uses_allocator_helper<_Tp, _Alloc>::type + { }; + + struct __uses_alloc_base { }; + + struct __uses_alloc0 : __uses_alloc_base + { + struct _Sink { void operator=(const void*) { } } _M_a; + }; + + template + struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc; + + template + struct __uses_alloc + : __conditional_t< + is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, + __uses_alloc1<_Alloc>, + __uses_alloc2<_Alloc>> + { + + + static_assert(__or_< + is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, + is_constructible<_Tp, _Args..., const _Alloc&>>::value, + "construction with an allocator must be possible" + " if uses_allocator is true"); + }; + + template + struct __uses_alloc + : __uses_alloc0 { }; + + template + using __uses_alloc_t = + __uses_alloc::value, _Tp, _Alloc, _Args...>; + + template + + inline __uses_alloc_t<_Tp, _Alloc, _Args...> + __use_alloc(const _Alloc& __a) + { + __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; + __ret._M_a = std::__addressof(__a); + return __ret; + } + + template + void + __use_alloc(const _Alloc&&) = delete; + + + template + inline constexpr bool uses_allocator_v = + uses_allocator<_Tp, _Alloc>::value; + + + template class _Predicate, + typename _Tp, typename _Alloc, typename... _Args> + struct __is_uses_allocator_predicate + : __conditional_t::value, + __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, + _Predicate<_Tp, _Args..., _Alloc>>, + _Predicate<_Tp, _Args...>> { }; + + template + struct __is_uses_allocator_constructible + : __is_uses_allocator_predicate + { }; + + + template + inline constexpr bool __is_uses_allocator_constructible_v = + __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; + + + template + struct __is_nothrow_uses_allocator_constructible + : __is_uses_allocator_predicate + { }; + + + + template + inline constexpr bool + __is_nothrow_uses_allocator_constructible_v = + __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; + + + template + void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr, + _Args&&... __args) + { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } + + template + void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr, + _Args&&... __args) + { + ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a, + std::forward<_Args>(__args)...); + } + + template + void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr, + _Args&&... __args) + { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); } + + template + void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr, + _Args&&... __args) + { + std::__uses_allocator_construct_impl( + std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr, + std::forward<_Args>(__args)...); + } + + + +} +# 76 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + + + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 + template::type> + constexpr _Up&& + __invfwd(typename remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Up&&>(__t); } + + template + constexpr _Res + __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) + { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } + + template + constexpr _Res + __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } + + template + constexpr _Res + __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + { + return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); + } + + template + constexpr _Res + __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) + { return __invfwd<_Tp>(__t).*__f; } + + template + constexpr _Res + __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) + { return (*std::forward<_Tp>(__t)).*__f; } + + + template + constexpr typename __invoke_result<_Callable, _Args...>::type + __invoke(_Callable&& __fn, _Args&&... __args) + noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) + { + using __result = __invoke_result<_Callable, _Args...>; + using __type = typename __result::type; + using __tag = typename __result::__invoke_type; + return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + } + + + + template + constexpr enable_if_t, _Res> + __invoke_r(_Callable&& __fn, _Args&&... __args) + noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) + { + using __result = __invoke_result<_Callable, _Args...>; + using __type = typename __result::type; + using __tag = typename __result::__invoke_type; + if constexpr (is_void_v<_Res>) + std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + else + return std::__invoke_impl<__type>(__tag{}, + std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + } +# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + class tuple; + + template + struct __is_empty_non_tuple : is_empty<_Tp> { }; + + + template + struct __is_empty_non_tuple> : false_type { }; + + + template + using __empty_not_final + = __conditional_t<__is_final(_Tp), false_type, + __is_empty_non_tuple<_Tp>>; + + template::value> + struct _Head_base; + + + template + struct _Head_base<_Idx, _Head, true> + { + constexpr _Head_base() + : _M_head_impl() { } + + constexpr _Head_base(const _Head& __h) + : _M_head_impl(__h) { } + + constexpr _Head_base(const _Head_base&) = default; + constexpr _Head_base(_Head_base&&) = default; + + template + constexpr _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + + + _Head_base(allocator_arg_t, __uses_alloc0) + : _M_head_impl() { } + + template + + _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) + : _M_head_impl(allocator_arg, *__a._M_a) { } + + template + + _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) + : _M_head_impl(*__a._M_a) { } + + template + + _Head_base(__uses_alloc0, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead)) { } + + template + + _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) + { } + + template + + _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } + + static constexpr _Head& + _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } + + static constexpr const _Head& + _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } + + [[__no_unique_address__]] _Head _M_head_impl; + }; +# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + struct _Head_base<_Idx, _Head, false> + { + constexpr _Head_base() + : _M_head_impl() { } + + constexpr _Head_base(const _Head& __h) + : _M_head_impl(__h) { } + + constexpr _Head_base(const _Head_base&) = default; + constexpr _Head_base(_Head_base&&) = default; + + template + constexpr _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + + + _Head_base(allocator_arg_t, __uses_alloc0) + : _M_head_impl() { } + + template + + _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) + : _M_head_impl(allocator_arg, *__a._M_a) { } + + template + + _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) + : _M_head_impl(*__a._M_a) { } + + template + + _Head_base(__uses_alloc0, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead)) { } + + template + + _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) + { } + + template + + _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } + + static constexpr _Head& + _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } + + static constexpr const _Head& + _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } + + _Head _M_head_impl; + }; +# 250 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + struct _Tuple_impl; + + + + + + + template + struct _Tuple_impl<_Idx, _Head, _Tail...> + : public _Tuple_impl<_Idx + 1, _Tail...>, + private _Head_base<_Idx, _Head> + { + template friend struct _Tuple_impl; + + typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; + typedef _Head_base<_Idx, _Head> _Base; + + static constexpr _Head& + _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr const _Head& + _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr _Inherited& + _M_tail(_Tuple_impl& __t) noexcept { return __t; } + + static constexpr const _Inherited& + _M_tail(const _Tuple_impl& __t) noexcept { return __t; } + + constexpr _Tuple_impl() + : _Inherited(), _Base() { } + + explicit constexpr + _Tuple_impl(const _Head& __head, const _Tail&... __tail) + : _Inherited(__tail...), _Base(__head) + { } + + template> + explicit constexpr + _Tuple_impl(_UHead&& __head, _UTail&&... __tail) + : _Inherited(std::forward<_UTail>(__tail)...), + _Base(std::forward<_UHead>(__head)) + { } + + constexpr _Tuple_impl(const _Tuple_impl&) = default; + + + + _Tuple_impl& operator=(const _Tuple_impl&) = delete; + + _Tuple_impl(_Tuple_impl&&) = default; + + template + constexpr + _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) + : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), + _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) + { } + + template + constexpr + _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + : _Inherited(std::move + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), + _Base(std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) + { } +# 338 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a), + _Base(__tag, __use_alloc<_Head>(__a)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Head& __head, const _Tail&... __tail) + : _Inherited(__tag, __a, __tail...), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) + { } + + template> + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _UHead&& __head, _UTail&&... __tail) + : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), + _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(__head)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl& __in) + : _Inherited(__tag, __a, _M_tail(__in)), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl&& __in) + : _Inherited(__tag, __a, std::move(_M_tail(__in))), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + std::forward<_Head>(_M_head(__in))) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl<_Idx, _UHead, _UTails...>& __in) + : _Inherited(__tag, __a, + _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), + _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), + _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + : _Inherited(__tag, __a, std::move + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), + _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) + { } +# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + void + _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) + { + _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); + _M_tail(*this)._M_assign( + _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); + } + + template + + void + _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + { + _M_head(*this) = std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); + _M_tail(*this)._M_assign( + std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); + } +# 466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + protected: + + void + _M_swap(_Tuple_impl& __in) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + _Inherited::_M_swap(_M_tail(__in)); + } +# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + template + struct _Tuple_impl<_Idx, _Head> + : private _Head_base<_Idx, _Head> + { + template friend struct _Tuple_impl; + + typedef _Head_base<_Idx, _Head> _Base; + + static constexpr _Head& + _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr const _Head& + _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + constexpr + _Tuple_impl() + : _Base() { } + + explicit constexpr + _Tuple_impl(const _Head& __head) + : _Base(__head) + { } + + template + explicit constexpr + _Tuple_impl(_UHead&& __head) + : _Base(std::forward<_UHead>(__head)) + { } + + constexpr _Tuple_impl(const _Tuple_impl&) = default; + + + + _Tuple_impl& operator=(const _Tuple_impl&) = delete; + + + + + constexpr + _Tuple_impl(_Tuple_impl&& __in) + noexcept(is_nothrow_move_constructible<_Head>::value) + : _Base(static_cast<_Base&&>(__in)) + { } + + + template + constexpr + _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) + : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) + { } + + template + constexpr + _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) + : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) + { } +# 559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) + : _Base(__tag, __use_alloc<_Head>(__a)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Head& __head) + : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _UHead&& __head) + : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(__head)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl& __in) + : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl&& __in) + : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + std::forward<_Head>(_M_head(__in))) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl<_Idx, _UHead>& __in) + : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), + _Tuple_impl<_Idx, _UHead>::_M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl<_Idx, _UHead>&& __in) + : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) + { } +# 629 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + void + _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) + { + _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); + } + + template + + void + _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) + { + _M_head(*this) + = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); + } +# 663 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + protected: + + void + _M_swap(_Tuple_impl& __in) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + } +# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + + template + struct _TupleConstraints + { + template + using __constructible = __and_...>; + + template + using __convertible = __and_...>; + + + + + template + static constexpr bool __is_implicitly_constructible() + { + return __and_<__constructible<_UTypes...>, + __convertible<_UTypes...> + >::value; + } + + + + + template + static constexpr bool __is_explicitly_constructible() + { + return __and_<__constructible<_UTypes...>, + __not_<__convertible<_UTypes...>> + >::value; + } + + static constexpr bool __is_implicitly_default_constructible() + { + return __and_... + >::value; + } + + static constexpr bool __is_explicitly_default_constructible() + { + return __and_..., + __not_<__and_< + std::__is_implicitly_default_constructible<_Types>...> + >>::value; + } + }; + + + + template + struct _TupleConstraints + { + template + static constexpr bool __is_implicitly_constructible() + { return false; } + + template + static constexpr bool __is_explicitly_constructible() + { return false; } + }; + + + template + class tuple : public _Tuple_impl<0, _Elements...> + { + typedef _Tuple_impl<0, _Elements...> _Inherited; + + template + using _TCC = _TupleConstraints<_Cond, _Elements...>; + + + template + using _ImplicitDefaultCtor = __enable_if_t< + _TCC<_Dummy>::__is_implicitly_default_constructible(), + bool>; + + + template + using _ExplicitDefaultCtor = __enable_if_t< + _TCC<_Dummy>::__is_explicitly_default_constructible(), + bool>; + + + template + using _ImplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), + bool>; + + + template + using _ExplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), + bool>; + + template + static constexpr + __enable_if_t + __assignable() + { return __and_...>::value; } + + + template + static constexpr bool __nothrow_assignable() + { + return + __and_...>::value; + } + + + template + static constexpr bool __nothrow_constructible() + { + return + __and_...>::value; + } + + + template + static constexpr bool __valid_args() + { + return sizeof...(_Elements) == 1 + && !is_same>::value; + } + + + template + static constexpr bool __valid_args() + { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } +# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template> + struct _UseOtherCtor + : false_type + { }; + + + template + struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> + : __or_, is_constructible<_Tp, _Tuple>>::type + { }; + + + template + struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> + : true_type + { }; + + + + + template + static constexpr bool __use_other_ctor() + { return _UseOtherCtor<_Tuple>::value; } +# 856 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + public: + template::value> = true> + constexpr + tuple() + noexcept(__and_...>::value) + : _Inherited() { } + + template::value> = false> + explicit constexpr + tuple() + noexcept(__and_...>::value) + : _Inherited() { } + + template= 1), + _ImplicitCtor<_NotEmpty, const _Elements&...> = true> + constexpr + tuple(const _Elements&... __elements) + noexcept(__nothrow_constructible()) + : _Inherited(__elements...) { } + + template= 1), + _ExplicitCtor<_NotEmpty, const _Elements&...> = false> + explicit constexpr + tuple(const _Elements&... __elements) + noexcept(__nothrow_constructible()) + : _Inherited(__elements...) { } + + template(), + _ImplicitCtor<_Valid, _UElements...> = true> + constexpr + tuple(_UElements&&... __elements) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + template(), + _ExplicitCtor<_Valid, _UElements...> = false> + explicit constexpr + tuple(_UElements&&... __elements) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + constexpr tuple(const tuple&) = default; + + constexpr tuple(tuple&&) = default; + + template&>(), + _ImplicitCtor<_Valid, const _UElements&...> = true> + constexpr + tuple(const tuple<_UElements...>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) + { } + + template&>(), + _ExplicitCtor<_Valid, const _UElements&...> = false> + explicit constexpr + tuple(const tuple<_UElements...>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) + { } + + template&&>(), + _ImplicitCtor<_Valid, _UElements...> = true> + constexpr + tuple(tuple<_UElements...>&& __in) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } + + template&&>(), + _ExplicitCtor<_Valid, _UElements...> = false> + explicit constexpr + tuple(tuple<_UElements...>&& __in) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } +# 968 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template::value> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template= 1), + _ImplicitCtor<_NotEmpty, const _Elements&...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template= 1), + _ExplicitCtor<_NotEmpty, const _Elements&...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template(), + _ImplicitCtor<_Valid, _UElements...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + _UElements&&... __elements) + : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) + { } + + template(), + _ExplicitCtor<_Valid, _UElements...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + _UElements&&... __elements) + : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) + { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) + : _Inherited(__tag, __a, static_cast(__in)) { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) + : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } + + template&>(), + _ImplicitCtor<_Valid, const _UElements&...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template&>(), + _ExplicitCtor<_Valid, const _UElements&...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template&&>(), + _ImplicitCtor<_Valid, _UElements...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_UElements...>&& __in) + : _Inherited(__tag, __a, + static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) + { } + + template&&>(), + _ExplicitCtor<_Valid, _UElements...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_UElements...>&& __in) + : _Inherited(__tag, __a, + static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) + { } +# 1093 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + tuple& + operator=(__conditional_t<__assignable(), + const tuple&, + const __nonesuch&> __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + + tuple& + operator=(__conditional_t<__assignable<_Elements...>(), + tuple&&, + __nonesuch&&> __in) + noexcept(__nothrow_assignable<_Elements...>()) + { + this->_M_assign(std::move(__in)); + return *this; + } + + template + + __enable_if_t<__assignable(), tuple&> + operator=(const tuple<_UElements...>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + template + + __enable_if_t<__assignable<_UElements...>(), tuple&> + operator=(tuple<_UElements...>&& __in) + noexcept(__nothrow_assignable<_UElements...>()) + { + this->_M_assign(std::move(__in)); + return *this; + } +# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + void + swap(tuple& __in) + noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) + { _Inherited::_M_swap(__in); } +# 1192 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + template + tuple(_UTypes...) -> tuple<_UTypes...>; + template + tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; + template + tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; + template + tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; + template + tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; + + + + template<> + class tuple<> + { + public: + + void swap(tuple&) noexcept { } + + + + + + tuple() = default; + + template + + tuple(allocator_arg_t, const _Alloc&) noexcept { } + template + + tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } + }; + + + + template + class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> + { + typedef _Tuple_impl<0, _T1, _T2> _Inherited; + + + template + using _ImplicitDefaultCtor = __enable_if_t< + _TupleConstraints<_Dummy, _U1, _U2>:: + __is_implicitly_default_constructible(), + bool>; + + + template + using _ExplicitDefaultCtor = __enable_if_t< + _TupleConstraints<_Dummy, _U1, _U2>:: + __is_explicitly_default_constructible(), + bool>; + + template + using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; + + + template + using _ImplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), + bool>; + + + template + using _ExplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), + bool>; + + template + static constexpr bool __assignable() + { + return __and_, + is_assignable<_T2&, _U2>>::value; + } + + template + static constexpr bool __nothrow_assignable() + { + return __and_, + is_nothrow_assignable<_T2&, _U2>>::value; + } + + template + static constexpr bool __nothrow_constructible() + { + return __and_, + is_nothrow_constructible<_T2, _U2>>::value; + } + + static constexpr bool __nothrow_default_constructible() + { + return __and_, + is_nothrow_default_constructible<_T2>>::value; + } + + template + static constexpr bool __is_alloc_arg() + { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } +# 1306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + public: + template = true> + constexpr + tuple() + noexcept(__nothrow_default_constructible()) + : _Inherited() { } + + template = false> + explicit constexpr + tuple() + noexcept(__nothrow_default_constructible()) + : _Inherited() { } + + template = true> + constexpr + tuple(const _T1& __a1, const _T2& __a2) + noexcept(__nothrow_constructible()) + : _Inherited(__a1, __a2) { } + + template = false> + explicit constexpr + tuple(const _T1& __a1, const _T2& __a2) + noexcept(__nothrow_constructible()) + : _Inherited(__a1, __a2) { } + + template(), _U1, _U2> = true> + constexpr + tuple(_U1&& __a1, _U2&& __a2) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + template(), _U1, _U2> = false> + explicit constexpr + tuple(_U1&& __a1, _U2&& __a2) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + constexpr tuple(const tuple&) = default; + + constexpr tuple(tuple&&) = default; + + template = true> + constexpr + tuple(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) { } + + template = false> + explicit constexpr + tuple(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) { } + + template = true> + constexpr + tuple(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } + + template = false> + explicit constexpr + tuple(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } +# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template = true> + constexpr + tuple(const pair<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(__in.first, __in.second) { } + + template = false> + explicit constexpr + tuple(const pair<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(__in.first, __in.second) { } + + template = true> + constexpr + tuple(pair<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + template = false> + explicit constexpr + tuple(pair<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } +# 1450 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template::value, _T1, _T2> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) + : _Inherited(__tag, __a, std::forward<_U1>(__a1), + std::forward<_U2>(__a2)) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + _U1&& __a1, _U2&& __a2) + : _Inherited(__tag, __a, std::forward<_U1>(__a1), + std::forward<_U2>(__a2)) { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) + : _Inherited(__tag, __a, static_cast(__in)) { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) + : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) + : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) + { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) + : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) + { } +# 1553 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) + : _Inherited(__tag, __a, std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) + : _Inherited(__tag, __a, std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } +# 1604 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + tuple& + operator=(__conditional_t<__assignable(), + const tuple&, + const __nonesuch&> __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + + tuple& + operator=(__conditional_t<__assignable<_T1, _T2>(), + tuple&&, + __nonesuch&&> __in) + noexcept(__nothrow_assignable<_T1, _T2>()) + { + this->_M_assign(std::move(__in)); + return *this; + } + + template + + __enable_if_t<__assignable(), tuple&> + operator=(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + template + + __enable_if_t<__assignable<_U1, _U2>(), tuple&> + operator=(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_assignable<_U1, _U2>()) + { + this->_M_assign(std::move(__in)); + return *this; + } +# 1683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + __enable_if_t<__assignable(), tuple&> + operator=(const pair<_U1, _U2>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_head(*this) = __in.first; + this->_M_tail(*this)._M_head(*this) = __in.second; + return *this; + } + + template + + __enable_if_t<__assignable<_U1, _U2>(), tuple&> + operator=(pair<_U1, _U2>&& __in) + noexcept(__nothrow_assignable<_U1, _U2>()) + { + this->_M_head(*this) = std::forward<_U1>(__in.first); + this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); + return *this; + } +# 1730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + void + swap(tuple& __in) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { _Inherited::_M_swap(__in); } +# 1744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + inline constexpr size_t tuple_size_v> + = sizeof...(_Types); + + template + inline constexpr size_t tuple_size_v> + = sizeof...(_Types); + + + + template + struct tuple_element<__i, tuple<_Types...>> + { + static_assert(__i < sizeof...(_Types), "tuple index must be in range"); + + using type = typename _Nth_type<__i, _Types...>::type; + }; + + template + constexpr _Head& + __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + template + constexpr const _Head& + __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + + template + __enable_if_t<(__i >= sizeof...(_Types))> + __get_helper(const tuple<_Types...>&) = delete; + + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>& + get(tuple<_Elements...>& __t) noexcept + { return std::__get_helper<__i>(__t); } + + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>& + get(const tuple<_Elements...>& __t) noexcept + { return std::__get_helper<__i>(__t); } + + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>&& + get(tuple<_Elements...>&& __t) noexcept + { + typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; + return std::forward<__element_type>(std::__get_helper<__i>(__t)); + } + + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& + get(const tuple<_Elements...>&& __t) noexcept + { + typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; + return std::forward(std::__get_helper<__i>(__t)); + } + + + + template + constexpr __enable_if_t<(__i >= sizeof...(_Elements))> + get(const tuple<_Elements...>&) = delete; + + + + + + + + template + constexpr _Tp& + get(tuple<_Types...>& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::__get_helper<__idx>(__t); + } + + + template + constexpr _Tp&& + get(tuple<_Types...>&& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::forward<_Tp>(std::__get_helper<__idx>(__t)); + } + + + template + constexpr const _Tp& + get(const tuple<_Types...>& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::__get_helper<__idx>(__t); + } + + + + template + constexpr const _Tp&& + get(const tuple<_Types...>&& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::forward(std::__get_helper<__idx>(__t)); + } + + + + template + struct __tuple_compare + { + static constexpr bool + __eq(const _Tp& __t, const _Up& __u) + { + return bool(std::get<__i>(__t) == std::get<__i>(__u)) + && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); + } + + static constexpr bool + __less(const _Tp& __t, const _Up& __u) + { + return bool(std::get<__i>(__t) < std::get<__i>(__u)) + || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) + && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); + } + }; + + template + struct __tuple_compare<_Tp, _Up, __size, __size> + { + static constexpr bool + __eq(const _Tp&, const _Up&) { return true; } + + static constexpr bool + __less(const _Tp&, const _Up&) { return false; } + }; + + template + constexpr bool + operator==(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) == sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare = __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__eq(__t, __u); + } +# 1945 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + constexpr bool + operator<(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) == sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare = __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__less(__t, __u); + } + + template + constexpr bool + operator!=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t == __u); } + + template + constexpr bool + operator>(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return __u < __t; } + + template + constexpr bool + operator<=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__u < __t); } + + template + constexpr bool + operator>=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t < __u); } + + + + + template + constexpr tuple::__type...> + make_tuple(_Elements&&... __args) + { + typedef tuple::__type...> + __result_type; + return __result_type(std::forward<_Elements>(__args)...); + } + + + + + template + constexpr tuple<_Elements&&...> + forward_as_tuple(_Elements&&... __args) noexcept + { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } + + + + + template struct array; + + template + constexpr _Tp& + get(array<_Tp, _Nm>&) noexcept; + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&&) noexcept; + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>&) noexcept; + + template + constexpr const _Tp&& + get(const array<_Tp, _Nm>&&) noexcept; + + + template + struct __make_tuple_impl; + + template + struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> + : __make_tuple_impl<_Idx + 1, + tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, + _Tuple, _Nm> + { }; + + template + struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> + { + typedef tuple<_Tp...> __type; + }; + + template + struct __do_make_tuple + : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value> + { }; + + + template + struct __make_tuple + : public __do_make_tuple<__remove_cvref_t<_Tuple>> + { }; + + + template + struct __combine_tuples; + + template<> + struct __combine_tuples<> + { + typedef tuple<> __type; + }; + + template + struct __combine_tuples> + { + typedef tuple<_Ts...> __type; + }; + + template + struct __combine_tuples, tuple<_T2s...>, _Rem...> + { + typedef typename __combine_tuples, + _Rem...>::__type __type; + }; + + + template + struct __tuple_cat_result + { + typedef typename __combine_tuples + ::__type...>::__type __type; + }; + + + + template + struct __make_1st_indices; + + template<> + struct __make_1st_indices<> + { + typedef _Index_tuple<> __type; + }; + + template + struct __make_1st_indices<_Tp, _Tpls...> + { + typedef typename _Build_index_tuple::type>::value>::__type __type; + }; + + + + + template + struct __tuple_concater; + + template + struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...> + { + template + static constexpr _Ret + _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) + { + typedef typename __make_1st_indices<_Tpls...>::__type __idx; + typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; + return __next::_S_do(std::forward<_Tpls>(__tps)..., + std::forward<_Us>(__us)..., + std::get<_Is>(std::forward<_Tp>(__tp))...); + } + }; + + template + struct __tuple_concater<_Ret, _Index_tuple<>> + { + template + static constexpr _Ret + _S_do(_Us&&... __us) + { + return _Ret(std::forward<_Us>(__us)...); + } + }; + + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template...>::value>::type> + constexpr auto + tuple_cat(_Tpls&&... __tpls) + -> typename __tuple_cat_result<_Tpls...>::__type + { + typedef typename __tuple_cat_result<_Tpls...>::__type __ret; + typedef typename __make_1st_indices<_Tpls...>::__type __idx; + typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; + return __concater::_S_do(std::forward<_Tpls>(__tpls)...); + } + + + + + template + constexpr tuple<_Elements&...> + tie(_Elements&... __args) noexcept + { return tuple<_Elements&...>(__args...); } + + + template + + inline + + + typename enable_if<__and_<__is_swappable<_Elements>...>::value + >::type + + + + swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 2184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + typename enable_if...>::value>::type + swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; + + + + + + + struct _Swallow_assign + { + template + constexpr const _Swallow_assign& + operator=(const _Tp&) const + { return *this; } + }; +# 2219 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + inline constexpr _Swallow_assign ignore{}; + + + template + struct uses_allocator, _Alloc> : true_type { }; +# 2234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + template + + inline + pair<_T1, _T2>:: + pair(piecewise_construct_t, + tuple<_Args1...> __first, tuple<_Args2...> __second) + : pair(__first, __second, + typename _Build_index_tuple::__type(), + typename _Build_index_tuple::__type()) + { } + + template + template + inline + pair<_T1, _T2>:: + pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) + : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), + second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) + { } + + + + + + + + template class _Trait, typename _Tp, typename _Tuple> + inline constexpr bool __unpack_std_tuple = false; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> + = _Trait<_Tp, _Up...>::value; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> + = _Trait<_Tp, _Up&...>::value; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> + = _Trait<_Tp, const _Up...>::value; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> + = _Trait<_Tp, const _Up&...>::value; + + + + template + constexpr decltype(auto) + __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) + { + return std::__invoke(std::forward<_Fn>(__f), + std::get<_Idx>(std::forward<_Tuple>(__t))...); + } + + template + constexpr decltype(auto) + apply(_Fn&& __f, _Tuple&& __t) + noexcept(__unpack_std_tuple) + { + using _Indices + = make_index_sequence>>; + return std::__apply_impl(std::forward<_Fn>(__f), + std::forward<_Tuple>(__t), + _Indices{}); + } + + + + template + constexpr _Tp + __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) + { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } + + template + constexpr _Tp + make_from_tuple(_Tuple&& __t) + noexcept(__unpack_std_tuple) + { + constexpr size_t __n = tuple_size_v>; + + + + + + + + return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t), + make_index_sequence<__n>{}); + } +# 2345 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 +} +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct unary_function + { + + typedef _Arg argument_type; + + + typedef _Result result_type; + } __attribute__ ((__deprecated__)); + + + + + + template + struct binary_function + { + + typedef _Arg1 first_argument_type; + + + typedef _Arg2 second_argument_type; + + + typedef _Result result_type; + } __attribute__ ((__deprecated__)); +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + struct __is_transparent; + + template + struct plus; + + template + struct minus; + + template + struct multiplies; + + template + struct divides; + + template + struct modulus; + + template + struct negate; + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct plus : public binary_function<_Tp, _Tp, _Tp> + { + + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x + __y; } + }; + + + template + struct minus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x - __y; } + }; + + + template + struct multiplies : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x * __y; } + }; + + + template + struct divides : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x / __y; } + }; + + + template + struct modulus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x % __y; } + }; + + + template + struct negate : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return -__x; } + }; +#pragma GCC diagnostic pop + + + + + + template<> + struct plus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct minus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct multiplies + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct divides + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct modulus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct negate + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(-std::forward<_Tp>(__t))) + -> decltype(-std::forward<_Tp>(__t)) + { return -std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; +# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct equal_to; + + template + struct not_equal_to; + + template + struct greater; + + template + struct less; + + template + struct greater_equal; + + template + struct less_equal; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x == __y; } + }; + + + template + struct not_equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x != __y; } + }; + + + template + struct greater : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x > __y; } + }; + + + template + struct less : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x < __y; } + }; + + + template + struct greater_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x >= __y; } + }; + + + template + struct less_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x <= __y; } + }; + + + template + struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x > __y; + + return (long unsigned int)__x > (long unsigned int)__y; + } + }; + + + template + struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x < __y; + + return (long unsigned int)__x < (long unsigned int)__y; + } + }; + + + template + struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x >= __y; + + return (long unsigned int)__x >= (long unsigned int)__y; + } + }; + + + template + struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x <= __y; + + return (long unsigned int)__x <= (long unsigned int)__y; + } + }; +#pragma GCC diagnostic pop + + + + template<> + struct equal_to + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct not_equal_to + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct greater + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return greater>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return greater{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct less + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return less>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return less{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct greater_equal + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return greater_equal>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return greater_equal{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct less_equal + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return less_equal>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return less_equal{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; +# 781 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct logical_and; + + template + struct logical_or; + + template + struct logical_not; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct logical_and : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x && __y; } + }; + + + template + struct logical_or : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x || __y; } + }; + + + template + struct logical_not : public unary_function<_Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x) const + { return !__x; } + }; +#pragma GCC diagnostic pop + + + + template<> + struct logical_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(!std::forward<_Tp>(__t))) + -> decltype(!std::forward<_Tp>(__t)) + { return !std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; + + + + + template + struct bit_and; + + template + struct bit_or; + + template + struct bit_xor; + + template + struct bit_not; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + template + struct bit_and : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x & __y; } + }; + + template + struct bit_or : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x | __y; } + }; + + template + struct bit_xor : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x ^ __y; } + }; + + template + struct bit_not : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return ~__x; } + }; +#pragma GCC diagnostic pop + + + template <> + struct bit_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_xor + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(~std::forward<_Tp>(__t))) + -> decltype(~std::forward<_Tp>(__t)) + { return ~std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class [[__deprecated__]] unary_negate + : public unary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + unary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::argument_type& __x) const + { return !_M_pred(__x); } + }; + + + template + __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) + constexpr + inline unary_negate<_Predicate> + not1(const _Predicate& __pred) + { return unary_negate<_Predicate>(__pred); } + + + template + class [[__deprecated__]] binary_negate + : public binary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + binary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::first_argument_type& __x, + const typename _Predicate::second_argument_type& __y) const + { return !_M_pred(__x, __y); } + }; + + + template + __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) + constexpr + inline binary_negate<_Predicate> + not2(const _Predicate& __pred) + { return binary_negate<_Predicate>(__pred); } +# 1104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class pointer_to_unary_function : public unary_function<_Arg, _Result> + { + protected: + _Result (*_M_ptr)(_Arg); + + public: + pointer_to_unary_function() { } + + explicit + pointer_to_unary_function(_Result (*__x)(_Arg)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg __x) const + { return _M_ptr(__x); } + } __attribute__ ((__deprecated__)); + + + template + __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) + inline pointer_to_unary_function<_Arg, _Result> + ptr_fun(_Result (*__x)(_Arg)) + { return pointer_to_unary_function<_Arg, _Result>(__x); } + + + template + class pointer_to_binary_function + : public binary_function<_Arg1, _Arg2, _Result> + { + protected: + _Result (*_M_ptr)(_Arg1, _Arg2); + + public: + pointer_to_binary_function() { } + + explicit + pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg1 __x, _Arg2 __y) const + { return _M_ptr(__x, __y); } + } __attribute__ ((__deprecated__)); + + + template + __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) + inline pointer_to_binary_function<_Arg1, _Arg2, _Result> + ptr_fun(_Result (*__x)(_Arg1, _Arg2)) + { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } + + + template + struct _Identity + : public unary_function<_Tp, _Tp> + { + _Tp& + operator()(_Tp& __x) const + { return __x; } + + const _Tp& + operator()(const _Tp& __x) const + { return __x; } + }; + + + template struct _Identity : _Identity<_Tp> { }; + + template + struct _Select1st + : public unary_function<_Pair, typename _Pair::first_type> + { + typename _Pair::first_type& + operator()(_Pair& __x) const + { return __x.first; } + + const typename _Pair::first_type& + operator()(const _Pair& __x) const + { return __x.first; } + + + template + typename _Pair2::first_type& + operator()(_Pair2& __x) const + { return __x.first; } + + template + const typename _Pair2::first_type& + operator()(const _Pair2& __x) const + { return __x.first; } + + }; + + template + struct _Select2nd + : public unary_function<_Pair, typename _Pair::second_type> + { + typename _Pair::second_type& + operator()(_Pair& __x) const + { return __x.second; } + + const typename _Pair::second_type& + operator()(const _Pair& __x) const + { return __x.second; } + }; +# 1231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class mem_fun_t : public unary_function<_Tp*, _Ret> + { + public: + explicit + mem_fun_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun_t : public unary_function + { + public: + explicit + const_mem_fun_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + mem_fun_ref_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> + { + public: + explicit + mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun1_t : public binary_function + { + public: + explicit + const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + } __attribute__ ((__deprecated__)); + + + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)()) + { return mem_fun_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)() const) + { return const_mem_fun_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)()) + { return mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)() const) + { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } +#pragma GCC diagnostic pop + + + + + template> + struct __has_is_transparent + { }; + + template + struct __has_is_transparent<_Func, _SfinaeType, + __void_t> + { typedef void type; }; + + template + using __has_is_transparent_t + = typename __has_is_transparent<_Func, _SfinaeType>::type; + + + +} + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 1 3 +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 + template + class binder1st + : public unary_function + { + protected: + _Operation op; + typename _Operation::first_argument_type value; + + public: + binder1st(const _Operation& __x, + const typename _Operation::first_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + + + + typename _Operation::result_type + operator()(typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); + + + template + __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) + inline binder1st<_Operation> + bind1st(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::first_argument_type _Arg1_type; + return binder1st<_Operation>(__fn, _Arg1_type(__x)); + } + + + template + class binder2nd + : public unary_function + { + protected: + _Operation op; + typename _Operation::second_argument_type value; + + public: + binder2nd(const _Operation& __x, + const typename _Operation::second_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + + + + typename _Operation::result_type + operator()(typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); + + + template + __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) + inline binder2nd<_Operation> + bind2nd(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::second_argument_type _Arg2_type; + return binder2nd<_Operation>(__fn, _Arg2_type(__x)); + } + + + +} + +#pragma GCC diagnostic pop +# 1439 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 2 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hash_bytes.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template + struct __hash_base + { + typedef _Result result_type [[__deprecated__]]; + typedef _Arg argument_type [[__deprecated__]]; + }; + + + template + struct hash; + + template + struct __poison_hash + { + static constexpr bool __enable_hash_call = false; + private: + + __poison_hash(__poison_hash&&); + ~__poison_hash(); + }; + + template + struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> + { + static constexpr bool __enable_hash_call = true; + }; + + + template::value> + struct __hash_enum + { + private: + + __hash_enum(__hash_enum&&); + ~__hash_enum(); + }; + + + template + struct __hash_enum<_Tp, true> : public __hash_base + { + size_t + operator()(_Tp __val) const noexcept + { + using __type = typename underlying_type<_Tp>::type; + return hash<__type>{}(static_cast<__type>(__val)); + } + }; + + + + template + struct hash : __hash_enum<_Tp> + { }; + + + template + struct hash<_Tp*> : public __hash_base + { + size_t + operator()(_Tp* __p) const noexcept + { return reinterpret_cast(__p); } + }; +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; + + + + + + + + template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; +# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + struct _Hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(0xc70f6907UL)) + { return _Hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + + struct _Fnv_hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(2166136261UL)) + { return _Fnv_hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(float __val) const noexcept + { + + return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(double __val) const noexcept + { + + return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash + : public __hash_base + { + __attribute__ ((__pure__)) size_t + operator()(long double __val) const noexcept; + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(nullptr_t) const noexcept + { return 0; } + }; +# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template + struct __is_fast_hash : public std::true_type + { }; + + template<> + struct __is_fast_hash> : public std::false_type + { }; + + +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template class auto_ptr; +#pragma GCC diagnostic pop + + + + + + + + template + struct default_delete + { + + constexpr default_delete() noexcept = default; + + + + + + + template>> + + default_delete(const default_delete<_Up>&) noexcept { } + + + + void + operator()(_Tp* __ptr) const + { + static_assert(!is_void<_Tp>::value, + "can't delete pointer to incomplete type"); + static_assert(sizeof(_Tp)>0, + "can't delete pointer to incomplete type"); + delete __ptr; + } + }; +# 111 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + struct default_delete<_Tp[]> + { + public: + + constexpr default_delete() noexcept = default; +# 127 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template>> + + default_delete(const default_delete<_Up[]>&) noexcept { } + + + template + + typename enable_if::value>::type + operator()(_Up* __ptr) const + { + static_assert(sizeof(_Tp)>0, + "can't delete pointer to incomplete type"); + delete [] __ptr; + } + }; + + + + + template + class __uniq_ptr_impl + { + template + struct _Ptr + { + using type = _Up*; + }; + + template + struct + _Ptr<_Up, _Ep, __void_t::type::pointer>> + { + using type = typename remove_reference<_Ep>::type::pointer; + }; + + public: + using _DeleterConstraint = enable_if< + __and_<__not_>, + is_default_constructible<_Dp>>::value>; + + using pointer = typename _Ptr<_Tp, _Dp>::type; + + static_assert( !is_rvalue_reference<_Dp>::value, + "unique_ptr's deleter type must be a function object type" + " or an lvalue reference type" ); + + __uniq_ptr_impl() = default; + + __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; } + + template + + __uniq_ptr_impl(pointer __p, _Del&& __d) + : _M_t(__p, std::forward<_Del>(__d)) { } + + + __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept + : _M_t(std::move(__u._M_t)) + { __u._M_ptr() = nullptr; } + + + __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept + { + reset(__u.release()); + _M_deleter() = std::forward<_Dp>(__u._M_deleter()); + return *this; + } + + + pointer& _M_ptr() noexcept { return std::get<0>(_M_t); } + + pointer _M_ptr() const noexcept { return std::get<0>(_M_t); } + + _Dp& _M_deleter() noexcept { return std::get<1>(_M_t); } + + const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); } + + + void reset(pointer __p) noexcept + { + const pointer __old_p = _M_ptr(); + _M_ptr() = __p; + if (__old_p) + _M_deleter()(__old_p); + } + + + pointer release() noexcept + { + pointer __p = _M_ptr(); + _M_ptr() = nullptr; + return __p; + } + + + void + swap(__uniq_ptr_impl& __rhs) noexcept + { + using std::swap; + swap(this->_M_ptr(), __rhs._M_ptr()); + swap(this->_M_deleter(), __rhs._M_deleter()); + } + + private: + tuple _M_t; + }; + + + template ::value, + bool = is_move_assignable<_Dp>::value> + struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp> + { + using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; + __uniq_ptr_data(__uniq_ptr_data&&) = default; + __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; + }; + + template + struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp> + { + using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; + __uniq_ptr_data(__uniq_ptr_data&&) = default; + __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; + }; + + template + struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp> + { + using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; + __uniq_ptr_data(__uniq_ptr_data&&) = delete; + __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; + }; + + template + struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp> + { + using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; + __uniq_ptr_data(__uniq_ptr_data&&) = delete; + __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; + }; + + + + + + + + template > + class unique_ptr + { + template + using _DeleterConstraint = + typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; + + __uniq_ptr_data<_Tp, _Dp> _M_t; + + public: + using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; + using element_type = _Tp; + using deleter_type = _Dp; + + private: + + + template + using __safe_conversion_up = __and_< + is_convertible::pointer, pointer>, + __not_> + >; + + public: + + + + template> + constexpr unique_ptr() noexcept + : _M_t() + { } + + + + + + + + template> + + explicit + unique_ptr(pointer __p) noexcept + : _M_t(__p) + { } +# 328 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template>> + + unique_ptr(pointer __p, const deleter_type& __d) noexcept + : _M_t(__p, __d) { } +# 341 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template>> + + unique_ptr(pointer __p, + __enable_if_t::value, + _Del&&> __d) noexcept + : _M_t(__p, std::move(__d)) + { } + + template::type> + + unique_ptr(pointer, + __enable_if_t::value, + _DelUnref&&>) = delete; + + + template> + constexpr unique_ptr(nullptr_t) noexcept + : _M_t() + { } + + + + + unique_ptr(unique_ptr&&) = default; + + + + + + + + template, + __conditional_t::value, + is_same<_Ep, _Dp>, + is_convertible<_Ep, _Dp>>>> + + unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept + : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) + { } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template, is_same<_Dp, default_delete<_Tp>>>> + unique_ptr(auto_ptr<_Up>&& __u) noexcept; +#pragma GCC diagnostic pop + + + + + + + ~unique_ptr() noexcept + { + static_assert(__is_invocable::value, + "unique_ptr's deleter must be invocable with a pointer"); + auto& __ptr = _M_t._M_ptr(); + if (__ptr != nullptr) + get_deleter()(std::move(__ptr)); + __ptr = pointer(); + } + + + + + + + + unique_ptr& operator=(unique_ptr&&) = default; +# 423 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + + typename enable_if< __and_< + __safe_conversion_up<_Up, _Ep>, + is_assignable + >::value, + unique_ptr&>::type + operator=(unique_ptr<_Up, _Ep>&& __u) noexcept + { + reset(__u.release()); + get_deleter() = std::forward<_Ep>(__u.get_deleter()); + return *this; + } + + + + unique_ptr& + operator=(nullptr_t) noexcept + { + reset(); + return *this; + } + + + + + + typename add_lvalue_reference::type + operator*() const noexcept(noexcept(*std::declval())) + { + do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) __builtin_unreachable(); } while (false); + return *get(); + } + + + + pointer + operator->() const noexcept + { + ; + return get(); + } + + + + pointer + get() const noexcept + { return _M_t._M_ptr(); } + + + + deleter_type& + get_deleter() noexcept + { return _M_t._M_deleter(); } + + + + const deleter_type& + get_deleter() const noexcept + { return _M_t._M_deleter(); } + + + + explicit operator bool() const noexcept + { return get() == pointer() ? false : true; } + + + + + + pointer + release() noexcept + { return _M_t.release(); } +# 504 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + void + reset(pointer __p = pointer()) noexcept + { + static_assert(__is_invocable::value, + "unique_ptr's deleter must be invocable with a pointer"); + _M_t.reset(std::move(__p)); + } + + + + void + swap(unique_ptr& __u) noexcept + { + static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); + _M_t.swap(__u._M_t); + } + + + unique_ptr(const unique_ptr&) = delete; + unique_ptr& operator=(const unique_ptr&) = delete; + }; +# 534 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + class unique_ptr<_Tp[], _Dp> + { + template + using _DeleterConstraint = + typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; + + __uniq_ptr_data<_Tp, _Dp> _M_t; + + + template + using __is_derived_Tp + = __and_< is_base_of<_Tp, _Up>, + __not_, __remove_cv_t<_Up>>> >; + + public: + using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; + using element_type = _Tp; + using deleter_type = _Dp; + + + + template, + typename _UP_pointer = typename _UPtr::pointer, + typename _UP_element_type = typename _UPtr::element_type> + using __safe_conversion_up = __and_< + is_array<_Up>, + is_same, + is_same<_UP_pointer, _UP_element_type*>, + is_convertible<_UP_element_type(*)[], element_type(*)[]> + >; + + + template + using __safe_conversion_raw = __and_< + __or_<__or_, + is_same<_Up, nullptr_t>>, + __and_, + is_same, + is_convertible< + typename remove_pointer<_Up>::type(*)[], + element_type(*)[]> + > + > + >; + + + + + template> + constexpr unique_ptr() noexcept + : _M_t() + { } +# 596 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template, + typename = typename enable_if< + __safe_conversion_raw<_Up>::value, bool>::type> + + explicit + unique_ptr(_Up __p) noexcept + : _M_t(__p) + { } +# 615 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template, + is_copy_constructible<_Del>>> + + unique_ptr(_Up __p, const deleter_type& __d) noexcept + : _M_t(__p, __d) { } +# 630 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template, + is_move_constructible<_Del>>> + + unique_ptr(_Up __p, + __enable_if_t::value, + _Del&&> __d) noexcept + : _M_t(std::move(__p), std::move(__d)) + { } + + template::type, + typename = _Require<__safe_conversion_raw<_Up>>> + unique_ptr(_Up, + __enable_if_t::value, + _DelUnref&&>) = delete; + + + unique_ptr(unique_ptr&&) = default; + + + template> + constexpr unique_ptr(nullptr_t) noexcept + : _M_t() + { } + + template, + __conditional_t::value, + is_same<_Ep, _Dp>, + is_convertible<_Ep, _Dp>>>> + + unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept + : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) + { } + + + + + + ~unique_ptr() + { + auto& __ptr = _M_t._M_ptr(); + if (__ptr != nullptr) + get_deleter()(__ptr); + __ptr = pointer(); + } + + + + + + + + unique_ptr& + operator=(unique_ptr&&) = default; +# 694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + + typename + enable_if<__and_<__safe_conversion_up<_Up, _Ep>, + is_assignable + >::value, + unique_ptr&>::type + operator=(unique_ptr<_Up, _Ep>&& __u) noexcept + { + reset(__u.release()); + get_deleter() = std::forward<_Ep>(__u.get_deleter()); + return *this; + } + + + + unique_ptr& + operator=(nullptr_t) noexcept + { + reset(); + return *this; + } + + + + + + typename std::add_lvalue_reference::type + operator[](size_t __i) const + { + do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) __builtin_unreachable(); } while (false); + return get()[__i]; + } + + + + pointer + get() const noexcept + { return _M_t._M_ptr(); } + + + + deleter_type& + get_deleter() noexcept + { return _M_t._M_deleter(); } + + + + const deleter_type& + get_deleter() const noexcept + { return _M_t._M_deleter(); } + + + + explicit operator bool() const noexcept + { return get() == pointer() ? false : true; } + + + + + + pointer + release() noexcept + { return _M_t.release(); } + + + + + + + + template , + __and_, + is_pointer<_Up>, + is_convertible< + typename remove_pointer<_Up>::type(*)[], + element_type(*)[] + > + > + > + >> + + void + reset(_Up __p) noexcept + { _M_t.reset(std::move(__p)); } + + + void reset(nullptr_t = nullptr) noexcept + { reset(pointer()); } + + + + void + swap(unique_ptr& __u) noexcept + { + static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); + _M_t.swap(__u._M_t); + } + + + unique_ptr(const unique_ptr&) = delete; + unique_ptr& operator=(const unique_ptr&) = delete; + }; + + + + + + template + inline + + + + typename enable_if<__is_swappable<_Dp>::value>::type + + + + swap(unique_ptr<_Tp, _Dp>& __x, + unique_ptr<_Tp, _Dp>& __y) noexcept + { __x.swap(__y); } + + + template + typename enable_if::value>::type + swap(unique_ptr<_Tp, _Dp>&, + unique_ptr<_Tp, _Dp>&) = delete; + + + + template + [[__nodiscard__]] + inline bool + operator==(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return __x.get() == __y.get(); } + + + template + [[__nodiscard__]] + inline bool + operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept + { return !__x; } + + + + template + [[__nodiscard__]] + inline bool + operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept + { return !__x; } + + + template + [[__nodiscard__]] + inline bool + operator!=(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return __x.get() != __y.get(); } + + + template + [[__nodiscard__]] + inline bool + operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept + { return (bool)__x; } + + + template + [[__nodiscard__]] + inline bool + operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept + { return (bool)__x; } + + + + template + [[__nodiscard__]] + inline bool + operator<(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { + typedef typename + std::common_type::pointer, + typename unique_ptr<_Up, _Ep>::pointer>::type _CT; + return std::less<_CT>()(__x.get(), __y.get()); + } + + + template + [[__nodiscard__]] + inline bool + operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { + return std::less::pointer>()(__x.get(), + nullptr); + } + + + template + [[__nodiscard__]] + inline bool + operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { + return std::less::pointer>()(nullptr, + __x.get()); + } + + + template + [[__nodiscard__]] + inline bool + operator<=(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return !(__y < __x); } + + + template + [[__nodiscard__]] + inline bool + operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return !(nullptr < __x); } + + + template + [[__nodiscard__]] + inline bool + operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { return !(__x < nullptr); } + + + template + [[__nodiscard__]] + inline bool + operator>(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return (__y < __x); } + + + template + [[__nodiscard__]] + inline bool + operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { + return std::less::pointer>()(nullptr, + __x.get()); + } + + + template + [[__nodiscard__]] + inline bool + operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { + return std::less::pointer>()(__x.get(), + nullptr); + } + + + template + [[__nodiscard__]] + inline bool + operator>=(const unique_ptr<_Tp, _Dp>& __x, + const unique_ptr<_Up, _Ep>& __y) + { return !(__x < __y); } + + + template + [[__nodiscard__]] + inline bool + operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) + { return !(__x < nullptr); } + + + template + [[__nodiscard__]] inline bool + operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) + { return !(nullptr < __x); } +# 1006 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template::__enable_hash_call> + struct __uniq_ptr_hash + + : private __poison_hash<_Ptr> + + { + size_t + operator()(const _Up& __u) const + noexcept(noexcept(std::declval>()(std::declval<_Ptr>()))) + { return hash<_Ptr>()(__u.get()); } + }; + + template + struct __uniq_ptr_hash<_Up, _Ptr, false> + : private __poison_hash<_Ptr> + { }; + + + + template + struct hash> + : public __hash_base>, + public __uniq_ptr_hash> + { }; + + + + + +namespace __detail +{ + template + struct _MakeUniq + { typedef unique_ptr<_Tp> __single_object; }; + + template + struct _MakeUniq<_Tp[]> + { typedef unique_ptr<_Tp[]> __array; }; + + template + struct _MakeUniq<_Tp[_Bound]> + { struct __invalid_type { }; }; + + template + using __unique_ptr_t = typename _MakeUniq<_Tp>::__single_object; + template + using __unique_ptr_array_t = typename _MakeUniq<_Tp>::__array; + template + using __invalid_make_unique_t = typename _MakeUniq<_Tp>::__invalid_type; +} +# 1066 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + + inline __detail::__unique_ptr_t<_Tp> + make_unique(_Args&&... __args) + { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } +# 1081 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + template + + inline __detail::__unique_ptr_array_t<_Tp> + make_unique(size_t __num) + { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); } + + + + + + + template + __detail::__invalid_make_unique_t<_Tp> + make_unique(_Args&&...) = delete; +# 1154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + } + + + +} +# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 1 3 +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 + template + struct char_traits; + + template<> struct char_traits; + + template<> struct char_traits; + + + + + + + template<> struct char_traits; + template<> struct char_traits; + + +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_string; + +} + + + typedef basic_string string; + + + typedef basic_string wstring; +# 89 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 + typedef basic_string u16string; + + + typedef basic_string u32string; + + + + + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 27 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/include/bits/floatn.h" 1 3 4 +# 119 "/usr/include/bits/floatn.h" 3 4 +# 1 "/usr/include/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/bits/floatn-common.h" 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 25 "/usr/include/bits/floatn-common.h" 2 3 4 +# 214 "/usr/include/bits/floatn-common.h" 3 4 +typedef float _Float32; +# 251 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float64; +# 268 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float32x; +# 285 "/usr/include/bits/floatn-common.h" 3 4 +typedef long double _Float64x; +# 120 "/usr/include/bits/floatn.h" 2 3 4 +# 31 "/usr/include/wchar.h" 2 3 4 + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 36 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 +# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 39 "/usr/include/wchar.h" 2 3 4 + + + + +typedef __gnuc_va_list va_list; +# 52 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 +# 20 "/usr/include/bits/types/wint_t.h" 3 4 +typedef unsigned int wint_t; +# 53 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 + + + +# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 +# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 +typedef struct +{ + int __count; + union + { + unsigned int __wch; + char __wchb[4]; + } __value; +} __mbstate_t; +# 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4 + +typedef __mbstate_t mbstate_t; +# 54 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 + + + +struct _IO_FILE; +typedef struct _IO_FILE __FILE; +# 55 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/include/bits/types/FILE.h" 1 3 4 + + + +struct _IO_FILE; + + +typedef struct _IO_FILE FILE; +# 58 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 61 "/usr/include/wchar.h" 2 3 4 +# 90 "/usr/include/wchar.h" 3 4 +extern "C" { + + + +struct tm; + + + +extern wchar_t *wcscpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern wchar_t *wcsncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern size_t wcslcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern size_t wcslcat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern wchar_t *wcscat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern wchar_t *wcsncat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + +extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, + size_t __n) noexcept (true); + + + +extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + +extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + + + +extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + + +extern size_t wcsxfrm (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + + + + + +extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + + + + +extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + +extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) + __attribute__ ((__malloc__)) ; +# 189 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); +# 199 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + +extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) + noexcept (true) __attribute__ ((__pure__)); + + +extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 226 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 237 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + +extern wchar_t *wcstok (wchar_t *__restrict __s, + const wchar_t *__restrict __delim, + wchar_t **__restrict __ptr) noexcept (true); + + +extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); +# 258 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)); +# 278 "/usr/include/wchar.h" 3 4 +extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + + +extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + +extern wchar_t *wmemcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + +extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true); + + +extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); + + + + +extern wchar_t *wmempcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) + noexcept (true); + + + + + +extern wint_t btowc (int __c) noexcept (true); + + + +extern int wctob (wint_t __c) noexcept (true); + + + +extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); + + + +extern size_t mbrtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n, + mbstate_t *__restrict __p) noexcept (true); + + +extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, + mbstate_t *__restrict __ps) noexcept (true); + + +extern size_t __mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); +extern size_t mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + + +extern wint_t __btowc_alias (int __c) __asm ("btowc"); +extern __inline __attribute__ ((__gnu_inline__)) wint_t + btowc (int __c) noexcept (true) +{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' + ? (wint_t) __c : __btowc_alias (__c)); } + +extern int __wctob_alias (wint_t __c) __asm ("wctob"); +extern __inline __attribute__ ((__gnu_inline__)) int + wctob (wint_t __wc) noexcept (true) +{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' + ? (int) __wc : __wctob_alias (__wc)); } + +extern __inline __attribute__ ((__gnu_inline__)) size_t + mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) + +{ return (__ps != __null + ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } + + + + +extern size_t mbsrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + +extern size_t mbsnrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsnrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + +extern int wcwidth (wchar_t __c) noexcept (true); + + + +extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); + + + + + +extern double wcstod (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern float wcstof (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +extern long double wcstold (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 422 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 437 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 455 "/usr/include/wchar.h" 3 4 +extern long int wcstol (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) noexcept (true); + + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + + +extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); +# 561 "/usr/include/wchar.h" 3 4 +extern long int wcstol_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base, + locale_t __loc) noexcept (true); + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true); + + + + + +extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); + + + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); + + + + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); + + + + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); +# 630 "/usr/include/wchar.h" 3 4 +extern double wcstod_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern float wcstof_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern long double wcstold_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 649 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 667 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 689 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcpcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) noexcept (true); + + + +extern wchar_t *wcpncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true); +# 718 "/usr/include/wchar.h" 3 4 +extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern int fwide (__FILE *__fp, int __mode) noexcept (true); + + + + + + +extern int fwprintf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wprintf (const wchar_t *__restrict __format, ...) + ; + +extern int swprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, ...) + noexcept (true) ; + + + + + +extern int vfwprintf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwprintf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + +extern int vswprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; + + + + + + +extern int fwscanf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wscanf (const wchar_t *__restrict __format, ...) + ; + +extern int swscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, ...) + noexcept (true) ; +# 795 "/usr/include/wchar.h" 3 4 +extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") + + + ; +extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") + + ; +extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") + + + ; +# 851 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwscanf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + +extern int vswscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; +# 875 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") + + + ; +extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") + + ; +extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") + + + ; +# 935 "/usr/include/wchar.h" 3 4 +extern wint_t fgetwc (__FILE *__stream); +extern wint_t getwc (__FILE *__stream); + + + + + +extern wint_t getwchar (void); + + + + + + +extern wint_t fputwc (wchar_t __wc, __FILE *__stream); +extern wint_t putwc (wchar_t __wc, __FILE *__stream); + + + + + +extern wint_t putwchar (wchar_t __wc); + + + + + + + +extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + +extern int fputws (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern wint_t ungetwc (wint_t __wc, __FILE *__stream); +# 990 "/usr/include/wchar.h" 3 4 +extern wint_t getwc_unlocked (__FILE *__stream); +extern wint_t getwchar_unlocked (void); + + + + + + + +extern wint_t fgetwc_unlocked (__FILE *__stream); + + + + + + + +extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); +# 1016 "/usr/include/wchar.h" 3 4 +extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); +extern wint_t putwchar_unlocked (wchar_t __wc); +# 1026 "/usr/include/wchar.h" 3 4 +extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + + + +extern int fputws_unlocked (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp) noexcept (true); + + + + +extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); +# 1073 "/usr/include/wchar.h" 3 4 +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 2 3 +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +namespace std +{ + using ::mbstate_t; +} +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::wint_t; + + using ::btowc; + using ::fgetwc; + using ::fgetws; + using ::fputwc; + using ::fputws; + using ::fwide; + using ::fwprintf; + using ::fwscanf; + using ::getwc; + using ::getwchar; + using ::mbrlen; + using ::mbrtowc; + using ::mbsinit; + using ::mbsrtowcs; + using ::putwc; + using ::putwchar; + + using ::swprintf; + + using ::swscanf; + using ::ungetwc; + using ::vfwprintf; + + using ::vfwscanf; + + + using ::vswprintf; + + + using ::vswscanf; + + using ::vwprintf; + + using ::vwscanf; + + using ::wcrtomb; + using ::wcscat; + using ::wcscmp; + using ::wcscoll; + using ::wcscpy; + using ::wcscspn; + using ::wcsftime; + using ::wcslen; + using ::wcsncat; + using ::wcsncmp; + using ::wcsncpy; + using ::wcsrtombs; + using ::wcsspn; + using ::wcstod; + + using ::wcstof; + + using ::wcstok; + using ::wcstol; + using ::wcstoul; + using ::wcsxfrm; + using ::wctob; + using ::wmemcmp; + using ::wmemcpy; + using ::wmemmove; + using ::wmemset; + using ::wprintf; + using ::wscanf; + using ::wcschr; + using ::wcspbrk; + using ::wcsrchr; + using ::wcsstr; + using ::wmemchr; + + + inline wchar_t* + wcschr(wchar_t* __p, wchar_t __c) + { return wcschr(const_cast(__p), __c); } + + inline wchar_t* + wcspbrk(wchar_t* __s1, const wchar_t* __s2) + { return wcspbrk(const_cast(__s1), __s2); } + + inline wchar_t* + wcsrchr(wchar_t* __p, wchar_t __c) + { return wcsrchr(const_cast(__p), __c); } + + inline wchar_t* + wcsstr(wchar_t* __s1, const wchar_t* __s2) + { return wcsstr(const_cast(__s1), __s2); } + + inline wchar_t* + wmemchr(wchar_t* __p, wchar_t __c, size_t __n) + { return wmemchr(const_cast(__p), __c, __n); } + + + +} +} + + + + + + + +namespace __gnu_cxx +{ + + + + + + using ::wcstold; +# 260 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 + using ::wcstoll; + using ::wcstoull; + +} + +namespace std +{ + using ::__gnu_cxx::wcstold; + using ::__gnu_cxx::wcstoll; + using ::__gnu_cxx::wcstoull; +} +# 280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +namespace std +{ + + using std::wcstof; + + + using std::vfwscanf; + + + using std::vswscanf; + + + using std::vwscanf; + + + + using std::wcstold; + using std::wcstoll; + using std::wcstoull; + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + typedef long int streamoff; + + + + + + typedef ptrdiff_t streamsize; +# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + template + class fpos + { + private: + streamoff _M_off; + _StateT _M_state; + + public: + + + + + fpos() + : _M_off(0), _M_state() { } +# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + fpos(streamoff __off) + : _M_off(__off), _M_state() { } + + + fpos(const fpos&) = default; + fpos& operator=(const fpos&) = default; + ~fpos() = default; + + + + operator streamoff() const { return _M_off; } + + + void + state(_StateT __st) + { _M_state = __st; } + + + _StateT + state() const + { return _M_state; } + + + + + + fpos& + operator+=(streamoff __off) + { + _M_off += __off; + return *this; + } + + + + + + fpos& + operator-=(streamoff __off) + { + _M_off -= __off; + return *this; + } + + + + + + + + fpos + operator+(streamoff __off) const + { + fpos __pos(*this); + __pos += __off; + return __pos; + } + + + + + + + + fpos + operator-(streamoff __off) const + { + fpos __pos(*this); + __pos -= __off; + return __pos; + } + + + + + + + streamoff + operator-(const fpos& __other) const + { return _M_off - __other._M_off; } + }; + + + + + + + template + inline bool + operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) == streamoff(__rhs); } + + template + inline bool + operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) != streamoff(__rhs); } + + + + + + typedef fpos streampos; + + typedef fpos wstreampos; +# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + typedef fpos u16streampos; + + typedef fpos u32streampos; + + + +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 76 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 + class ios_base; + + template > + class basic_ios; + + template > + class basic_streambuf; + + template > + class basic_istream; + + template > + class basic_ostream; + + template > + class basic_iostream; + + +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringbuf; + + template, + typename _Alloc = allocator<_CharT> > + class basic_istringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_ostringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringstream; + +} + + template > + class basic_filebuf; + + template > + class basic_ifstream; + + template > + class basic_ofstream; + + template > + class basic_fstream; + + template > + class istreambuf_iterator; + + template > + class ostreambuf_iterator; + + + + typedef basic_ios ios; + + + typedef basic_streambuf streambuf; + + + typedef basic_istream istream; + + + typedef basic_ostream ostream; + + + typedef basic_iostream iostream; + + + typedef basic_stringbuf stringbuf; + + + typedef basic_istringstream istringstream; + + + typedef basic_ostringstream ostringstream; + + + typedef basic_stringstream stringstream; + + + typedef basic_filebuf filebuf; + + + typedef basic_ifstream ifstream; + + + typedef basic_ofstream ofstream; + + + typedef basic_fstream fstream; + + + + typedef basic_ios wios; + + + typedef basic_streambuf wstreambuf; + + + typedef basic_istream wistream; + + + typedef basic_ostream wostream; + + + typedef basic_iostream wiostream; + + + typedef basic_stringbuf wstringbuf; + + + typedef basic_istringstream wistringstream; + + + typedef basic_ostringstream wostringstream; + + + typedef basic_stringstream wstringstream; + + + typedef basic_filebuf wfilebuf; + + + typedef basic_ifstream wifstream; + + + typedef basic_ofstream wofstream; + + + typedef basic_fstream wfstream; +# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 +} +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 1 3 +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + + + + + + +#pragma GCC visibility push(default) + + + + + +extern "C++" { + +namespace __cxxabiv1 +{ + class __class_type_info; +} +# 84 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 +namespace std +{ + + + + + + + class type_info + { + public: + + + + + virtual ~type_info(); + + + + const char* name() const noexcept + { return __name[0] == '*' ? __name + 1 : __name; } + + + + bool before(const type_info& __arg) const noexcept; + + + bool operator==(const type_info& __arg) const noexcept; + + + 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&) = delete; + type_info(const type_info&) = delete; +# 167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + }; + + + inline bool + type_info::before(const type_info& __arg) const noexcept + { + + + + + if (__name[0] != '*' || __arg.__name[0] != '*') + return __builtin_strcmp (__name, __arg.__name) < 0; +# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + return __name < __arg.__name; + } + + + + inline bool + type_info::operator==(const type_info& __arg) const noexcept + { + if (std::__is_constant_evaluated()) + return this == &__arg; + + if (__name == __arg.__name) + return true; + + + + + + + return __name[0] != '*' && __builtin_strcmp (__name, __arg.name()) == 0; + + + + } +# 220 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + class bad_cast : public exception + { + public: + bad_cast() noexcept { } + + + + virtual ~bad_cast() noexcept; + + + virtual const char* what() const noexcept; + }; + + + + + + class bad_typeid : public exception + { + public: + bad_typeid () noexcept { } + + + + virtual ~bad_typeid() noexcept; + + + virtual const char* what() const noexcept; + }; +} + +} + +#pragma GCC visibility pop +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocated_ptr.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocated_ptr.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + struct __allocated_ptr + { + using pointer = typename allocator_traits<_Alloc>::pointer; + using value_type = typename allocator_traits<_Alloc>::value_type; + + + __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept + : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr) + { } + + + template>> + __allocated_ptr(_Alloc& __a, _Ptr __ptr) + : _M_alloc(std::__addressof(__a)), + _M_ptr(pointer_traits::pointer_to(*__ptr)) + { } + + + __allocated_ptr(__allocated_ptr&& __gd) noexcept + : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr) + { __gd._M_ptr = nullptr; } + + + ~__allocated_ptr() + { + if (_M_ptr != nullptr) + std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1); + } + + + __allocated_ptr& + operator=(std::nullptr_t) noexcept + { + _M_ptr = nullptr; + return *this; + } + + + value_type* get() { return std::__to_address(_M_ptr); } + + private: + _Alloc* _M_alloc; + pointer _M_ptr; + }; + + + template + __allocated_ptr<_Alloc> + __allocate_guarded(_Alloc& __a) + { + return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) }; + } + + + +} +# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 + template + struct _Maybe_unary_or_binary_function { }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1> + : std::unary_function<_T1, _Res> { }; + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> + : std::binary_function<_T1, _T2, _Res> { }; + +#pragma GCC diagnostic pop + + template + struct _Mem_fn_traits; + + template + struct _Mem_fn_traits_base + { + using __result_type = _Res; + using __maybe_type + = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; + using __arity = integral_constant; + }; +# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; + + +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; + + + + + + + template> + struct _Maybe_get_result_type + { }; + + template + struct _Maybe_get_result_type<_Functor, + __void_t> + { typedef typename _Functor::result_type result_type; }; + + + + + + template + struct _Weak_result_type_impl + : _Maybe_get_result_type<_Functor> + { }; + + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct + _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)> + { typedef _Res result_type; }; + + + template::value> + struct _Weak_result_type_memfun + : _Weak_result_type_impl<_Functor> + { }; + + + template + struct _Weak_result_type_memfun<_MemFunPtr, true> + { + using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; + }; + + + template + struct _Weak_result_type_memfun<_Func _Class::*, false> + { }; + + + + + + template + struct _Weak_result_type + : _Weak_result_type_memfun::type> + { }; + + + + template> + struct _Refwrap_base_arg1 + { }; + + + template + struct _Refwrap_base_arg1<_Tp, + __void_t> + { + typedef typename _Tp::argument_type argument_type; + }; + + + template> + struct _Refwrap_base_arg2 + { }; + + + template + struct _Refwrap_base_arg2<_Tp, + __void_t> + { + typedef typename _Tp::first_argument_type first_argument_type; + typedef typename _Tp::second_argument_type second_argument_type; + }; + + + + + + + + template + struct _Reference_wrapper_base + : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> + { }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) volatile> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const volatile> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> + : binary_function<_T1, _T2, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)> + : binary_function<_T1, _T2, _Res> + { }; + + template::value> + struct _Reference_wrapper_base_memfun + : _Reference_wrapper_base<_Tp> + { }; + + template + struct _Reference_wrapper_base_memfun<_MemFunPtr, true> + : _Mem_fn_traits<_MemFunPtr>::__maybe_type + { + using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; + }; +#pragma GCC diagnostic pop + + + + + + + + + template + class reference_wrapper + + + + : public _Reference_wrapper_base_memfun::type> + + { + _Tp* _M_data; + + + static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } + + static void _S_fun(_Tp&&) = delete; + + template> + using __not_same + = typename enable_if::value>::type; + + public: + typedef _Tp type; + + + + + template, typename + = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> + + reference_wrapper(_Up&& __uref) + noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) + : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) + { } + + reference_wrapper(const reference_wrapper&) = default; + + reference_wrapper& + operator=(const reference_wrapper&) = default; + + + operator _Tp&() const noexcept + { return this->get(); } + + + _Tp& + get() const noexcept + { return *_M_data; } + + template + + typename __invoke_result<_Tp&, _Args...>::type + operator()(_Args&&... __args) const + noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value) + { + + + + + return std::__invoke(get(), std::forward<_Args>(__args)...); + } + }; + + + template + reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; + + + + + + template + + inline reference_wrapper<_Tp> + ref(_Tp& __t) noexcept + { return reference_wrapper<_Tp>(__t); } + + + template + + inline reference_wrapper + cref(const _Tp& __t) noexcept + { return reference_wrapper(__t); } + + template + void ref(const _Tp&&) = delete; + + template + void cref(const _Tp&&) = delete; + + + template + + inline reference_wrapper<_Tp> + ref(reference_wrapper<_Tp> __t) noexcept + { return __t; } + + + template + + inline reference_wrapper + cref(reference_wrapper<_Tp> __t) noexcept + { return { __t.get() }; } + + + + +} +# 58 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/aligned_buffer.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/aligned_buffer.h" 3 + + + + + + + +namespace __gnu_cxx +{ + + + + + template + struct __aligned_membuf + { + + + + + + struct _Tp2 { _Tp _M_t; }; + + alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)]; + + __aligned_membuf() = default; + + + __aligned_membuf(std::nullptr_t) { } + + void* + _M_addr() noexcept + { return static_cast(&_M_storage); } + + const void* + _M_addr() const noexcept + { return static_cast(&_M_storage); } + + _Tp* + _M_ptr() noexcept + { return static_cast<_Tp*>(_M_addr()); } + + const _Tp* + _M_ptr() const noexcept + { return static_cast(_M_addr()); } + }; + + + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + + + template + struct __aligned_buffer + : std::aligned_storage + { + typename + std::aligned_storage::type _M_storage; + + __aligned_buffer() = default; + + + __aligned_buffer(std::nullptr_t) { } + + void* + _M_addr() noexcept + { + return static_cast(&_M_storage); + } + + const void* + _M_addr() const noexcept + { + return static_cast(&_M_storage); + } + + _Tp* + _M_ptr() noexcept + { return static_cast<_Tp*>(_M_addr()); } + + const _Tp* + _M_ptr() const noexcept + { return static_cast(_M_addr()); } + }; +#pragma GCC diagnostic pop + + +} +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 1 3 +# 30 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 +#pragma GCC visibility push(default) +# 148 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +# 1 "/usr/include/pthread.h" 1 3 4 +# 22 "/usr/include/pthread.h" 3 4 +# 1 "/usr/include/sched.h" 1 3 4 +# 29 "/usr/include/sched.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 30 "/usr/include/sched.h" 2 3 4 + +# 1 "/usr/include/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 32 "/usr/include/sched.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 + + + + + +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 35 "/usr/include/bits/endian.h" 3 4 +# 1 "/usr/include/bits/endianness.h" 1 3 4 +# 36 "/usr/include/bits/endian.h" 2 3 4 +# 7 "/usr/include/bits/types/struct_timespec.h" 2 3 4 + + + + +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 +}; +# 33 "/usr/include/sched.h" 2 3 4 + + + + + +typedef __pid_t pid_t; + + + + +# 1 "/usr/include/bits/sched.h" 1 3 4 +# 80 "/usr/include/bits/sched.h" 3 4 +# 1 "/usr/include/bits/types/struct_sched_param.h" 1 3 4 +# 23 "/usr/include/bits/types/struct_sched_param.h" 3 4 +struct sched_param +{ + int sched_priority; +}; +# 81 "/usr/include/bits/sched.h" 2 3 4 + +extern "C" { + + + +extern int clone (int (*__fn) (void *__arg), void *__child_stack, + int __flags, void *__arg, ...) noexcept (true); + + +extern int unshare (int __flags) noexcept (true); + + +extern int sched_getcpu (void) noexcept (true); + + +extern int getcpu (unsigned int *, unsigned int *) noexcept (true); + + +extern int setns (int __fd, int __nstype) noexcept (true); + + +} +# 44 "/usr/include/sched.h" 2 3 4 +# 1 "/usr/include/bits/cpu-set.h" 1 3 4 +# 32 "/usr/include/bits/cpu-set.h" 3 4 +typedef unsigned long int __cpu_mask; + + + + + + +typedef struct +{ + __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; +} cpu_set_t; +# 115 "/usr/include/bits/cpu-set.h" 3 4 +extern "C" { + +extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) + noexcept (true); +extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) ; +extern void __sched_cpufree (cpu_set_t *__set) noexcept (true); + +} +# 45 "/usr/include/sched.h" 2 3 4 + + + + + + +extern "C" { + + +extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) + noexcept (true); + + +extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true); + + +extern int sched_setscheduler (__pid_t __pid, int __policy, + const struct sched_param *__param) noexcept (true); + + +extern int sched_getscheduler (__pid_t __pid) noexcept (true); + + +extern int sched_yield (void) noexcept (true); + + +extern int sched_get_priority_max (int __algorithm) noexcept (true); + + +extern int sched_get_priority_min (int __algorithm) noexcept (true); + + + +extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true); +# 130 "/usr/include/sched.h" 3 4 +extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, + const cpu_set_t *__cpuset) noexcept (true); + + +extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, + cpu_set_t *__cpuset) noexcept (true); + + +} +# 23 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 73 "/usr/include/bits/time.h" 3 4 +# 1 "/usr/include/bits/timex.h" 1 3 4 +# 22 "/usr/include/bits/timex.h" 3 4 +# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 23 "/usr/include/bits/timex.h" 2 3 4 + + + +struct timex +{ +# 58 "/usr/include/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); +# 90 "/usr/include/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 38 "/usr/include/time.h" 2 3 4 + +# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 + + + + + + +# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 47 "/usr/include/time.h" 2 3 4 +# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 48 "/usr/include/time.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0) + noexcept (true) __attribute__ ((__const__)); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 100 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) + noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 155 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 180 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 198 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 218 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 247 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); +# 264 "/usr/include/time.h" 3 4 +extern time_t timelocal (struct tm *__tp) noexcept (true); + + + + + + + +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 282 "/usr/include/time.h" 3 4 +extern int nanosleep (const struct timespec *__requested_time, + struct timespec *__remaining); + + +extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 324 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 339 "/usr/include/time.h" 3 4 +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) noexcept (true); + + +extern int timer_delete (timer_t __timerid) noexcept (true); + + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) noexcept (true); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + noexcept (true); +# 377 "/usr/include/time.h" 3 4 +extern int timer_getoverrun (timer_t __timerid) noexcept (true); + + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 400 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 426 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 435 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 449 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 24 "/usr/include/pthread.h" 2 3 4 + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 27 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/setjmp.h" 1 3 4 +# 26 "/usr/include/bits/setjmp.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 27 "/usr/include/bits/setjmp.h" 2 3 4 + + + + +typedef long int __jmp_buf[8]; +# 28 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 29 "/usr/include/pthread.h" 2 3 4 + +# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 31 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/types/struct___jmp_buf_tag.h" 1 3 4 +# 26 "/usr/include/bits/types/struct___jmp_buf_tag.h" 3 4 +struct __jmp_buf_tag + { + + + + + __jmp_buf __jmpbuf; + int __mask_was_saved; + __sigset_t __saved_mask; + }; +# 32 "/usr/include/pthread.h" 2 3 4 + +# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 34 "/usr/include/pthread.h" 2 3 4 + + + +enum +{ + PTHREAD_CREATE_JOINABLE, + + PTHREAD_CREATE_DETACHED + +}; + + + +enum +{ + PTHREAD_MUTEX_TIMED_NP, + PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_ADAPTIVE_NP + + , + PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, + PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL + + + + , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP + +}; + + + + +enum +{ + PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_ROBUST, + PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST +}; + + + + + +enum +{ + PTHREAD_PRIO_NONE, + PTHREAD_PRIO_INHERIT, + PTHREAD_PRIO_PROTECT +}; +# 104 "/usr/include/pthread.h" 3 4 +enum +{ + PTHREAD_RWLOCK_PREFER_READER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, + PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP +}; +# 124 "/usr/include/pthread.h" 3 4 +enum +{ + PTHREAD_INHERIT_SCHED, + + PTHREAD_EXPLICIT_SCHED + +}; + + + +enum +{ + PTHREAD_SCOPE_SYSTEM, + + PTHREAD_SCOPE_PROCESS + +}; + + + +enum +{ + PTHREAD_PROCESS_PRIVATE, + + PTHREAD_PROCESS_SHARED + +}; +# 159 "/usr/include/pthread.h" 3 4 +struct _pthread_cleanup_buffer +{ + void (*__routine) (void *); + void *__arg; + int __canceltype; + struct _pthread_cleanup_buffer *__prev; +}; + + +enum +{ + PTHREAD_CANCEL_ENABLE, + + PTHREAD_CANCEL_DISABLE + +}; +enum +{ + PTHREAD_CANCEL_DEFERRED, + + PTHREAD_CANCEL_ASYNCHRONOUS + +}; +# 197 "/usr/include/pthread.h" 3 4 +extern "C" { + + + + +extern int pthread_create (pthread_t *__restrict __newthread, + const pthread_attr_t *__restrict __attr, + void *(*__start_routine) (void *), + void *__restrict __arg) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + + + +extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); + + + + + + + +extern int pthread_join (pthread_t __th, void **__thread_return); + + + + +extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) noexcept (true); +# 233 "/usr/include/pthread.h" 3 4 +extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, + const struct timespec *__abstime); +# 243 "/usr/include/pthread.h" 3 4 +extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return, + clockid_t __clockid, + const struct timespec *__abstime); +# 269 "/usr/include/pthread.h" 3 4 +extern int pthread_detach (pthread_t __th) noexcept (true); + + + +extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__)); + + +extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) + noexcept (true) __attribute__ ((__const__)); + + + + + + + +extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_destroy (pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, + int *__detachstate) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, + int __detachstate) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, + size_t *__guardsize) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setguardsize (pthread_attr_t *__attr, + size_t __guardsize) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, + struct sched_param *__restrict __param) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, + const struct sched_param *__restrict + __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict + __attr, int *__restrict __policy) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict + __attr, int *__restrict __inherit) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, + int __inherit) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, + int *__restrict __scope) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict + __attr, void **__restrict __stackaddr) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); + + + + + +extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, + void *__stackaddr) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); + + +extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict + __attr, size_t *__restrict __stacksize) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int pthread_attr_setstacksize (pthread_attr_t *__attr, + size_t __stacksize) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, + void **__restrict __stackaddr, + size_t *__restrict __stacksize) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))); + + + + +extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, + size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, + size_t __cpusetsize, + const cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, + size_t __cpusetsize, + cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + +extern int pthread_getattr_default_np (pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr, + const __sigset_t *sigmask); + + + + +extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr, + __sigset_t *sigmask); + + + + + + + +extern int pthread_setattr_default_np (const pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + + + + +extern int pthread_setschedparam (pthread_t __target_thread, int __policy, + const struct sched_param *__param) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + +extern int pthread_getschedparam (pthread_t __target_thread, + int *__restrict __policy, + struct sched_param *__restrict __param) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + +extern int pthread_setschedprio (pthread_t __target_thread, int __prio) + noexcept (true); + + + + +extern int pthread_getname_np (pthread_t __target_thread, char *__buf, + size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int pthread_setname_np (pthread_t __target_thread, const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + + +extern int pthread_getconcurrency (void) noexcept (true); + + +extern int pthread_setconcurrency (int __level) noexcept (true); + + + +extern int pthread_yield (void) noexcept (true); + +extern int pthread_yield (void) noexcept (true) __asm__ ("" "sched_yield") + __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead"))); +# 489 "/usr/include/pthread.h" 3 4 +extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, + const cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + +extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, + cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 509 "/usr/include/pthread.h" 3 4 +extern int pthread_once (pthread_once_t *__once_control, + void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); +# 521 "/usr/include/pthread.h" 3 4 +extern int pthread_setcancelstate (int __state, int *__oldstate); + + + +extern int pthread_setcanceltype (int __type, int *__oldtype); + + +extern int pthread_cancel (pthread_t __th); + + + + +extern void pthread_testcancel (void); + + + + +struct __cancel_jmp_buf_tag +{ + __jmp_buf __cancel_jmp_buf; + int __mask_was_saved; +}; + +typedef struct +{ + struct __cancel_jmp_buf_tag __cancel_jmp_buf[1]; + void *__pad[4]; +} __pthread_unwind_buf_t __attribute__ ((__aligned__)); +# 557 "/usr/include/pthread.h" 3 4 +struct __pthread_cleanup_frame +{ + void (*__cancel_routine) (void *); + void *__cancel_arg; + int __do_it; + int __cancel_type; +}; + + + + +class __pthread_cleanup_class +{ + void (*__cancel_routine) (void *); + void *__cancel_arg; + int __do_it; + int __cancel_type; + + public: + __pthread_cleanup_class (void (*__fct) (void *), void *__arg) + : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } + ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } + void __setdoit (int __newval) { __do_it = __newval; } + void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, + &__cancel_type); } + void __restore () const { pthread_setcanceltype (__cancel_type, 0); } +}; +# 773 "/usr/include/pthread.h" 3 4 +extern int __sigsetjmp (struct __jmp_buf_tag __env[1], + int __savemask) noexcept (true); + + + + + + +extern int pthread_mutex_init (pthread_mutex_t *__mutex, + const pthread_mutexattr_t *__mutexattr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_lock (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 817 "/usr/include/pthread.h" 3 4 +extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex, + clockid_t __clockid, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 835 "/usr/include/pthread.h" 3 4 +extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutex_getprioceiling (const pthread_mutex_t * + __restrict __mutex, + int *__restrict __prioceiling) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, + int __prioceiling, + int *__restrict __old_ceiling) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + + +extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_consistent_np (pthread_mutex_t *) noexcept (true) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nonnull__ (1))) + + __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent"))); +# 874 "/usr/include/pthread.h" 3 4 +extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, + int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict + __attr, int *__restrict __kind) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __protocol) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, + int __protocol) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __prioceiling) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, + int __prioceiling) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, + int *__robustness) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) noexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nonnull__ (1))) + + + __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust"))); + + + + + + + +extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, + int __robustness) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) noexcept (true) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nonnull__ (1))) + + + __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust"))); +# 967 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, + const pthread_rwlockattr_t *__restrict + __attr) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 1004 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock, + clockid_t __clockid, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 1023 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 1051 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock, + clockid_t __clockid, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 1071 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, + int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * + __restrict __attr, + int *__restrict __pref) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, + int __pref) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern int pthread_cond_init (pthread_cond_t *__restrict __cond, + const pthread_condattr_t *__restrict __cond_attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_destroy (pthread_cond_t *__cond) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_signal (pthread_cond_t *__cond) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_broadcast (pthread_cond_t *__cond) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex) + __attribute__ ((__nonnull__ (1, 2))); +# 1145 "/usr/include/pthread.h" 3 4 +extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex, + const struct timespec *__restrict __abstime) + __attribute__ ((__nonnull__ (1, 2, 3))); +# 1171 "/usr/include/pthread.h" 3 4 +extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex, + __clockid_t __clock_id, + const struct timespec *__restrict __abstime) + __attribute__ ((__nonnull__ (1, 2, 4))); +# 1194 "/usr/include/pthread.h" 3 4 +extern int pthread_condattr_init (pthread_condattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_condattr_destroy (pthread_condattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_condattr_getpshared (const pthread_condattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, + int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_condattr_getclock (const pthread_condattr_t * + __restrict __attr, + __clockid_t *__restrict __clock_id) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_condattr_setclock (pthread_condattr_t *__attr, + __clockid_t __clock_id) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1230 "/usr/include/pthread.h" 3 4 +extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_destroy (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_lock (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_trylock (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_unlock (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, + const pthread_barrierattr_t *__restrict + __attr, unsigned int __count) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrier_wait (pthread_barrier_t *__barrier) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, + int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1297 "/usr/include/pthread.h" 3 4 +extern int pthread_key_create (pthread_key_t *__key, + void (*__destr_function) (void *)) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_key_delete (pthread_key_t __key) noexcept (true); + + +extern void *pthread_getspecific (pthread_key_t __key) noexcept (true); + + +extern int pthread_setspecific (pthread_key_t __key, + const void *__pointer) + noexcept (true) ; + + + + +extern int pthread_getcpuclockid (pthread_t __thread_id, + __clockid_t *__clock_id) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 1332 "/usr/include/pthread.h" 3 4 +extern int pthread_atfork (void (*__prepare) (void), + void (*__parent) (void), + void (*__child) (void)) noexcept (true); + + + + +extern __inline __attribute__ ((__gnu_inline__)) int + pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true) +{ + return __thread1 == __thread2; +} + + +} +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +typedef pthread_t __gthread_t; +typedef pthread_key_t __gthread_key_t; +typedef pthread_once_t __gthread_once_t; +typedef pthread_mutex_t __gthread_mutex_t; +typedef pthread_mutex_t __gthread_recursive_mutex_t; +typedef pthread_cond_t __gthread_cond_t; +typedef struct timespec __gthread_time_t; +# 299 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_active_p (void) +{ + return 1; +} +# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), + void *__args) +{ + return pthread_create (__threadid, __null, __func, __args); +} + +static inline int +__gthread_join (__gthread_t __threadid, void **__value_ptr) +{ + return pthread_join (__threadid, __value_ptr); +} + +static inline int +__gthread_detach (__gthread_t __threadid) +{ + return pthread_detach (__threadid); +} + +static inline int +__gthread_equal (__gthread_t __t1, __gthread_t __t2) +{ + return pthread_equal (__t1, __t2); +} + +static inline __gthread_t +__gthread_self (void) +{ + return pthread_self (); +} + +static inline int +__gthread_yield (void) +{ + return sched_yield (); +} + +static inline int +__gthread_once (__gthread_once_t *__once, void (*__func) (void)) +{ + if (__gthread_active_p ()) + return pthread_once (__once, __func); + else + return -1; +} + +static inline int +__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) +{ + return pthread_key_create (__key, __dtor); +} + +static inline int +__gthread_key_delete (__gthread_key_t __key) +{ + return pthread_key_delete (__key); +} + +static inline void * +__gthread_getspecific (__gthread_key_t __key) +{ + return pthread_getspecific (__key); +} + +static inline int +__gthread_setspecific (__gthread_key_t __key, const void *__ptr) +{ + return pthread_setspecific (__key, __ptr); +} + +static inline void +__gthread_mutex_init_function (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + pthread_mutex_init (__mutex, __null); +} + +static inline int +__gthread_mutex_destroy (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_destroy (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_lock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_lock (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_trylock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_trylock (__mutex); + else + return 0; +} + + +static inline int +__gthread_mutex_timedlock (__gthread_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + if (__gthread_active_p ()) + return pthread_mutex_timedlock (__mutex, __abs_timeout); + else + return 0; +} + + +static inline int +__gthread_mutex_unlock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_unlock (__mutex); + else + return 0; +} +# 808 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_lock (__mutex); +} + +static inline int +__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_trylock (__mutex); +} + + +static inline int +__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + return __gthread_mutex_timedlock (__mutex, __abs_timeout); +} + + +static inline int +__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_unlock (__mutex); +} + +static inline int +__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_destroy (__mutex); +} +# 850 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_cond_broadcast (__gthread_cond_t *__cond) +{ + return pthread_cond_broadcast (__cond); +} + +static inline int +__gthread_cond_signal (__gthread_cond_t *__cond) +{ + return pthread_cond_signal (__cond); +} + +static inline int +__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) +{ + return pthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + return pthread_cond_timedwait (__cond, __mutex, __abs_timeout); +} + +static inline int +__gthread_cond_wait_recursive (__gthread_cond_t *__cond, + __gthread_recursive_mutex_t *__mutex) +{ + return __gthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_destroy (__gthread_cond_t* __cond) +{ + return pthread_cond_destroy (__cond); +} +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 2 3 + + +#pragma GCC visibility pop +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3 +# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 3 +typedef int _Atomic_word; +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 + +# 1 "/usr/include/sys/single_threaded.h" 1 3 4 +# 24 "/usr/include/sys/single_threaded.h" 3 4 +extern "C" { + + + + +extern char __libc_single_threaded; + +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + __attribute__((__always_inline__)) + inline bool + __is_single_threaded() noexcept + { + + + + return ::__libc_single_threaded; + + + + } + + + + + + + inline _Atomic_word + __attribute__((__always_inline__)) + __exchange_and_add(volatile _Atomic_word* __mem, int __val) + { return __atomic_fetch_add(__mem, __val, 4); } + + inline void + __attribute__((__always_inline__)) + __atomic_add(volatile _Atomic_word* __mem, int __val) + { __atomic_fetch_add(__mem, __val, 4); } +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 + inline _Atomic_word + __attribute__((__always_inline__)) + __exchange_and_add_single(_Atomic_word* __mem, int __val) + { + _Atomic_word __result = *__mem; + *__mem += __val; + return __result; + } + + inline void + __attribute__((__always_inline__)) + __atomic_add_single(_Atomic_word* __mem, int __val) + { *__mem += __val; } + + inline _Atomic_word + __attribute__ ((__always_inline__)) + __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) + { + if (__is_single_threaded()) + return __exchange_and_add_single(__mem, __val); + else + return __exchange_and_add(__mem, __val); + } + + inline void + __attribute__ ((__always_inline__)) + __atomic_add_dispatch(_Atomic_word* __mem, int __val) + { + if (__is_single_threaded()) + __atomic_add_single(__mem, __val); + else + __atomic_add(__mem, __val); + } + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + class bad_exception : public exception + { + public: + bad_exception() noexcept { } + + + + virtual ~bad_exception() noexcept; + + + virtual const char* + what() const noexcept; + }; + + + typedef void (*terminate_handler) (); + + + terminate_handler set_terminate(terminate_handler) noexcept; + + + + terminate_handler get_terminate() noexcept; + + + + + void terminate() noexcept __attribute__ ((__noreturn__)); + + + + typedef void (*__attribute__ ((__deprecated__)) unexpected_handler) (); + + + + + + __attribute__ ((__deprecated__)) + unexpected_handler set_unexpected(unexpected_handler) noexcept; + + + + + + + + __attribute__ ((__deprecated__)) + unexpected_handler get_unexpected() noexcept; + + + + + + + + __attribute__ ((__deprecated__)) + void unexpected() __attribute__ ((__noreturn__)); +# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + __attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "' instead"))) + bool uncaught_exception() noexcept __attribute__ ((__pure__)); + + + + + + + + int uncaught_exceptions() noexcept __attribute__ ((__pure__)); + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + void __verbose_terminate_handler(); + + +} + +} + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 + +#pragma GCC visibility push(default) + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 +# 35 "/usr/lib/clang/16/include/stddef.h" 3 +typedef long int ptrdiff_t; +# 109 "/usr/lib/clang/16/include/stddef.h" 3 +# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 +# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 +typedef struct { + long long __clang_max_align_nonce1 + __attribute__((__aligned__(__alignof__(long long)))); + long double __clang_max_align_nonce2 + __attribute__((__aligned__(__alignof__(long double)))); +} max_align_t; +# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 2 3 +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 +namespace std +{ + class type_info; +} + +namespace __cxxabiv1 +{ + struct __cxa_refcounted_exception; + + extern "C" + { + + void* + __cxa_allocate_exception(size_t) noexcept; + + void + __cxa_free_exception(void*) noexcept; + + + __cxa_refcounted_exception* + __cxa_init_primary_exception(void *__object, std::type_info *__tinfo, + void ( *__dest) (void *)) + noexcept; + + } +} + + + +#pragma GCC visibility pop +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + class type_info; + + + + + + + namespace __exception_ptr + { + class exception_ptr; + } + + using __exception_ptr::exception_ptr; +# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + exception_ptr current_exception() noexcept; + + template + exception_ptr make_exception_ptr(_Ex) noexcept; + + + void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); + + namespace __exception_ptr + { + using std::rethrow_exception; +# 97 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + class exception_ptr + { + void* _M_exception_object; + + explicit exception_ptr(void* __e) noexcept; + + void _M_addref() noexcept; + void _M_release() noexcept; + + void *_M_get() const noexcept __attribute__ ((__pure__)); + + friend exception_ptr std::current_exception() noexcept; + friend void std::rethrow_exception(exception_ptr); + template + friend exception_ptr std::make_exception_ptr(_Ex) noexcept; + + public: + exception_ptr() noexcept; + + exception_ptr(const exception_ptr&) noexcept; + + + exception_ptr(nullptr_t) noexcept + : _M_exception_object(nullptr) + { } + + exception_ptr(exception_ptr&& __o) noexcept + : _M_exception_object(__o._M_exception_object) + { __o._M_exception_object = nullptr; } +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +# 162 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + explicit operator bool() const noexcept + { return _M_exception_object; } + + + + + + + + friend bool + operator==(const exception_ptr& __x, const exception_ptr& __y) + noexcept + { return __x._M_exception_object == __y._M_exception_object; } + + friend bool + operator!=(const exception_ptr& __x, const exception_ptr& __y) + noexcept + { return __x._M_exception_object != __y._M_exception_object; } + + + const class std::type_info* + __cxa_exception_type() const noexcept + __attribute__ ((__pure__)); + }; + + + inline + exception_ptr::exception_ptr() noexcept + : _M_exception_object(0) + { } + + + inline + exception_ptr::exception_ptr(const exception_ptr& __other) + noexcept + : _M_exception_object(__other._M_exception_object) + { + if (_M_exception_object) + _M_addref(); + } + + + inline + exception_ptr::~exception_ptr() noexcept + { + if (_M_exception_object) + _M_release(); + } + + + inline exception_ptr& + exception_ptr::operator=(const exception_ptr& __other) noexcept + { + exception_ptr(__other).swap(*this); + return *this; + } + + + inline void + exception_ptr::swap(exception_ptr &__other) noexcept + { + void *__tmp = _M_exception_object; + _M_exception_object = __other._M_exception_object; + __other._M_exception_object = __tmp; + } + + + inline void + swap(exception_ptr& __lhs, exception_ptr& __rhs) + { __lhs.swap(__rhs); } + + + template + + inline void + __dest_thunk(void* __x) + { static_cast<_Ex*>(__x)->~_Ex(); } + + + } + + using __exception_ptr::swap; + + + + template + exception_ptr + make_exception_ptr(_Ex __ex) noexcept + { + + using _Ex2 = typename decay<_Ex>::type; + void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); + (void) __cxxabiv1::__cxa_init_primary_exception( + __e, const_cast(&typeid(_Ex)), + __exception_ptr::__dest_thunk<_Ex2>); + try + { + ::new (__e) _Ex2(__ex); + return exception_ptr(__e); + } + catch(...) + { + __cxxabiv1::__cxa_free_exception(__e); + return current_exception(); + } +# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + } +# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 +} + +} +# 165 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + class nested_exception + { + exception_ptr _M_ptr; + + public: + + nested_exception() noexcept : _M_ptr(current_exception()) { } + + nested_exception(const nested_exception&) noexcept = 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)) + { } + }; +# 145 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + 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"); + + + if constexpr (is_class_v<_Up>) + if constexpr (!is_final_v<_Up>) + if constexpr (!is_base_of_v) + throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; + throw std::forward<_Tp>(__t); + + + + + + } +# 203 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + template + + + + inline void + rethrow_if_nested(const _Ex& __ex) + { + const _Ex* __ptr = __builtin_addressof(__ex); +# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + if constexpr (!is_polymorphic_v<_Ex>) + return; + else if constexpr (is_base_of_v + && !is_convertible_v<_Ex*, nested_exception*>) + return; + + + + + else if (auto __ne_ptr = dynamic_cast(__ptr)) + __ne_ptr->rethrow_nested(); + + } + + +} + +} +# 166 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 2 3 + + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; + + + + inline const _Lock_policy __default_lock_policy = + + + + _S_atomic; + + + + + + + class __concurrence_lock_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_lock_error"; } + }; + + class __concurrence_unlock_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_unlock_error"; } + }; + + class __concurrence_broadcast_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_broadcast_error"; } + }; + + class __concurrence_wait_error : public std::exception + { + public: + virtual char const* + what() const throw() + { return "__gnu_cxx::__concurrence_wait_error"; } + }; + + + inline void + __throw_concurrence_lock_error() + { (throw (__concurrence_lock_error())); } + + inline void + __throw_concurrence_unlock_error() + { (throw (__concurrence_unlock_error())); } + + + inline void + __throw_concurrence_broadcast_error() + { (throw (__concurrence_broadcast_error())); } + + inline void + __throw_concurrence_wait_error() + { (throw (__concurrence_wait_error())); } + + + class __mutex + { + private: + + __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } }; + + + + + __mutex(const __mutex&); + __mutex& operator=(const __mutex&); + + public: + __mutex() + { + + + + + } +# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 + void lock() + { + + if (__gthread_active_p()) + { + if (__gthread_mutex_lock(&_M_mutex) != 0) + __throw_concurrence_lock_error(); + } + + } + + void unlock() + { + + if (__gthread_active_p()) + { + if (__gthread_mutex_unlock(&_M_mutex) != 0) + __throw_concurrence_unlock_error(); + } + + } + + __gthread_mutex_t* gthread_mutex(void) + { return &_M_mutex; } + }; + + class __recursive_mutex + { + private: + + __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } }; + + + + + __recursive_mutex(const __recursive_mutex&); + __recursive_mutex& operator=(const __recursive_mutex&); + + public: + __recursive_mutex() + { + + + + + } +# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 + void lock() + { + + if (__gthread_active_p()) + { + if (__gthread_recursive_mutex_lock(&_M_mutex) != 0) + __throw_concurrence_lock_error(); + } + + } + + void unlock() + { + + if (__gthread_active_p()) + { + if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0) + __throw_concurrence_unlock_error(); + } + + } + + __gthread_recursive_mutex_t* gthread_recursive_mutex(void) + { return &_M_mutex; } + }; + + + + + class __scoped_lock + { + public: + typedef __mutex __mutex_type; + + private: + __mutex_type& _M_device; + + __scoped_lock(const __scoped_lock&); + __scoped_lock& operator=(const __scoped_lock&); + + public: + explicit __scoped_lock(__mutex_type& __name) : _M_device(__name) + { _M_device.lock(); } + + ~__scoped_lock() throw() + { _M_device.unlock(); } + }; + + + class __cond + { + private: + + __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } }; + + + + + __cond(const __cond&); + __cond& operator=(const __cond&); + + public: + __cond() + { + + + + + } +# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 + void broadcast() + { + + if (__gthread_active_p()) + { + if (__gthread_cond_broadcast(&_M_cond) != 0) + __throw_concurrence_broadcast_error(); + } + + } + + void wait(__mutex *mutex) + { + + { + if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0) + __throw_concurrence_wait_error(); + } + + } + + void wait_recursive(__recursive_mutex *mutex) + { + + { + if (__gthread_cond_wait_recursive(&_M_cond, + mutex->gthread_recursive_mutex()) + != 0) + __throw_concurrence_wait_error(); + } + + } + }; + + + +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template class auto_ptr; +#pragma GCC diagnostic pop + + + + + + + class bad_weak_ptr : public std::exception + { + public: + virtual char const* what() const noexcept; + + virtual ~bad_weak_ptr() noexcept; + }; + + + inline void + __throw_bad_weak_ptr() + { (throw (bad_weak_ptr())); } + + using __gnu_cxx::_Lock_policy; + using __gnu_cxx::__default_lock_policy; + using __gnu_cxx::_S_single; + using __gnu_cxx::_S_mutex; + using __gnu_cxx::_S_atomic; + + + template<_Lock_policy _Lp> + class _Mutex_base + { + protected: + + enum { _S_need_barriers = 0 }; + }; + + template<> + class _Mutex_base<_S_mutex> + : public __gnu_cxx::__mutex + { + protected: + + + + enum { _S_need_barriers = 1 }; + }; + + template<_Lock_policy _Lp = __default_lock_policy> + class _Sp_counted_base + : public _Mutex_base<_Lp> + { + public: + _Sp_counted_base() noexcept + : _M_use_count(1), _M_weak_count(1) { } + + virtual + ~_Sp_counted_base() noexcept + { } + + + + virtual void + _M_dispose() noexcept = 0; + + + virtual void + _M_destroy() noexcept + { delete this; } + + virtual void* + _M_get_deleter(const std::type_info&) noexcept = 0; + + + void + _M_add_ref_copy() + { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } + + + void + _M_add_ref_lock() + { + if (!_M_add_ref_lock_nothrow()) + __throw_bad_weak_ptr(); + } + + + bool + _M_add_ref_lock_nothrow() noexcept; + + + void + _M_release() noexcept; + + + void + _M_release_last_use() noexcept + { + ; + _M_dispose(); + + + + + if (_Mutex_base<_Lp>::_S_need_barriers) + { + __atomic_thread_fence (4); + } + + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, + -1) == 1) + { + ; + _M_destroy(); + } + } + + + __attribute__((__noinline__)) + void + _M_release_last_use_cold() noexcept + { _M_release_last_use(); } + + + void + _M_weak_add_ref() noexcept + { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } + + + void + _M_weak_release() noexcept + { + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) + { + ; + if (_Mutex_base<_Lp>::_S_need_barriers) + { + + + __atomic_thread_fence (4); + } + _M_destroy(); + } + } + + long + _M_get_use_count() const noexcept + { + + + return __atomic_load_n(&_M_use_count, 0); + } + + private: + _Sp_counted_base(_Sp_counted_base const&) = delete; + _Sp_counted_base& operator=(_Sp_counted_base const&) = delete; + + _Atomic_word _M_use_count; + _Atomic_word _M_weak_count; + }; + + template<> + inline bool + _Sp_counted_base<_S_single>:: + _M_add_ref_lock_nothrow() noexcept + { + if (_M_use_count == 0) + return false; + ++_M_use_count; + return true; + } + + template<> + inline bool + _Sp_counted_base<_S_mutex>:: + _M_add_ref_lock_nothrow() noexcept + { + __gnu_cxx::__scoped_lock sentry(*this); + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) + { + _M_use_count = 0; + return false; + } + return true; + } + + template<> + inline bool + _Sp_counted_base<_S_atomic>:: + _M_add_ref_lock_nothrow() noexcept + { + + _Atomic_word __count = _M_get_use_count(); + do + { + if (__count == 0) + return false; + + + } + while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, + true, 4, + 0)); + return true; + } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_add_ref_copy() + { ++_M_use_count; } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_release() noexcept + { + if (--_M_use_count == 0) + { + _M_dispose(); + if (--_M_weak_count == 0) + _M_destroy(); + } + } + + template<> + inline void + _Sp_counted_base<_S_mutex>::_M_release() noexcept + { + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) + { + _M_release_last_use(); + } + } + + template<> + inline void + _Sp_counted_base<_S_atomic>::_M_release() noexcept + { + ; + + constexpr bool __lock_free + = __atomic_always_lock_free(sizeof(long long), 0) + && __atomic_always_lock_free(sizeof(_Atomic_word), 0); + constexpr bool __double_word + = sizeof(long long) == 2 * sizeof(_Atomic_word); + + + constexpr bool __aligned = __alignof(long long) <= alignof(void*); + if constexpr (__lock_free && __double_word && __aligned) + { + constexpr int __wordbits = 8 * sizeof(_Atomic_word); + constexpr int __shiftbits = __double_word ? __wordbits : 0; + constexpr long long __unique_ref = 1LL + (1LL << __shiftbits); + auto __both_counts = reinterpret_cast(&_M_use_count); + + ; + if (__atomic_load_n(__both_counts, 2) == __unique_ref) + { + + + + + _M_weak_count = _M_use_count = 0; + ; + ; + _M_dispose(); + _M_destroy(); + return; + } + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) + [[__unlikely__]] + { + _M_release_last_use_cold(); + return; + } + } + else + + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) + { + _M_release_last_use(); + } + } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept + { ++_M_weak_count; } + + template<> + inline void + _Sp_counted_base<_S_single>::_M_weak_release() noexcept + { + if (--_M_weak_count == 0) + _M_destroy(); + } + + template<> + inline long + _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept + { return _M_use_count; } + + + + template + class __shared_ptr; + + template + class __weak_ptr; + + template + class __enable_shared_from_this; + + template + class shared_ptr; + + template + class weak_ptr; + + template + struct owner_less; + + template + class enable_shared_from_this; + + template<_Lock_policy _Lp = __default_lock_policy> + class __weak_count; + + template<_Lock_policy _Lp = __default_lock_policy> + class __shared_count; + + + + + + + + template + class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> + { + public: + explicit + _Sp_counted_ptr(_Ptr __p) noexcept + : _M_ptr(__p) { } + + virtual void + _M_dispose() noexcept + { delete _M_ptr; } + + virtual void + _M_destroy() noexcept + { delete this; } + + virtual void* + _M_get_deleter(const std::type_info&) noexcept + { return nullptr; } + + _Sp_counted_ptr(const _Sp_counted_ptr&) = delete; + _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; + + private: + _Ptr _M_ptr; + }; + + template<> + inline void + _Sp_counted_ptr::_M_dispose() noexcept { } + + template<> + inline void + _Sp_counted_ptr::_M_dispose() noexcept { } + + template<> + inline void + _Sp_counted_ptr::_M_dispose() noexcept { } + + + + + + + template + struct _Sp_ebo_helper; + + + template + struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp + { + explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { } + explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { } + + static _Tp& + _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); } + }; + + + template + struct _Sp_ebo_helper<_Nm, _Tp, false> + { + explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { } + explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { } + + static _Tp& + _S_get(_Sp_ebo_helper& __eboh) + { return __eboh._M_tp; } + + private: + _Tp _M_tp; + }; + + + template + class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> + { + class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> + { + typedef _Sp_ebo_helper<0, _Deleter> _Del_base; + typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base; + + public: + _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept + : _Del_base(std::move(__d)), _Alloc_base(__a), _M_ptr(__p) + { } + + _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); } + _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); } + + _Ptr _M_ptr; + }; + + public: + using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>; + + + _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept + : _M_impl(__p, std::move(__d), _Alloc()) { } + + + _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept + : _M_impl(__p, std::move(__d), __a) { } + + ~_Sp_counted_deleter() noexcept { } + + virtual void + _M_dispose() noexcept + { _M_impl._M_del()(_M_impl._M_ptr); } + + virtual void + _M_destroy() noexcept + { + __allocator_type __a(_M_impl._M_alloc()); + __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; + this->~_Sp_counted_deleter(); + } + + virtual void* + _M_get_deleter(const type_info& __ti [[__gnu__::__unused__]]) noexcept + { + + + + return __ti == typeid(_Deleter) + ? std::__addressof(_M_impl._M_del()) + : nullptr; + + + + } + + private: + _Impl _M_impl; + }; + + + + struct _Sp_make_shared_tag + { + private: + template + friend class _Sp_counted_ptr_inplace; + + static const type_info& + _S_ti() noexcept __attribute__ ((__visibility__ ("default"))) + { + alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { }; + return reinterpret_cast(__tag); + } + + static bool _S_eq(const type_info&) noexcept; + }; + + template + struct _Sp_alloc_shared_tag + { + const _Alloc& _M_a; + }; + + template + class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> + { + class _Impl : _Sp_ebo_helper<0, _Alloc> + { + typedef _Sp_ebo_helper<0, _Alloc> _A_base; + + public: + explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { } + + _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); } + + __gnu_cxx::__aligned_buffer<_Tp> _M_storage; + }; + + public: + using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>; + + + template + _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args) + : _M_impl(__a) + { + + + allocator_traits<_Alloc>::construct(__a, _M_ptr(), + std::forward<_Args>(__args)...); + } + + ~_Sp_counted_ptr_inplace() noexcept { } + + virtual void + _M_dispose() noexcept + { + allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr()); + } + + + virtual void + _M_destroy() noexcept + { + __allocator_type __a(_M_impl._M_alloc()); + __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; + this->~_Sp_counted_ptr_inplace(); + } + + private: + friend class __shared_count<_Lp>; + + + + virtual void* + _M_get_deleter(const std::type_info& __ti) noexcept override + { + auto __ptr = const_cast::type*>(_M_ptr()); + + + + + if (&__ti == &_Sp_make_shared_tag::_S_ti() + || + + __ti == typeid(_Sp_make_shared_tag) + + + + ) + return __ptr; + return nullptr; + } + + _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } + + _Impl _M_impl; + }; +# 886 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + struct __sp_array_delete + { + template + void operator()(_Yp* __p) const { delete[] __p; } + }; + + template<_Lock_policy _Lp> + class __shared_count + { + + template + struct __not_alloc_shared_tag { using type = void; }; + + template + struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { }; + + + + + + + public: + constexpr __shared_count() noexcept : _M_pi(0) + { } + + template + explicit + __shared_count(_Ptr __p) : _M_pi(0) + { + try + { + _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); + } + catch(...) + { + delete __p; + throw; + } + } + + template + __shared_count(_Ptr __p, false_type) + : __shared_count(__p) + { } + + template + __shared_count(_Ptr __p, true_type) + : __shared_count(__p, __sp_array_delete{}, allocator()) + { } + + template::type> + __shared_count(_Ptr __p, _Deleter __d) + : __shared_count(__p, std::move(__d), allocator()) + { } + + template::type> + __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0) + { + typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; + try + { + typename _Sp_cd_type::__allocator_type __a2(__a); + auto __guard = std::__allocate_guarded(__a2); + _Sp_cd_type* __mem = __guard.get(); + ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a)); + _M_pi = __mem; + __guard = nullptr; + } + catch(...) + { + __d(__p); + throw; + } + } + + template + __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a, + _Args&&... __args) + { + typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type; + typename _Sp_cp_type::__allocator_type __a2(__a._M_a); + auto __guard = std::__allocate_guarded(__a2); + _Sp_cp_type* __mem = __guard.get(); + auto __pi = ::new (__mem) + _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...); + __guard = nullptr; + _M_pi = __pi; + __p = __pi->_M_ptr(); + } +# 1024 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template + explicit + __shared_count(std::auto_ptr<_Tp>&& __r); +#pragma GCC diagnostic pop + + + + template + explicit + __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0) + { + + + if (__r.get() == nullptr) + return; + + using _Ptr = typename unique_ptr<_Tp, _Del>::pointer; + using _Del2 = __conditional_t::value, + reference_wrapper::type>, + _Del>; + using _Sp_cd_type + = _Sp_counted_deleter<_Ptr, _Del2, allocator, _Lp>; + using _Alloc = allocator<_Sp_cd_type>; + using _Alloc_traits = allocator_traits<_Alloc>; + _Alloc __a; + _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1); + + + + _Alloc_traits::construct(__a, __mem, __r.release(), + std::forward<_Del>(__r.get_deleter())); + _M_pi = __mem; + } + + + explicit __shared_count(const __weak_count<_Lp>& __r); + + + explicit + __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept; + + ~__shared_count() noexcept + { + if (_M_pi != nullptr) + _M_pi->_M_release(); + } + + __shared_count(const __shared_count& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi != nullptr) + _M_pi->_M_add_ref_copy(); + } + + __shared_count& + operator=(const __shared_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != _M_pi) + { + if (__tmp != nullptr) + __tmp->_M_add_ref_copy(); + if (_M_pi != nullptr) + _M_pi->_M_release(); + _M_pi = __tmp; + } + return *this; + } + + void + _M_swap(__shared_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + __r._M_pi = _M_pi; + _M_pi = __tmp; + } + + long + _M_get_use_count() const noexcept + { return _M_pi ? _M_pi->_M_get_use_count() : 0; } + + bool + _M_unique() const noexcept + { return this->_M_get_use_count() == 1; } + + void* + _M_get_deleter(const std::type_info& __ti) const noexcept + { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; } + + bool + _M_less(const __shared_count& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + bool + _M_less(const __weak_count<_Lp>& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + + friend inline bool + operator==(const __shared_count& __a, const __shared_count& __b) noexcept + { return __a._M_pi == __b._M_pi; } + + private: + friend class __weak_count<_Lp>; + + + + + _Sp_counted_base<_Lp>* _M_pi; + }; + + + template<_Lock_policy _Lp> + class __weak_count + { + public: + constexpr __weak_count() noexcept : _M_pi(nullptr) + { } + + __weak_count(const __shared_count<_Lp>& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi != nullptr) + _M_pi->_M_weak_add_ref(); + } + + __weak_count(const __weak_count& __r) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi != nullptr) + _M_pi->_M_weak_add_ref(); + } + + __weak_count(__weak_count&& __r) noexcept + : _M_pi(__r._M_pi) + { __r._M_pi = nullptr; } + + ~__weak_count() noexcept + { + if (_M_pi != nullptr) + _M_pi->_M_weak_release(); + } + + __weak_count& + operator=(const __shared_count<_Lp>& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != nullptr) + __tmp->_M_weak_add_ref(); + if (_M_pi != nullptr) + _M_pi->_M_weak_release(); + _M_pi = __tmp; + return *this; + } + + __weak_count& + operator=(const __weak_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + if (__tmp != nullptr) + __tmp->_M_weak_add_ref(); + if (_M_pi != nullptr) + _M_pi->_M_weak_release(); + _M_pi = __tmp; + return *this; + } + + __weak_count& + operator=(__weak_count&& __r) noexcept + { + if (_M_pi != nullptr) + _M_pi->_M_weak_release(); + _M_pi = __r._M_pi; + __r._M_pi = nullptr; + return *this; + } + + void + _M_swap(__weak_count& __r) noexcept + { + _Sp_counted_base<_Lp>* __tmp = __r._M_pi; + __r._M_pi = _M_pi; + _M_pi = __tmp; + } + + long + _M_get_use_count() const noexcept + { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; } + + bool + _M_less(const __weak_count& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + bool + _M_less(const __shared_count<_Lp>& __rhs) const noexcept + { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } + + + friend inline bool + operator==(const __weak_count& __a, const __weak_count& __b) noexcept + { return __a._M_pi == __b._M_pi; } + + private: + friend class __shared_count<_Lp>; + + + + + _Sp_counted_base<_Lp>* _M_pi; + }; + + + template<_Lock_policy _Lp> + inline + __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r) + : _M_pi(__r._M_pi) + { + if (_M_pi == nullptr || !_M_pi->_M_add_ref_lock_nothrow()) + __throw_bad_weak_ptr(); + } + + + template<_Lock_policy _Lp> + inline + __shared_count<_Lp>:: + __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept + : _M_pi(__r._M_pi) + { + if (_M_pi && !_M_pi->_M_add_ref_lock_nothrow()) + _M_pi = nullptr; + } + + + + + + template + struct __sp_compatible_with + : false_type + { }; + + template + struct __sp_compatible_with<_Yp*, _Tp*> + : is_convertible<_Yp*, _Tp*>::type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]> + : true_type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]> + : true_type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]> + : true_type + { }; + + template + struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]> + : true_type + { }; + + + template + struct __sp_is_constructible_arrN + : false_type + { }; + + template + struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> + : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type + { }; + + + template + struct __sp_is_constructible_arr + : false_type + { }; + + template + struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> + : is_convertible<_Yp(*)[], _Up(*)[]>::type + { }; + + + template + struct __sp_is_constructible; + + + template + struct __sp_is_constructible<_Up[_Nm], _Yp> + : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type + { }; + + + template + struct __sp_is_constructible<_Up[], _Yp> + : __sp_is_constructible_arr<_Up, _Yp>::type + { }; + + + template + struct __sp_is_constructible + : is_convertible<_Yp*, _Tp*>::type + { }; + + + + template::value, bool = is_void<_Tp>::value> + class __shared_ptr_access + { + public: + using element_type = _Tp; + + element_type& + operator*() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(_M_get() != nullptr)) __builtin_unreachable(); } while (false); + return *_M_get(); + } + + element_type* + operator->() const noexcept + { + ; + return _M_get(); + } + + private: + element_type* + _M_get() const noexcept + { return static_cast*>(this)->get(); } + }; + + + template + class __shared_ptr_access<_Tp, _Lp, false, true> + { + public: + using element_type = _Tp; + + element_type* + operator->() const noexcept + { + auto __ptr = static_cast*>(this)->get(); + ; + return __ptr; + } + }; + + + template + class __shared_ptr_access<_Tp, _Lp, true, false> + { + public: + using element_type = typename remove_extent<_Tp>::type; +# 1407 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + element_type& + operator[](ptrdiff_t __i) const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(_M_get() != nullptr)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(!extent<_Tp>::value || __i < extent<_Tp>::value)) __builtin_unreachable(); } while (false); + return _M_get()[__i]; + } + + private: + element_type* + _M_get() const noexcept + { return static_cast*>(this)->get(); } + }; + + template + class __shared_ptr + : public __shared_ptr_access<_Tp, _Lp> + { + public: + using element_type = typename remove_extent<_Tp>::type; + + private: + + template + using _SafeConv + = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type; + + + template + using _Compatible = typename + enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; + + + template + using _Assignable = _Compatible<_Yp, __shared_ptr&>; + + + template::pointer> + using _UniqCompatible = __enable_if_t<__and_< + __sp_compatible_with<_Yp*, _Tp*>, + is_convertible<_Ptr, element_type*>, + is_move_constructible<_Del> + >::value, _Res>; + + + template + using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>; + + public: + + + using weak_type = __weak_ptr<_Tp, _Lp>; + + + constexpr __shared_ptr() noexcept + : _M_ptr(0), _M_refcount() + { } + + template> + explicit + __shared_ptr(_Yp* __p) + : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type()) + { + static_assert( !is_void<_Yp>::value, "incomplete type" ); + static_assert( sizeof(_Yp) > 0, "incomplete type" ); + _M_enable_shared_from_this_with(__p); + } + + template> + __shared_ptr(_Yp* __p, _Deleter __d) + : _M_ptr(__p), _M_refcount(__p, std::move(__d)) + { + static_assert(__is_invocable<_Deleter&, _Yp*&>::value, + "deleter expression d(p) is well-formed"); + _M_enable_shared_from_this_with(__p); + } + + template> + __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) + : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a)) + { + static_assert(__is_invocable<_Deleter&, _Yp*&>::value, + "deleter expression d(p) is well-formed"); + _M_enable_shared_from_this_with(__p); + } + + template + __shared_ptr(nullptr_t __p, _Deleter __d) + : _M_ptr(0), _M_refcount(__p, std::move(__d)) + { } + + template + __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) + : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a)) + { } + + + template + __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r, + element_type* __p) noexcept + : _M_ptr(__p), _M_refcount(__r._M_refcount) + { } + + + template + __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r, + element_type* __p) noexcept + : _M_ptr(__p), _M_refcount() + { + _M_refcount._M_swap(__r._M_refcount); + __r._M_ptr = nullptr; + } + + __shared_ptr(const __shared_ptr&) noexcept = default; + __shared_ptr& operator=(const __shared_ptr&) noexcept = default; + ~__shared_ptr() = default; + + template> + __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) + { } + + __shared_ptr(__shared_ptr&& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount() + { + _M_refcount._M_swap(__r._M_refcount); + __r._M_ptr = nullptr; + } + + template> + __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount() + { + _M_refcount._M_swap(__r._M_refcount); + __r._M_ptr = nullptr; + } + + template> + explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r) + : _M_refcount(__r._M_refcount) + { + + + _M_ptr = __r._M_ptr; + } + + + template> + __shared_ptr(unique_ptr<_Yp, _Del>&& __r) + : _M_ptr(__r.get()), _M_refcount() + { + auto __raw = __to_address(__r.get()); + _M_refcount = __shared_count<_Lp>(std::move(__r)); + _M_enable_shared_from_this_with(__raw); + } +# 1585 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template> + __shared_ptr(auto_ptr<_Yp>&& __r); +#pragma GCC diagnostic pop + + + constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } + + template + _Assignable<_Yp> + operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept + { + _M_ptr = __r._M_ptr; + _M_refcount = __r._M_refcount; + return *this; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _Assignable<_Yp> + operator=(auto_ptr<_Yp>&& __r) + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } +#pragma GCC diagnostic pop + + + __shared_ptr& + operator=(__shared_ptr&& __r) noexcept + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + _Assignable<_Yp> + operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + _UniqAssignable<_Yp, _Del> + operator=(unique_ptr<_Yp, _Del>&& __r) + { + __shared_ptr(std::move(__r)).swap(*this); + return *this; + } + + void + reset() noexcept + { __shared_ptr().swap(*this); } + + template + _SafeConv<_Yp> + reset(_Yp* __p) + { + + do { if (std::__is_constant_evaluated() && !bool(__p == nullptr || __p != _M_ptr)) __builtin_unreachable(); } while (false); + __shared_ptr(__p).swap(*this); + } + + template + _SafeConv<_Yp> + reset(_Yp* __p, _Deleter __d) + { __shared_ptr(__p, std::move(__d)).swap(*this); } + + template + _SafeConv<_Yp> + reset(_Yp* __p, _Deleter __d, _Alloc __a) + { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); } + + + element_type* + get() const noexcept + { return _M_ptr; } + + + explicit operator bool() const noexcept + { return _M_ptr != nullptr; } + + + bool + unique() const noexcept + { return _M_refcount._M_unique(); } + + + long + use_count() const noexcept + { return _M_refcount._M_get_use_count(); } + + + void + swap(__shared_ptr<_Tp, _Lp>& __other) noexcept + { + std::swap(_M_ptr, __other._M_ptr); + _M_refcount._M_swap(__other._M_refcount); + } +# 1697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + template + bool + owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept + { return _M_refcount._M_less(__rhs._M_refcount); } + + template + bool + owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept + { return _M_refcount._M_less(__rhs._M_refcount); } + + + protected: + + template + __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) + : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...) + { _M_enable_shared_from_this_with(_M_ptr); } + + template + friend __shared_ptr<_Tp1, _Lp1> + __allocate_shared(const _Alloc& __a, _Args&&... __args); +# 1731 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexcept + : _M_refcount(__r._M_refcount, std::nothrow) + { + _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr; + } + + friend class __weak_ptr<_Tp, _Lp>; + + private: + + template + using __esft_base_t = decltype(__enable_shared_from_this_base( + std::declval&>(), + std::declval<_Yp*>())); + + + template + struct __has_esft_base + : false_type { }; + + template + struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>> + : __not_> { }; + + template::type> + typename enable_if<__has_esft_base<_Yp2>::value>::type + _M_enable_shared_from_this_with(_Yp* __p) noexcept + { + if (auto __base = __enable_shared_from_this_base(_M_refcount, __p)) + __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount); + } + + template::type> + typename enable_if::value>::type + _M_enable_shared_from_this_with(_Yp*) noexcept + { } + + void* + _M_get_deleter(const std::type_info& __ti) const noexcept + { return _M_refcount._M_get_deleter(__ti); } + + template friend class __shared_ptr; + template friend class __weak_ptr; + + template + friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; + + template + friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept; + + + + + + element_type* _M_ptr; + __shared_count<_Lp> _M_refcount; + }; + + + + template + inline bool + operator==(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return __a.get() == __b.get(); } + + template + inline bool + operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !__a; } +# 1817 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + template + inline bool + operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !__a; } + + template + inline bool + operator!=(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return __a.get() != __b.get(); } + + template + inline bool + operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return (bool)__a; } + + template + inline bool + operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return (bool)__a; } + + template + inline bool + operator<(const __shared_ptr<_Tp, _Lp>& __a, + const __shared_ptr<_Up, _Lp>& __b) noexcept + { + using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; + using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type; + using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; + return less<_Vp>()(__a.get(), __b.get()); + } + + template + inline bool + operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { + using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; + return less<_Tp_elt*>()(__a.get(), nullptr); + } + + template + inline bool + operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { + using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; + return less<_Tp_elt*>()(nullptr, __a.get()); + } + + template + inline bool + operator<=(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return !(__b < __a); } + + template + inline bool + operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !(nullptr < __a); } + + template + inline bool + operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !(__a < nullptr); } + + template + inline bool + operator>(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return (__b < __a); } + + template + inline bool + operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return nullptr < __a; } + + template + inline bool + operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return __a < nullptr; } + + template + inline bool + operator>=(const __shared_ptr<_Tp1, _Lp>& __a, + const __shared_ptr<_Tp2, _Lp>& __b) noexcept + { return !(__a < __b); } + + template + inline bool + operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept + { return !(__a < nullptr); } + + template + inline bool + operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept + { return !(nullptr < __a); } + + + + template + inline void + swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept + { __a.swap(__b); } +# 1927 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + template + inline __shared_ptr<_Tp, _Lp> + static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + using _Sp = __shared_ptr<_Tp, _Lp>; + return _Sp(__r, static_cast(__r.get())); + } + + + + + + + template + inline __shared_ptr<_Tp, _Lp> + const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + using _Sp = __shared_ptr<_Tp, _Lp>; + return _Sp(__r, const_cast(__r.get())); + } + + + + + + + template + inline __shared_ptr<_Tp, _Lp> + dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + using _Sp = __shared_ptr<_Tp, _Lp>; + if (auto* __p = dynamic_cast(__r.get())) + return _Sp(__r, __p); + return _Sp(); + } + + + template + inline __shared_ptr<_Tp, _Lp> + reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept + { + using _Sp = __shared_ptr<_Tp, _Lp>; + return _Sp(__r, reinterpret_cast(__r.get())); + } + + + template + class __weak_ptr + { + template + using _Compatible = typename + enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; + + + template + using _Assignable = _Compatible<_Yp, __weak_ptr&>; + + public: + using element_type = typename remove_extent<_Tp>::type; + + constexpr __weak_ptr() noexcept + : _M_ptr(nullptr), _M_refcount() + { } + + __weak_ptr(const __weak_ptr&) noexcept = default; + + ~__weak_ptr() = default; +# 2009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 + template> + __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept + : _M_refcount(__r._M_refcount) + { _M_ptr = __r.lock().get(); } + + template> + __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) + { } + + __weak_ptr(__weak_ptr&& __r) noexcept + : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount)) + { __r._M_ptr = nullptr; } + + template> + __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept + : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount)) + { __r._M_ptr = nullptr; } + + __weak_ptr& + operator=(const __weak_ptr& __r) noexcept = default; + + template + _Assignable<_Yp> + operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept + { + _M_ptr = __r.lock().get(); + _M_refcount = __r._M_refcount; + return *this; + } + + template + _Assignable<_Yp> + operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept + { + _M_ptr = __r._M_ptr; + _M_refcount = __r._M_refcount; + return *this; + } + + __weak_ptr& + operator=(__weak_ptr&& __r) noexcept + { + __weak_ptr(std::move(__r)).swap(*this); + return *this; + } + + template + _Assignable<_Yp> + operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept + { + _M_ptr = __r.lock().get(); + _M_refcount = std::move(__r._M_refcount); + __r._M_ptr = nullptr; + return *this; + } + + __shared_ptr<_Tp, _Lp> + lock() const noexcept + { return __shared_ptr(*this, std::nothrow); } + + long + use_count() const noexcept + { return _M_refcount._M_get_use_count(); } + + bool + expired() const noexcept + { return _M_refcount._M_get_use_count() == 0; } + + template + bool + owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept + { return _M_refcount._M_less(__rhs._M_refcount); } + + template + bool + owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept + { return _M_refcount._M_less(__rhs._M_refcount); } + + void + reset() noexcept + { __weak_ptr().swap(*this); } + + void + swap(__weak_ptr& __s) noexcept + { + std::swap(_M_ptr, __s._M_ptr); + _M_refcount._M_swap(__s._M_refcount); + } + + private: + + void + _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept + { + if (use_count() == 0) + { + _M_ptr = __ptr; + _M_refcount = __refcount; + } + } + + template friend class __shared_ptr; + template friend class __weak_ptr; + friend class __enable_shared_from_this<_Tp, _Lp>; + friend class enable_shared_from_this<_Tp>; + + + + + element_type* _M_ptr; + __weak_count<_Lp> _M_refcount; + }; + + + template + inline void + swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept + { __a.swap(__b); } + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> + { + bool + operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept + { return __lhs.owner_before(__rhs); } + + bool + operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept + { return __lhs.owner_before(__rhs); } + + bool + operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept + { return __lhs.owner_before(__rhs); } + }; +#pragma GCC diagnostic pop + + template<> + struct _Sp_owner_less + { + template + auto + operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept + -> decltype(__lhs.owner_before(__rhs)) + { return __lhs.owner_before(__rhs); } + + using is_transparent = void; + }; + + template + struct owner_less<__shared_ptr<_Tp, _Lp>> + : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>> + { }; + + template + struct owner_less<__weak_ptr<_Tp, _Lp>> + : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>> + { }; + + + template + class __enable_shared_from_this + { + protected: + constexpr __enable_shared_from_this() noexcept { } + + __enable_shared_from_this(const __enable_shared_from_this&) noexcept { } + + __enable_shared_from_this& + operator=(const __enable_shared_from_this&) noexcept + { return *this; } + + ~__enable_shared_from_this() { } + + public: + __shared_ptr<_Tp, _Lp> + shared_from_this() + { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } + + __shared_ptr + shared_from_this() const + { return __shared_ptr(this->_M_weak_this); } + + + __weak_ptr<_Tp, _Lp> + weak_from_this() noexcept + { return this->_M_weak_this; } + + __weak_ptr + weak_from_this() const noexcept + { return this->_M_weak_this; } + + + private: + template + void + _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept + { _M_weak_this._M_assign(__p, __n); } + + friend const __enable_shared_from_this* + __enable_shared_from_this_base(const __shared_count<_Lp>&, + const __enable_shared_from_this* __p) + { return __p; } + + template + friend class __shared_ptr; + + mutable __weak_ptr<_Tp, _Lp> _M_weak_this; + }; + + template + inline __shared_ptr<_Tp, _Lp> + __allocate_shared(const _Alloc& __a, _Args&&... __args) + { + static_assert(!is_array<_Tp>::value, "make_shared not supported"); + + return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a}, + std::forward<_Args>(__args)...); + } + + template + inline __shared_ptr<_Tp, _Lp> + __make_shared(_Args&&... __args) + { + typedef typename std::remove_const<_Tp>::type _Tp_nc; + return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(), + std::forward<_Args>(__args)...); + } + + + template + struct hash<__shared_ptr<_Tp, _Lp>> + : public __hash_base> + { + size_t + operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept + { + return hash::element_type*>()( + __s.get()); + } + }; + + +} +# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + inline std::basic_ostream<_Ch, _Tr>& + operator<<(std::basic_ostream<_Ch, _Tr>& __os, + const __shared_ptr<_Tp, _Lp>& __p) + { + __os << __p.get(); + return __os; + } + + template + inline _Del* + get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept + { + + return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); + + + + } + + + + + + template + inline _Del* + get_deleter(const shared_ptr<_Tp>& __p) noexcept + { + + return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); + + + + } +# 111 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + using _NonArray = __enable_if_t::value, _Tp>; +# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + class shared_ptr : public __shared_ptr<_Tp> + { + template + using _Constructible = typename enable_if< + is_constructible<__shared_ptr<_Tp>, _Args...>::value + >::type; + + template + using _Assignable = typename enable_if< + is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr& + >::type; + + public: + + + using element_type = typename __shared_ptr<_Tp>::element_type; + + + + + + using weak_type = weak_ptr<_Tp>; + + + + + + constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } + + shared_ptr(const shared_ptr&) noexcept = default; + + + + + + + + template> + explicit + shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { } +# 229 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template> + shared_ptr(_Yp* __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, std::move(__d)) { } +# 247 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + shared_ptr(nullptr_t __p, _Deleter __d) + : __shared_ptr<_Tp>(__p, std::move(__d)) { } +# 266 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template> + shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) + : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } +# 286 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) + : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } +# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept + : __shared_ptr<_Tp>(__r, __p) { } +# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template&>> + shared_ptr(const shared_ptr<_Yp>& __r) noexcept + : __shared_ptr<_Tp>(__r) { } + + + + + + + shared_ptr(shared_ptr&& __r) noexcept + : __shared_ptr<_Tp>(std::move(__r)) { } + + + + + + + template>> + shared_ptr(shared_ptr<_Yp>&& __r) noexcept + : __shared_ptr<_Tp>(std::move(__r)) { } +# 379 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template&>> + explicit shared_ptr(const weak_ptr<_Yp>& __r) + : __shared_ptr<_Tp>(__r) { } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template>> + shared_ptr(auto_ptr<_Yp>&& __r); +#pragma GCC diagnostic pop + + + + + template>> + shared_ptr(unique_ptr<_Yp, _Del>&& __r) + : __shared_ptr<_Tp>(std::move(__r)) { } +# 412 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } + + shared_ptr& operator=(const shared_ptr&) noexcept = default; + + template + _Assignable&> + operator=(const shared_ptr<_Yp>& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=(__r); + return *this; + } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + template + _Assignable> + operator=(auto_ptr<_Yp>&& __r) + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } +#pragma GCC diagnostic pop + + + shared_ptr& + operator=(shared_ptr&& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + template + _Assignable> + operator=(shared_ptr<_Yp>&& __r) noexcept + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + template + _Assignable> + operator=(unique_ptr<_Yp, _Del>&& __r) + { + this->__shared_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + private: + + template + shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) + : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...) + { } + + template + friend shared_ptr<_NonArray<_Yp>> + allocate_shared(const _Alloc&, _Args&&...); + + template + friend shared_ptr<_NonArray<_Yp>> + make_shared(_Args&&...); +# 535 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) noexcept + : __shared_ptr<_Tp>(__r, std::nothrow) { } + + friend class weak_ptr<_Tp>; + }; + + + template + shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; + template + shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>; + + + + + + + + template + [[__nodiscard__]] inline bool + operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return __a.get() == __b.get(); } + + + template + [[__nodiscard__]] inline bool + operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !__a; } +# 580 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + [[__nodiscard__]] inline bool + operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !__a; } + + + template + [[__nodiscard__]] inline bool + operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return __a.get() != __b.get(); } + + + template + [[__nodiscard__]] inline bool + operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return (bool)__a; } + + + template + [[__nodiscard__]] inline bool + operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return (bool)__a; } + + + template + [[__nodiscard__]] inline bool + operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { + using _Tp_elt = typename shared_ptr<_Tp>::element_type; + using _Up_elt = typename shared_ptr<_Up>::element_type; + using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; + return less<_Vp>()(__a.get(), __b.get()); + } + + + template + [[__nodiscard__]] inline bool + operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { + using _Tp_elt = typename shared_ptr<_Tp>::element_type; + return less<_Tp_elt*>()(__a.get(), nullptr); + } + + + template + [[__nodiscard__]] inline bool + operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { + using _Tp_elt = typename shared_ptr<_Tp>::element_type; + return less<_Tp_elt*>()(nullptr, __a.get()); + } + + + template + [[__nodiscard__]] inline bool + operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return !(__b < __a); } + + + template + [[__nodiscard__]] inline bool + operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !(nullptr < __a); } + + + template + [[__nodiscard__]] inline bool + operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !(__a < nullptr); } + + + template + [[__nodiscard__]] inline bool + operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return (__b < __a); } + + + template + [[__nodiscard__]] inline bool + operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return nullptr < __a; } + + + template + [[__nodiscard__]] inline bool + operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return __a < nullptr; } + + + template + [[__nodiscard__]] inline bool + operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept + { return !(__a < __b); } + + + template + [[__nodiscard__]] inline bool + operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept + { return !(__a < nullptr); } + + + template + [[__nodiscard__]] inline bool + operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept + { return !(nullptr < __a); } + + + + + + template + inline void + swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept + { __a.swap(__b); } + + + + + template + inline shared_ptr<_Tp> + static_pointer_cast(const shared_ptr<_Up>& __r) noexcept + { + using _Sp = shared_ptr<_Tp>; + return _Sp(__r, static_cast(__r.get())); + } + + + template + inline shared_ptr<_Tp> + const_pointer_cast(const shared_ptr<_Up>& __r) noexcept + { + using _Sp = shared_ptr<_Tp>; + return _Sp(__r, const_cast(__r.get())); + } + + + template + inline shared_ptr<_Tp> + dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept + { + using _Sp = shared_ptr<_Tp>; + if (auto* __p = dynamic_cast(__r.get())) + return _Sp(__r, __p); + return _Sp(); + } + + + + + template + inline shared_ptr<_Tp> + reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept + { + using _Sp = shared_ptr<_Tp>; + return _Sp(__r, reinterpret_cast(__r.get())); + } +# 810 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + class weak_ptr : public __weak_ptr<_Tp> + { + template + using _Constructible = typename enable_if< + is_constructible<__weak_ptr<_Tp>, _Arg>::value + >::type; + + template + using _Assignable = typename enable_if< + is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr& + >::type; + + public: + constexpr weak_ptr() noexcept = default; + + template&>> + weak_ptr(const shared_ptr<_Yp>& __r) noexcept + : __weak_ptr<_Tp>(__r) { } + + weak_ptr(const weak_ptr&) noexcept = default; + + template&>> + weak_ptr(const weak_ptr<_Yp>& __r) noexcept + : __weak_ptr<_Tp>(__r) { } + + weak_ptr(weak_ptr&&) noexcept = default; + + template>> + weak_ptr(weak_ptr<_Yp>&& __r) noexcept + : __weak_ptr<_Tp>(std::move(__r)) { } + + weak_ptr& + operator=(const weak_ptr& __r) noexcept = default; + + template + _Assignable&> + operator=(const weak_ptr<_Yp>& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=(__r); + return *this; + } + + template + _Assignable&> + operator=(const shared_ptr<_Yp>& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=(__r); + return *this; + } + + weak_ptr& + operator=(weak_ptr&& __r) noexcept = default; + + template + _Assignable> + operator=(weak_ptr<_Yp>&& __r) noexcept + { + this->__weak_ptr<_Tp>::operator=(std::move(__r)); + return *this; + } + + shared_ptr<_Tp> + lock() const noexcept + { return shared_ptr<_Tp>(*this, std::nothrow); } + }; + + + template + weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; + + + + + + template + inline void + swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept + { __a.swap(__b); } + + + + template + struct owner_less; + + + template<> + struct owner_less : _Sp_owner_less + { }; + + + template + struct owner_less> + : public _Sp_owner_less, weak_ptr<_Tp>> + { }; + + + template + struct owner_less> + : public _Sp_owner_less, shared_ptr<_Tp>> + { }; + + + + + + + template + class enable_shared_from_this + { + protected: + constexpr enable_shared_from_this() noexcept { } + + enable_shared_from_this(const enable_shared_from_this&) noexcept { } + + enable_shared_from_this& + operator=(const enable_shared_from_this&) noexcept + { return *this; } + + ~enable_shared_from_this() { } + + public: + shared_ptr<_Tp> + shared_from_this() + { return shared_ptr<_Tp>(this->_M_weak_this); } + + shared_ptr + shared_from_this() const + { return shared_ptr(this->_M_weak_this); } + + + + + + + + weak_ptr<_Tp> + weak_from_this() noexcept + { return this->_M_weak_this; } + + weak_ptr + weak_from_this() const noexcept + { return this->_M_weak_this; } + + + + private: + template + void + _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept + { _M_weak_this._M_assign(__p, __n); } + + + friend const enable_shared_from_this* + __enable_shared_from_this_base(const __shared_count<>&, + const enable_shared_from_this* __p) + { return __p; } + + template + friend class __shared_ptr; + + mutable weak_ptr<_Tp> _M_weak_this; + }; +# 988 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + inline shared_ptr<_NonArray<_Tp>> + allocate_shared(const _Alloc& __a, _Args&&... __args) + { + return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, + std::forward<_Args>(__args)...); + } +# 1003 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + inline shared_ptr<_NonArray<_Tp>> + make_shared(_Args&&... __args) + { + using _Alloc = allocator; + _Alloc __a; + return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, + std::forward<_Args>(__args)...); + } +# 1152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 + template + struct hash> + : public __hash_base> + { + size_t + operator()(const shared_ptr<_Tp>& __s) const noexcept + { + return std::hash::element_type*>()(__s.get()); + } + }; + + + + + + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + } + + + +} +# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_lockfree_defines.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_lockfree_defines.h" 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 2 3 +# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + typedef enum memory_order + { + memory_order_relaxed, + memory_order_consume, + memory_order_acquire, + memory_order_release, + memory_order_acq_rel, + memory_order_seq_cst + } memory_order; + + + + enum __memory_order_modifier + { + __memory_order_mask = 0x0ffff, + __memory_order_modifier_mask = 0xffff0000, + __memory_order_hle_acquire = 0x10000, + __memory_order_hle_release = 0x20000 + }; + + + constexpr memory_order + operator|(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(int(__m) | int(__mod)); + } + + constexpr memory_order + operator&(memory_order __m, __memory_order_modifier __mod) + { + return memory_order(int(__m) & int(__mod)); + } + + + + + constexpr memory_order + __cmpexch_failure_order2(memory_order __m) noexcept + { + return __m == memory_order_acq_rel ? memory_order_acquire + : __m == memory_order_release ? memory_order_relaxed : __m; + } + + constexpr memory_order + __cmpexch_failure_order(memory_order __m) noexcept + { + return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask) + | __memory_order_modifier(__m & __memory_order_modifier_mask)); + } + + constexpr bool + __is_valid_cmpexch_failure_order(memory_order __m) noexcept + { + return (__m & __memory_order_mask) != memory_order_release + && (__m & __memory_order_mask) != memory_order_acq_rel; + } + + + template + struct __atomic_base; + + + + inline __attribute__((__always_inline__)) void + atomic_thread_fence(memory_order __m) noexcept + { __atomic_thread_fence(int(__m)); } + + inline __attribute__((__always_inline__)) void + atomic_signal_fence(memory_order __m) noexcept + { __atomic_signal_fence(int(__m)); } + + + template + inline _Tp + kill_dependency(_Tp __y) noexcept + { + _Tp __ret(__y); + return __ret; + } +# 173 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + template + struct atomic; + + template + struct atomic<_Tp*>; + + + + typedef bool __atomic_flag_data_type; +# 198 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + extern "C" { + + struct __atomic_flag_base + { + __atomic_flag_data_type _M_i ; + }; + + } + + + + + + + struct atomic_flag : public __atomic_flag_base + { + atomic_flag() noexcept = default; + ~atomic_flag() noexcept = default; + atomic_flag(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) = delete; + atomic_flag& operator=(const atomic_flag&) volatile = delete; + + + constexpr atomic_flag(bool __i) noexcept + : __atomic_flag_base{ _S_init(__i) } + { } + + inline __attribute__((__always_inline__)) bool + test_and_set(memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_test_and_set (&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) bool + test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_test_and_set (&_M_i, int(__m)); + } +# 284 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + inline __attribute__((__always_inline__)) void + clear(memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + __atomic_clear (&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) void + clear(memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + __atomic_clear (&_M_i, int(__m)); + } + + private: + static constexpr __atomic_flag_data_type + _S_init(bool __i) + { return __i ? 1 : 0; } + }; +# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + template + struct __atomic_base + { + using value_type = _ITp; + using difference_type = value_type; + + private: + typedef _ITp __int_type; + + static constexpr int _S_alignment = + sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); + + alignas(_S_alignment) __int_type _M_i ; + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + + constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } + + operator __int_type() const noexcept + { return load(); } + + operator __int_type() const volatile noexcept + { return load(); } + + __int_type + operator=(__int_type __i) noexcept + { + store(__i); + return __i; + } + + __int_type + operator=(__int_type __i) volatile noexcept + { + store(__i); + return __i; + } + + __int_type + operator++(int) noexcept + { return fetch_add(1); } + + __int_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __int_type + operator--(int) noexcept + { return fetch_sub(1); } + + __int_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __int_type + operator++() noexcept + { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + + __int_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + + __int_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + + __int_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } + + __int_type + operator+=(__int_type __i) noexcept + { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator+=(__int_type __i) volatile noexcept + { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator-=(__int_type __i) noexcept + { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator-=(__int_type __i) volatile noexcept + { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator&=(__int_type __i) noexcept + { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator&=(__int_type __i) volatile noexcept + { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator|=(__int_type __i) noexcept + { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator|=(__int_type __i) volatile noexcept + { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator^=(__int_type __i) noexcept + { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + __int_type + operator^=(__int_type __i) volatile noexcept + { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } + + bool + is_lock_free() const noexcept + { + + return __atomic_is_lock_free(sizeof(_M_i), + reinterpret_cast(-_S_alignment)); + } + + bool + is_lock_free() const volatile noexcept + { + + return __atomic_is_lock_free(sizeof(_M_i), + reinterpret_cast(-_S_alignment)); + } + + inline __attribute__((__always_inline__)) void + store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_i, __i, int(__m)); + } + + inline __attribute__((__always_inline__)) void + store(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_i, __i, int(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_i, int(__m)); + } + + inline __attribute__((__always_inline__)) __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_i, __i, int(__m)); + } + + + inline __attribute__((__always_inline__)) __int_type + exchange(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_i, __i, int(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_weak(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, memory_order __m2) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__int_type& __i1, __int_type __i2, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return compare_exchange_strong(__i1, __i2, __m, + __cmpexch_failure_order(__m)); + } +# 632 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + inline __attribute__((__always_inline__)) __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_add(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_sub(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_and(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_and(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_and(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_or(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_or(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_or(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } + + inline __attribute__((__always_inline__)) __int_type + fetch_xor(__int_type __i, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } + }; + + + + template + struct __atomic_base<_PTp*> + { + private: + typedef _PTp* __pointer_type; + + __pointer_type _M_p ; + + + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } + + constexpr ptrdiff_t + _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); } + + public: + __atomic_base() noexcept = default; + ~__atomic_base() noexcept = default; + __atomic_base(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) = delete; + __atomic_base& operator=(const __atomic_base&) volatile = delete; + + + constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } + + operator __pointer_type() const noexcept + { return load(); } + + operator __pointer_type() const volatile noexcept + { return load(); } + + __pointer_type + operator=(__pointer_type __p) noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator=(__pointer_type __p) volatile noexcept + { + store(__p); + return __p; + } + + __pointer_type + operator++(int) noexcept + { return fetch_add(1); } + + __pointer_type + operator++(int) volatile noexcept + { return fetch_add(1); } + + __pointer_type + operator--(int) noexcept + { return fetch_sub(1); } + + __pointer_type + operator--(int) volatile noexcept + { return fetch_sub(1); } + + __pointer_type + operator++() noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator++() volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator--() noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator--() volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(1), + int(memory_order_seq_cst)); } + + __pointer_type + operator+=(ptrdiff_t __d) noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + __pointer_type + operator+=(ptrdiff_t __d) volatile noexcept + { return __atomic_add_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + __pointer_type + operator-=(ptrdiff_t __d) noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + __pointer_type + operator-=(ptrdiff_t __d) volatile noexcept + { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), + int(memory_order_seq_cst)); } + + bool + is_lock_free() const noexcept + { + + return __atomic_is_lock_free(sizeof(_M_p), + reinterpret_cast(-__alignof(_M_p))); + } + + bool + is_lock_free() const volatile noexcept + { + + return __atomic_is_lock_free(sizeof(_M_p), + reinterpret_cast(-__alignof(_M_p))); + } + + inline __attribute__((__always_inline__)) void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_p, __p, int(__m)); + } + + inline __attribute__((__always_inline__)) void + store(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); + + __atomic_store_n(&_M_p, __p, int(__m)); + } + + inline __attribute__((__always_inline__)) __pointer_type + load(memory_order __m = memory_order_seq_cst) const noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_p, int(__m)); + } + + inline __attribute__((__always_inline__)) __pointer_type + load(memory_order __m = memory_order_seq_cst) const volatile noexcept + { + memory_order __b __attribute__ ((__unused__)) + = __m & __memory_order_mask; + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); + do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); + + return __atomic_load_n(&_M_p, int(__m)); + } + + inline __attribute__((__always_inline__)) __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) noexcept + { + return __atomic_exchange_n(&_M_p, __p, int(__m)); + } + + + inline __attribute__((__always_inline__)) __pointer_type + exchange(__pointer_type __p, + memory_order __m = memory_order_seq_cst) volatile noexcept + { + return __atomic_exchange_n(&_M_p, __p, int(__m)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, + int(__m1), int(__m2)); + } + + inline __attribute__((__always_inline__)) bool + compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, + memory_order __m1, + memory_order __m2) volatile noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); + + return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, + int(__m1), int(__m2)); + } +# 935 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 + inline __attribute__((__always_inline__)) __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_add(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) noexcept + { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } + + inline __attribute__((__always_inline__)) __pointer_type + fetch_sub(ptrdiff_t __d, + memory_order __m = memory_order_seq_cst) volatile noexcept + { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } + }; + + namespace __atomic_impl + { + + + template + constexpr bool + __maybe_has_padding() + { + + return false; + + + + + + + } + + template + inline __attribute__((__always_inline__)) _Tp* + __clear_padding(_Tp& __val) noexcept + { + auto* __ptr = std::__addressof(__val); + + + + + return __ptr; + } + + + template + using _Val = typename remove_volatile<_Tp>::type; + + template + inline __attribute__((__always_inline__)) bool + __compare_exchange(_Tp& __val, _Val<_Tp>& __e, _Val<_Tp>& __i, + bool __is_weak, + memory_order __s, memory_order __f) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__f))) __builtin_unreachable(); } while (false); + + using _Vp = _Val<_Tp>; + + if constexpr (__atomic_impl::__maybe_has_padding<_Vp>()) + { + + + alignas(_Vp) unsigned char __buf[sizeof(_Vp)]; + _Vp* __exp = ::new((void*)__buf) _Vp(__e); + __atomic_impl::__clear_padding(*__exp); + if (__atomic_compare_exchange(std::__addressof(__val), __exp, + __atomic_impl::__clear_padding(__i), + __is_weak, int(__s), int(__f))) + return true; + __builtin_memcpy(std::__addressof(__e), __exp, sizeof(_Vp)); + return false; + } + else + return __atomic_compare_exchange(std::__addressof(__val), + std::__addressof(__e), + std::__addressof(__i), + __is_weak, int(__s), int(__f)); + } + } +# 2021 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 +} +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 2 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + struct _Sp_locker + { + _Sp_locker(const _Sp_locker&) = delete; + _Sp_locker& operator=(const _Sp_locker&) = delete; + + + explicit + _Sp_locker(const void*) noexcept; + _Sp_locker(const void*, const void*) noexcept; + ~_Sp_locker(); + + private: + unsigned char _M_key1; + unsigned char _M_key2; + + + + }; +# 100 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + inline bool + atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p) + { + + return __gthread_active_p() == 0; + + + + } + + template + inline bool + atomic_is_lock_free(const shared_ptr<_Tp>* __p) + { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); } +# 127 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + inline shared_ptr<_Tp> + atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) + { + _Sp_locker __lock{__p}; + return *__p; + } + + template + inline shared_ptr<_Tp> + atomic_load(const shared_ptr<_Tp>* __p) + { return std::atomic_load_explicit(__p, memory_order_seq_cst); } + + template + inline __shared_ptr<_Tp, _Lp> + atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order) + { + _Sp_locker __lock{__p}; + return *__p; + } + + template + inline __shared_ptr<_Tp, _Lp> + atomic_load(const __shared_ptr<_Tp, _Lp>* __p) + { return std::atomic_load_explicit(__p, memory_order_seq_cst); } +# 163 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + inline void + atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, + memory_order) + { + _Sp_locker __lock{__p}; + __p->swap(__r); + } + + template + inline void + atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) + { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } + + template + inline void + atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp> __r, + memory_order) + { + _Sp_locker __lock{__p}; + __p->swap(__r); + } + + template + inline void + atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) + { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } +# 200 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + inline shared_ptr<_Tp> + atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, + memory_order) + { + _Sp_locker __lock{__p}; + __p->swap(__r); + return __r; + } + + template + inline shared_ptr<_Tp> + atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) + { + return std::atomic_exchange_explicit(__p, std::move(__r), + memory_order_seq_cst); + } + + template + inline __shared_ptr<_Tp, _Lp> + atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp> __r, + memory_order) + { + _Sp_locker __lock{__p}; + __p->swap(__r); + return __r; + } + + template + inline __shared_ptr<_Tp, _Lp> + atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) + { + return std::atomic_exchange_explicit(__p, std::move(__r), + memory_order_seq_cst); + } +# 249 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 + template + bool + atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, + shared_ptr<_Tp>* __v, + shared_ptr<_Tp> __w, + memory_order, + memory_order) + { + shared_ptr<_Tp> __x; + _Sp_locker __lock{__p, __v}; + owner_less> __less; + if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) + { + __x = std::move(*__p); + *__p = std::move(__w); + return true; + } + __x = std::move(*__v); + *__v = *__p; + return false; + } + + template + inline bool + atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, + shared_ptr<_Tp> __w) + { + return std::atomic_compare_exchange_strong_explicit(__p, __v, + std::move(__w), memory_order_seq_cst, memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, + shared_ptr<_Tp>* __v, + shared_ptr<_Tp> __w, + memory_order __success, + memory_order __failure) + { + return std::atomic_compare_exchange_strong_explicit(__p, __v, + std::move(__w), __success, __failure); + } + + template + inline bool + atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, + shared_ptr<_Tp> __w) + { + return std::atomic_compare_exchange_weak_explicit(__p, __v, + std::move(__w), memory_order_seq_cst, memory_order_seq_cst); + } + + template + bool + atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp>* __v, + __shared_ptr<_Tp, _Lp> __w, + memory_order, + memory_order) + { + __shared_ptr<_Tp, _Lp> __x; + _Sp_locker __lock{__p, __v}; + owner_less<__shared_ptr<_Tp, _Lp>> __less; + if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) + { + __x = std::move(*__p); + *__p = std::move(__w); + return true; + } + __x = std::move(*__v); + *__v = *__p; + return false; + } + + template + inline bool + atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp>* __v, + __shared_ptr<_Tp, _Lp> __w) + { + return std::atomic_compare_exchange_strong_explicit(__p, __v, + std::move(__w), memory_order_seq_cst, memory_order_seq_cst); + } + + template + inline bool + atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp>* __v, + __shared_ptr<_Tp, _Lp> __w, + memory_order __success, + memory_order __failure) + { + return std::atomic_compare_exchange_strong_explicit(__p, __v, + std::move(__w), __success, __failure); + } + + template + inline bool + atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p, + __shared_ptr<_Tp, _Lp>* __v, + __shared_ptr<_Tp, _Lp> __w) + { + return std::atomic_compare_exchange_weak_explicit(__p, __v, + std::move(__w), memory_order_seq_cst, memory_order_seq_cst); + } +# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 +} +# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + template + struct auto_ptr_ref + { + _Tp1* _M_ptr; + + explicit + auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } + } __attribute__ ((__deprecated__)); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 92 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + template + class auto_ptr + { + private: + _Tp* _M_ptr; + + public: + + typedef _Tp element_type; + + + + + + + + explicit + auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } +# 118 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } +# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + template + auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } +# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + auto_ptr& + operator=(auto_ptr& __a) throw() + { + reset(__a.release()); + return *this; + } +# 158 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + template + auto_ptr& + operator=(auto_ptr<_Tp1>& __a) throw() + { + reset(__a.release()); + return *this; + } +# 176 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + ~auto_ptr() { delete _M_ptr; } +# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + element_type& + operator*() const throw() + { + do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) __builtin_unreachable(); } while (false); + return *_M_ptr; + } + + + + + + + + element_type* + operator->() const throw() + { + do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) __builtin_unreachable(); } while (false); + return _M_ptr; + } +# 216 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + element_type* + get() const throw() { return _M_ptr; } +# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + element_type* + release() throw() + { + element_type* __tmp = _M_ptr; + _M_ptr = 0; + return __tmp; + } +# 245 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + void + reset(element_type* __p = 0) throw() + { + if (__p != _M_ptr) + { + delete _M_ptr; + _M_ptr = __p; + } + } +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 + auto_ptr(auto_ptr_ref __ref) throw() + : _M_ptr(__ref._M_ptr) { } + + auto_ptr& + operator=(auto_ptr_ref __ref) throw() + { + if (__ref._M_ptr != this->get()) + { + delete _M_ptr; + _M_ptr = __ref._M_ptr; + } + return *this; + } + + template + operator auto_ptr_ref<_Tp1>() throw() + { return auto_ptr_ref<_Tp1>(this->release()); } + + template + operator auto_ptr<_Tp1>() throw() + { return auto_ptr<_Tp1>(this->release()); } + } __attribute__ ((__deprecated__ ("use '" "std::unique_ptr" "' instead"))); + + + + template<> + class auto_ptr + { + public: + typedef void element_type; + } __attribute__ ((__deprecated__)); + + + + template<_Lock_policy _Lp> + template + inline + __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r) + : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get())) + { __r.release(); } + + template + template + inline + __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r) + : _M_ptr(__r.get()), _M_refcount() + { + + static_assert( sizeof(_Tp1) > 0, "incomplete type" ); + _Tp1* __tmp = __r.get(); + _M_refcount = __shared_count<_Lp>(std::move(__r)); + _M_enable_shared_from_this_with(__tmp); + } + + template + template + inline + shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r) + : __shared_ptr<_Tp>(std::move(__r)) { } + + + template + template + inline + unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept + : _M_t(__u.release(), deleter_type()) { } + + +#pragma GCC diagnostic pop + + +} +# 87 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 +# 101 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 +enum class pointer_safety { relaxed, preferred, strict }; + + +inline void +declare_reachable(void*) { } + + +template + inline _Tp* + undeclare_reachable(_Tp* __p) { return __p; } + + +inline void +declare_no_pointers(char*, size_t) { } + + +inline void +undeclare_no_pointers(char*, size_t) { } + + +inline pointer_safety +get_pointer_safety() noexcept { return pointer_safety::relaxed; } + + + +} +# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/glue_memory_defs.h" 1 3 +# 13 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/glue_memory_defs.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/execution_defs.h" 1 3 +# 15 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/execution_defs.h" 3 +namespace __pstl +{ +namespace execution +{ +inline namespace v1 +{ + + +class sequenced_policy +{ + public: + + static constexpr std::false_type + __allow_unsequenced() + { + return std::false_type{}; + } + static constexpr std::false_type + __allow_vector() + { + return std::false_type{}; + } + static constexpr std::false_type + __allow_parallel() + { + return std::false_type{}; + } +}; + + +class parallel_policy +{ + public: + + static constexpr std::false_type + __allow_unsequenced() + { + return std::false_type{}; + } + static constexpr std::false_type + __allow_vector() + { + return std::false_type{}; + } + static constexpr std::true_type + __allow_parallel() + { + return std::true_type{}; + } +}; + + +class parallel_unsequenced_policy +{ + public: + + static constexpr std::true_type + __allow_unsequenced() + { + return std::true_type{}; + } + static constexpr std::true_type + __allow_vector() + { + return std::true_type{}; + } + static constexpr std::true_type + __allow_parallel() + { + return std::true_type{}; + } +}; + +class unsequenced_policy +{ + public: + + static constexpr std::true_type + __allow_unsequenced() + { + return std::true_type{}; + } + static constexpr std::true_type + __allow_vector() + { + return std::true_type{}; + } + static constexpr std::false_type + __allow_parallel() + { + return std::false_type{}; + } +}; + + +inline constexpr sequenced_policy seq{}; +inline constexpr parallel_policy par{}; +inline constexpr parallel_unsequenced_policy par_unseq{}; +inline constexpr unsequenced_policy unseq{}; + + +template +struct is_execution_policy : std::false_type +{ +}; + +template <> +struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type +{ +}; +template <> +struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type +{ +}; +template <> +struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type +{ +}; +template <> +struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type +{ +}; + + +template +constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value; + + +} +} + +namespace __internal +{ +template + +using __enable_if_execution_policy = + typename std::enable_if<__pstl::execution::is_execution_policy>::value, + _Tp>::type; + + + + + +} + +} +# 14 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/glue_memory_defs.h" 2 3 + +namespace std +{ + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); + + + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> +uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); + +template +__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> +uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); + +} +# 155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 +# 15 "src/platform/inputs.h" 2 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 1 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 3 + + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 1 3 +# 78 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + struct _Vector_base + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Tp>::other _Tp_alloc_type; + typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer + pointer; + + struct _Vector_impl_data + { + pointer _M_start; + pointer _M_finish; + pointer _M_end_of_storage; + + + _Vector_impl_data() noexcept + : _M_start(), _M_finish(), _M_end_of_storage() + { } + + + + _Vector_impl_data(_Vector_impl_data&& __x) noexcept + : _M_start(__x._M_start), _M_finish(__x._M_finish), + _M_end_of_storage(__x._M_end_of_storage) + { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); } + + + + void + _M_copy_data(_Vector_impl_data const& __x) noexcept + { + _M_start = __x._M_start; + _M_finish = __x._M_finish; + _M_end_of_storage = __x._M_end_of_storage; + } + + + void + _M_swap_data(_Vector_impl_data& __x) noexcept + { + + + _Vector_impl_data __tmp; + __tmp._M_copy_data(*this); + _M_copy_data(__x); + __x._M_copy_data(__tmp); + } + }; + + struct _Vector_impl + : public _Tp_alloc_type, public _Vector_impl_data + { + + _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value) + + : _Tp_alloc_type() + { } + + + _Vector_impl(_Tp_alloc_type const& __a) noexcept + : _Tp_alloc_type(__a) + { } + + + + + + _Vector_impl(_Vector_impl&& __x) noexcept + : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x)) + { } + + + _Vector_impl(_Tp_alloc_type&& __a) noexcept + : _Tp_alloc_type(std::move(__a)) + { } + + + _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept + : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv)) + { } +# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + }; + + public: + typedef _Alloc allocator_type; + + + _Tp_alloc_type& + _M_get_Tp_allocator() noexcept + { return this->_M_impl; } + + + const _Tp_alloc_type& + _M_get_Tp_allocator() const noexcept + { return this->_M_impl; } + + + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_get_Tp_allocator()); } + + + _Vector_base() = default; + + + + + + _Vector_base(const allocator_type& __a) noexcept + : _M_impl(__a) { } + + + + + _Vector_base(size_t __n) + : _M_impl() + { _M_create_storage(__n); } + + + + _Vector_base(size_t __n, const allocator_type& __a) + : _M_impl(__a) + { _M_create_storage(__n); } + + + _Vector_base(_Vector_base&&) = default; + + + + + _Vector_base(_Tp_alloc_type&& __a) noexcept + : _M_impl(std::move(__a)) { } + + + _Vector_base(_Vector_base&& __x, const allocator_type& __a) + : _M_impl(__a) + { + if (__x.get_allocator() == __a) + this->_M_impl._M_swap_data(__x._M_impl); + else + { + size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start; + _M_create_storage(__n); + } + } + + + + _Vector_base(const allocator_type& __a, _Vector_base&& __x) + : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl)) + { } + + + + ~_Vector_base() noexcept + { + _M_deallocate(_M_impl._M_start, + _M_impl._M_end_of_storage - _M_impl._M_start); + } + + public: + _Vector_impl _M_impl; + + + pointer + _M_allocate(size_t __n) + { + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; + return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer(); + } + + + void + _M_deallocate(pointer __p, size_t __n) + { + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; + if (__p) + _Tr::deallocate(_M_impl, __p, __n); + } + + protected: + + void + _M_create_storage(size_t __n) + { + this->_M_impl._M_start = this->_M_allocate(__n); + this->_M_impl._M_finish = this->_M_impl._M_start; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + } + }; +# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template > + class vector : protected _Vector_base<_Tp, _Alloc> + { +# 437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + static_assert(is_same::type, _Tp>::value, + "std::vector must have a non-const, non-volatile value_type"); + + static_assert(is_same::value, + "std::vector must have the same value_type as its allocator"); + + + + typedef _Vector_base<_Tp, _Alloc> _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; + + public: + typedef _Tp value_type; + typedef typename _Base::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + typedef __gnu_cxx::__normal_iterator iterator; + typedef __gnu_cxx::__normal_iterator + const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + private: + + static constexpr bool + _S_nothrow_relocate(true_type) + { + return noexcept(std::__relocate_a(std::declval(), + std::declval(), + std::declval(), + std::declval<_Tp_alloc_type&>())); + } + + static constexpr bool + _S_nothrow_relocate(false_type) + { return false; } + + static constexpr bool + _S_use_relocate() + { + + + + return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{}); + } + + static pointer + _S_do_relocate(pointer __first, pointer __last, pointer __result, + _Tp_alloc_type& __alloc, true_type) noexcept + { + return std::__relocate_a(__first, __last, __result, __alloc); + } + + static pointer + _S_do_relocate(pointer, pointer, pointer __result, + _Tp_alloc_type&, false_type) noexcept + { return __result; } + + static pointer + _S_relocate(pointer __first, pointer __last, pointer __result, + _Tp_alloc_type& __alloc) noexcept + { + + + return std::__relocate_a(__first, __last, __result, __alloc); + + + + + } + + + protected: + using _Base::_M_allocate; + using _Base::_M_deallocate; + using _Base::_M_impl; + using _Base::_M_get_Tp_allocator; + + public: + + + + + + + + vector() = default; +# 537 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + explicit + + vector(const allocator_type& __a) noexcept + : _Base(__a) { } +# 551 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + explicit + + vector(size_type __n, const allocator_type& __a = allocator_type()) + : _Base(_S_check_init_len(__n, __a), __a) + { _M_default_initialize(__n); } +# 566 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(_S_check_init_len(__n, __a), __a) + { _M_fill_initialize(__n, __value); } +# 598 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector(const vector& __x) + : _Base(__x.size(), + _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator())) + { + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__x.begin(), __x.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } +# 617 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector(vector&&) noexcept = default; + + + + vector(const vector& __x, const __type_identity_t& __a) + : _Base(__x.size(), __a) + { + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__x.begin(), __x.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } + + private: + + vector(vector&& __rv, const allocator_type& __m, true_type) noexcept + : _Base(__m, std::move(__rv)) + { } + + + vector(vector&& __rv, const allocator_type& __m, false_type) + : _Base(__m) + { + if (__rv.get_allocator() == __m) + this->_M_impl._M_swap_data(__rv._M_impl); + else if (!__rv.empty()) + { + this->_M_create_storage(__rv.size()); + this->_M_impl._M_finish = + std::__uninitialized_move_a(__rv.begin(), __rv.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + __rv.clear(); + } + } + + public: + + + vector(vector&& __rv, const __type_identity_t& __m) + noexcept( noexcept( + vector(std::declval(), std::declval(), + std::declval())) ) + : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{}) + { } +# 675 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_range_initialize(__l.begin(), __l.end(), + random_access_iterator_tag()); + } +# 701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template> + + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_range_initialize(__first, __last, + std::__iterator_category(__first)); + } +# 730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + ~vector() noexcept + { + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + ; + } +# 747 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector& + operator=(const vector& __x); +# 762 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector& + operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) + { + constexpr bool __move_storage = + _Alloc_traits::_S_propagate_on_move_assign() + || _Alloc_traits::_S_always_equal(); + _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); + return *this; + } +# 784 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector& + operator=(initializer_list __l) + { + this->_M_assign_aux(__l.begin(), __l.end(), + random_access_iterator_tag()); + return *this; + } +# 804 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + assign(size_type __n, const value_type& __val) + { _M_fill_assign(__n, __val); } +# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template> + + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } +# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + assign(initializer_list __l) + { + this->_M_assign_aux(__l.begin(), __l.end(), + random_access_iterator_tag()); + } + + + + using _Base::get_allocator; + + + + + + + + [[__nodiscard__]] + iterator + begin() noexcept + { return iterator(this->_M_impl._M_start); } + + + + + + + [[__nodiscard__]] + const_iterator + begin() const noexcept + { return const_iterator(this->_M_impl._M_start); } + + + + + + + [[__nodiscard__]] + iterator + end() noexcept + { return iterator(this->_M_impl._M_finish); } + + + + + + + [[__nodiscard__]] + const_iterator + end() const noexcept + { return const_iterator(this->_M_impl._M_finish); } + + + + + + + [[__nodiscard__]] + reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + + + + + + [[__nodiscard__]] + reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + + + + + + + [[__nodiscard__]] + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_impl._M_start); } + + + + + + + [[__nodiscard__]] + const_iterator + cend() const noexcept + { return const_iterator(this->_M_impl._M_finish); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + + + + [[__nodiscard__]] + size_type + size() const noexcept + { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } + + + [[__nodiscard__]] + size_type + max_size() const noexcept + { return _S_max_size(_M_get_Tp_allocator()); } +# 1009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + resize(size_type __new_size) + { + if (__new_size > size()) + _M_default_append(__new_size - size()); + else if (__new_size < size()) + _M_erase_at_end(this->_M_impl._M_start + __new_size); + } +# 1030 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + resize(size_type __new_size, const value_type& __x) + { + if (__new_size > size()) + _M_fill_insert(end(), __new_size - size(), __x); + else if (__new_size < size()) + _M_erase_at_end(this->_M_impl._M_start + __new_size); + } +# 1064 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + shrink_to_fit() + { _M_shrink_to_fit(); } + + + + + + + [[__nodiscard__]] + size_type + capacity() const noexcept + { return size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); } + + + + + + [[__nodiscard__]] + bool + empty() const noexcept + { return begin() == end(); } +# 1106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + reserve(size_type __n); +# 1121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + [[__nodiscard__]] + reference + operator[](size_type __n) noexcept + { + ; + return *(this->_M_impl._M_start + __n); + } +# 1140 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + [[__nodiscard__]] + const_reference + operator[](size_type __n) const noexcept + { + ; + return *(this->_M_impl._M_start + __n); + } + + protected: + + + void + _M_range_check(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"), + + + __n, this->size()); + } + + public: +# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + reference + at(size_type __n) + { + _M_range_check(__n); + return (*this)[__n]; + } +# 1193 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + const_reference + at(size_type __n) const + { + _M_range_check(__n); + return (*this)[__n]; + } + + + + + + [[__nodiscard__]] + reference + front() noexcept + { + ; + return *begin(); + } + + + + + + [[__nodiscard__]] + const_reference + front() const noexcept + { + ; + return *begin(); + } + + + + + + [[__nodiscard__]] + reference + back() noexcept + { + ; + return *(end() - 1); + } + + + + + + [[__nodiscard__]] + const_reference + back() const noexcept + { + ; + return *(end() - 1); + } +# 1255 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + [[__nodiscard__]] + _Tp* + data() noexcept + { return _M_data_ptr(this->_M_impl._M_start); } + + [[__nodiscard__]] + const _Tp* + data() const noexcept + { return _M_data_ptr(this->_M_impl._M_start); } +# 1277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + push_back(const value_type& __x) + { + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + __x); + ++this->_M_impl._M_finish; + ; + } + else + _M_realloc_insert(end(), __x); + } + + + + void + push_back(value_type&& __x) + { emplace_back(std::move(__x)); } + + template + + + reference + + + + emplace_back(_Args&&... __args); +# 1318 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + pop_back() noexcept + { + ; + --this->_M_impl._M_finish; + _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); + ; + } +# 1340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + + iterator + emplace(const_iterator __position, _Args&&... __args) + { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); } +# 1358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + insert(const_iterator __position, const value_type& __x); +# 1389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + insert(const_iterator __position, value_type&& __x) + { return _M_insert_rval(__position, std::move(__x)); } +# 1407 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + insert(const_iterator __position, initializer_list __l) + { + auto __offset = __position - cbegin(); + _M_range_insert(begin() + __offset, __l.begin(), __l.end(), + std::random_access_iterator_tag()); + return begin() + __offset; + } +# 1433 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + insert(const_iterator __position, size_type __n, const value_type& __x) + { + difference_type __offset = __position - cbegin(); + _M_fill_insert(begin() + __offset, __n, __x); + return begin() + __offset; + } +# 1475 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template> + + iterator + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last) + { + difference_type __offset = __position - cbegin(); + _M_range_insert(begin() + __offset, __first, __last, + std::__iterator_category(__first)); + return begin() + __offset; + } +# 1529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + + erase(const_iterator __position) + { return _M_erase(begin() + (__position - cbegin())); } +# 1557 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + + erase(const_iterator __first, const_iterator __last) + { + const auto __beg = begin(); + const auto __cbeg = cbegin(); + return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg)); + } +# 1582 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + swap(vector& __x) noexcept + { + + do { if (std::__is_constant_evaluated() && !bool(_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator())) __builtin_unreachable(); } while (false); + + + this->_M_impl._M_swap_data(__x._M_impl); + _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(), + __x._M_get_Tp_allocator()); + } +# 1601 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + clear() noexcept + { _M_erase_at_end(this->_M_impl._M_start); } + + protected: + + + + + template + + pointer + _M_allocate_and_copy(size_type __n, + _ForwardIterator __first, _ForwardIterator __last) + { + pointer __result = this->_M_allocate(__n); + try + { + std::__uninitialized_copy_a(__first, __last, __result, + _M_get_Tp_allocator()); + return __result; + } + catch(...) + { + _M_deallocate(__result, __n); + throw; + } + } +# 1661 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + + void + _M_range_initialize(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + try { + for (; __first != __last; ++__first) + + emplace_back(*__first); + + + + } catch(...) { + clear(); + throw; + } + } + + + template + + void + _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __n = std::distance(__first, __last); + this->_M_impl._M_start + = this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator())); + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__first, __last, + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } + + + + + void + _M_fill_initialize(size_type __n, const value_type& __value) + { + this->_M_impl._M_finish = + std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, + _M_get_Tp_allocator()); + } + + + + + void + _M_default_initialize(size_type __n) + { + this->_M_impl._M_finish = + std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, + _M_get_Tp_allocator()); + } +# 1727 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { _M_fill_assign(__n, __val); } + + + template + + void + _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } + + + template + + void + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag); + + + template + + void + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag); + + + + + void + _M_fill_assign(size_type __n, const value_type& __val); + + + + + + + + template + + void + _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, + __true_type) + { _M_fill_insert(__pos, __n, __val); } + + + template + + void + _M_insert_dispatch(iterator __pos, _InputIterator __first, + _InputIterator __last, __false_type) + { + _M_range_insert(__pos, __first, __last, + std::__iterator_category(__first)); + } + + + template + + void + _M_range_insert(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag); + + + template + + void + _M_range_insert(iterator __pos, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag); + + + + + void + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); + + + + + void + _M_default_append(size_type __n); + + + bool + _M_shrink_to_fit(); +# 1826 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + struct _Temporary_value + { + template + explicit + _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec) + { + _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(), + std::forward<_Args>(__args)...); + } + + + ~_Temporary_value() + { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); } + + value_type& + _M_val() noexcept { return _M_storage._M_val; } + + private: + _Tp* + _M_ptr() noexcept { return std::__addressof(_M_storage._M_val); } + + union _Storage + { + constexpr _Storage() : _M_byte() { } + ~_Storage() { } + _Storage& operator=(const _Storage&) = delete; + unsigned char _M_byte; + _Tp _M_val; + }; + + vector* _M_this; + _Storage _M_storage; + }; + + + + template + + void + _M_insert_aux(iterator __position, _Arg&& __arg); + + template + + void + _M_realloc_insert(iterator __position, _Args&&... __args); + + + + iterator + _M_insert_rval(const_iterator __position, value_type&& __v); + + + template + + iterator + _M_emplace_aux(const_iterator __position, _Args&&... __args); + + + + iterator + _M_emplace_aux(const_iterator __position, value_type&& __v) + { return _M_insert_rval(__position, std::move(__v)); } + + + + + size_type + _M_check_len(size_type __n, const char* __s) const + { + if (max_size() - size() < __n) + __throw_length_error((__s)); + + const size_type __len = size() + (std::max)(size(), __n); + return (__len < size() || __len > max_size()) ? max_size() : __len; + } + + + static size_type + _S_check_init_len(size_type __n, const allocator_type& __a) + { + if (__n > _S_max_size(_Tp_alloc_type(__a))) + __throw_length_error( + ("cannot create std::vector larger than max_size()")); + return __n; + } + + static size_type + _S_max_size(const _Tp_alloc_type& __a) noexcept + { + + + + const size_t __diffmax + = __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); + const size_t __allocmax = _Alloc_traits::max_size(__a); + return (std::min)(__diffmax, __allocmax); + } + + + + + + + void + _M_erase_at_end(pointer __pos) noexcept + { + if (size_type __n = this->_M_impl._M_finish - __pos) + { + std::_Destroy(__pos, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __pos; + ; + } + } + + + iterator + _M_erase(iterator __position); + + + iterator + _M_erase(iterator __first, iterator __last); + + + private: + + + + + void + _M_move_assign(vector&& __x, true_type) noexcept + { + vector __tmp(get_allocator()); + this->_M_impl._M_swap_data(__x._M_impl); + __tmp._M_impl._M_swap_data(__x._M_impl); + std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); + } + + + + + void + _M_move_assign(vector&& __x, false_type) + { + if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) + _M_move_assign(std::move(__x), true_type()); + else + { + + + this->_M_assign_aux(std::make_move_iterator(__x.begin()), + std::make_move_iterator(__x.end()), + std::random_access_iterator_tag()); + __x.clear(); + } + } + + + template + + _Up* + _M_data_ptr(_Up* __ptr) const noexcept + { return __ptr; } + + + template + + typename std::pointer_traits<_Ptr>::element_type* + _M_data_ptr(_Ptr __ptr) const + { return empty() ? nullptr : std::__to_address(__ptr); } +# 2012 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + }; + + + template::value_type, + typename _Allocator = allocator<_ValT>, + typename = _RequireInputIter<_InputIterator>, + typename = _RequireAllocator<_Allocator>> + vector(_InputIterator, _InputIterator, _Allocator = _Allocator()) + -> vector<_ValT, _Allocator>; +# 2034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + + inline bool + operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return (__x.size() == __y.size() + && std::equal(__x.begin(), __x.end(), __y.begin())); } +# 2074 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + inline bool + operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); } + + + template + inline bool + operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return !(__x == __y); } + + + template + inline bool + operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return __y < __x; } + + + template + inline bool + operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return !(__x < __y); } + + + + template + + inline void + swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + + + + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::is_nothrow_move_assignable> + { }; + } + + + +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 1 3 +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + typedef unsigned long _Bit_type; + enum { _S_word_bit = int(8 * sizeof(_Bit_type)) }; + + __attribute__((__nonnull__)) + + void + __fill_bvector_n(_Bit_type*, size_t, bool) noexcept; + + + + struct _Bit_reference + { + _Bit_type * _M_p; + _Bit_type _M_mask; + + + _Bit_reference(_Bit_type * __x, _Bit_type __y) + : _M_p(__x), _M_mask(__y) { } + + + _Bit_reference() noexcept : _M_p(0), _M_mask(0) { } + + + _Bit_reference(const _Bit_reference&) = default; + + + [[__nodiscard__]] + operator bool() const noexcept + { return !!(*_M_p & _M_mask); } + + + _Bit_reference& + operator=(bool __x) noexcept + { + if (__x) + *_M_p |= _M_mask; + else + *_M_p &= ~_M_mask; + return *this; + } +# 122 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + _Bit_reference& + operator=(const _Bit_reference& __x) noexcept + { return *this = bool(__x); } + + [[__nodiscard__]] + bool + operator==(const _Bit_reference& __x) const + { return bool(*this) == bool(__x); } + + [[__nodiscard__]] + bool + operator<(const _Bit_reference& __x) const + { return !bool(*this) && bool(__x); } + + + void + flip() noexcept + { *_M_p ^= _M_mask; } + + + + friend void + swap(_Bit_reference __x, _Bit_reference __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + + friend void + swap(_Bit_reference __x, bool& __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + + friend void + swap(bool& __x, _Bit_reference __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + struct _Bit_iterator_base + : public std::iterator + { + _Bit_type * _M_p; + unsigned int _M_offset; + + + _Bit_iterator_base(_Bit_type * __x, unsigned int __y) + : _M_p(__x), _M_offset(__y) { } + + + void + _M_bump_up() + { + if (_M_offset++ == int(_S_word_bit) - 1) + { + _M_offset = 0; + ++_M_p; + } + } + + + void + _M_bump_down() + { + if (_M_offset-- == 0) + { + _M_offset = int(_S_word_bit) - 1; + --_M_p; + } + } + + + void + _M_incr(ptrdiff_t __i) + { + difference_type __n = __i + _M_offset; + _M_p += __n / int(_S_word_bit); + __n = __n % int(_S_word_bit); + if (__n < 0) + { + __n += int(_S_word_bit); + --_M_p; + } + _M_offset = static_cast(__n); + } + + [[__nodiscard__]] + friend bool + operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; } +# 237 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + [[__nodiscard__]] + friend bool + operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { + return __x._M_p < __y._M_p + || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset); + } + + [[__nodiscard__]] + friend bool + operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return !(__x == __y); } + + [[__nodiscard__]] + friend bool + operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return __y < __x; } + + [[__nodiscard__]] + friend bool + operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return !(__y < __x); } + + [[__nodiscard__]] + friend bool + operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return !(__x < __y); } + + + friend ptrdiff_t + operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { + return (int(_S_word_bit) * (__x._M_p - __y._M_p) + + __x._M_offset - __y._M_offset); + } + }; +#pragma GCC diagnostic pop + + struct _Bit_iterator : public _Bit_iterator_base + { + typedef _Bit_reference reference; + + + + typedef _Bit_reference* pointer; + + typedef _Bit_iterator iterator; + + + _Bit_iterator() : _Bit_iterator_base(0, 0) { } + + + _Bit_iterator(_Bit_type * __x, unsigned int __y) + : _Bit_iterator_base(__x, __y) { } + + + iterator + _M_const_cast() const + { return *this; } + + [[__nodiscard__]] + reference + operator*() const + { return reference(_M_p, 1UL << _M_offset); } + + + iterator& + operator++() + { + _M_bump_up(); + return *this; + } + + + iterator + operator++(int) + { + iterator __tmp = *this; + _M_bump_up(); + return __tmp; + } + + + iterator& + operator--() + { + _M_bump_down(); + return *this; + } + + + iterator + operator--(int) + { + iterator __tmp = *this; + _M_bump_down(); + return __tmp; + } + + + iterator& + operator+=(difference_type __i) + { + _M_incr(__i); + return *this; + } + + + iterator& + operator-=(difference_type __i) + { + *this += -__i; + return *this; + } + + [[__nodiscard__]] + reference + operator[](difference_type __i) const + { return *(*this + __i); } + + [[__nodiscard__]] + friend iterator + operator+(const iterator& __x, difference_type __n) + { + iterator __tmp = __x; + __tmp += __n; + return __tmp; + } + + [[__nodiscard__]] + friend iterator + operator+(difference_type __n, const iterator& __x) + { return __x + __n; } + + [[__nodiscard__]] + friend iterator + operator-(const iterator& __x, difference_type __n) + { + iterator __tmp = __x; + __tmp -= __n; + return __tmp; + } + }; + + struct _Bit_const_iterator : public _Bit_iterator_base + { + typedef bool reference; + typedef bool const_reference; + + + + typedef const bool* pointer; + + typedef _Bit_const_iterator const_iterator; + + + _Bit_const_iterator() : _Bit_iterator_base(0, 0) { } + + + _Bit_const_iterator(_Bit_type * __x, unsigned int __y) + : _Bit_iterator_base(__x, __y) { } + + + _Bit_const_iterator(const _Bit_iterator& __x) + : _Bit_iterator_base(__x._M_p, __x._M_offset) { } + + + _Bit_iterator + _M_const_cast() const + { return _Bit_iterator(_M_p, _M_offset); } + + [[__nodiscard__]] + const_reference + operator*() const + { return _Bit_reference(_M_p, 1UL << _M_offset); } + + + const_iterator& + operator++() + { + _M_bump_up(); + return *this; + } + + + const_iterator + operator++(int) + { + const_iterator __tmp = *this; + _M_bump_up(); + return __tmp; + } + + + const_iterator& + operator--() + { + _M_bump_down(); + return *this; + } + + + const_iterator + operator--(int) + { + const_iterator __tmp = *this; + _M_bump_down(); + return __tmp; + } + + + const_iterator& + operator+=(difference_type __i) + { + _M_incr(__i); + return *this; + } + + + const_iterator& + operator-=(difference_type __i) + { + *this += -__i; + return *this; + } + + [[__nodiscard__]] + const_reference + operator[](difference_type __i) const + { return *(*this + __i); } + + [[__nodiscard__]] + friend const_iterator + operator+(const const_iterator& __x, difference_type __n) + { + const_iterator __tmp = __x; + __tmp += __n; + return __tmp; + } + + [[__nodiscard__]] + friend const_iterator + operator-(const const_iterator& __x, difference_type __n) + { + const_iterator __tmp = __x; + __tmp -= __n; + return __tmp; + } + + [[__nodiscard__]] + friend const_iterator + operator+(difference_type __n, const const_iterator& __x) + { return __x + __n; } + }; + + template + struct _Bvector_base + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Bit_type>::other _Bit_alloc_type; + typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type> + _Bit_alloc_traits; + typedef typename _Bit_alloc_traits::pointer _Bit_pointer; + + struct _Bvector_impl_data + { + + _Bit_iterator _M_start; +# 514 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + _Bit_iterator _M_finish; + _Bit_pointer _M_end_of_storage; + + + _Bvector_impl_data() noexcept + : _M_start(), _M_finish(), _M_end_of_storage() + { } + + + _Bvector_impl_data(const _Bvector_impl_data&) = default; + + _Bvector_impl_data& + operator=(const _Bvector_impl_data&) = default; + + + _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept + : _Bvector_impl_data(__x) + { __x._M_reset(); } + + + void + _M_move_data(_Bvector_impl_data&& __x) noexcept + { + *this = __x; + __x._M_reset(); + } + + + + void + _M_reset() noexcept + { *this = _Bvector_impl_data(); } + + + void + _M_swap_data(_Bvector_impl_data& __x) noexcept + { + + + std::swap(*this, __x); + } + }; + + struct _Bvector_impl + : public _Bit_alloc_type, public _Bvector_impl_data + { + + _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value) + + : _Bit_alloc_type() + { } + + + _Bvector_impl(const _Bit_alloc_type& __a) noexcept + : _Bit_alloc_type(__a) + { } + + + + + + _Bvector_impl(_Bvector_impl&& __x) noexcept + : _Bit_alloc_type(std::move(__x)), _Bvector_impl_data(std::move(__x)) + { } + + + _Bvector_impl(_Bit_alloc_type&& __a, _Bvector_impl&& __x) noexcept + : _Bit_alloc_type(std::move(__a)), _Bvector_impl_data(std::move(__x)) + { } + + + + _Bit_type* + _M_end_addr() const noexcept + { + if (this->_M_end_of_storage) + return std::__addressof(this->_M_end_of_storage[-1]) + 1; + return 0; + } + }; + + public: + typedef _Alloc allocator_type; + + + _Bit_alloc_type& + _M_get_Bit_allocator() noexcept + { return this->_M_impl; } + + + const _Bit_alloc_type& + _M_get_Bit_allocator() const noexcept + { return this->_M_impl; } + + + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_get_Bit_allocator()); } + + + _Bvector_base() = default; + + + + + + _Bvector_base(const allocator_type& __a) + : _M_impl(__a) { } + + + _Bvector_base(_Bvector_base&&) = default; + + + _Bvector_base(_Bvector_base&& __x, const allocator_type& __a) noexcept + : _M_impl(_Bit_alloc_type(__a), std::move(__x._M_impl)) + { } + + + + ~_Bvector_base() + { this->_M_deallocate(); } + + protected: + _Bvector_impl _M_impl; + + + _Bit_pointer + _M_allocate(size_t __n) + { + _Bit_pointer __p = _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); +# 652 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + return __p; + } + + + void + _M_deallocate() + { + if (_M_impl._M_start._M_p) + { + const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p; + _Bit_alloc_traits::deallocate(_M_impl, + _M_impl._M_end_of_storage - __n, + __n); + _M_impl._M_reset(); + } + } + + + + void + _M_move_data(_Bvector_base&& __x) noexcept + { _M_impl._M_move_data(std::move(__x._M_impl)); } + + + constexpr + static size_t + _S_nword(size_t __n) + { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); } + }; +# 703 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + template + class vector : protected _Bvector_base<_Alloc> + { + typedef _Bvector_base<_Alloc> _Base; + typedef typename _Base::_Bit_pointer _Bit_pointer; + typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits; + + + friend struct std::hash; + + + public: + typedef bool value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Bit_reference reference; + typedef bool const_reference; + typedef _Bit_reference* pointer; + typedef const bool* const_pointer; + typedef _Bit_iterator iterator; + typedef _Bit_const_iterator const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef _Alloc allocator_type; + + + allocator_type + get_allocator() const + { return _Base::get_allocator(); } + + protected: + using _Base::_M_allocate; + using _Base::_M_deallocate; + using _Base::_S_nword; + using _Base::_M_get_Bit_allocator; + + public: + + vector() = default; + + + + + + explicit + vector(const allocator_type& __a) + : _Base(__a) { } + + + + explicit + vector(size_type __n, const allocator_type& __a = allocator_type()) + : vector(__n, false, __a) + { } + + + vector(size_type __n, const bool& __value, + const allocator_type& __a = allocator_type()) + + + + + + : _Base(__a) + { + _M_initialize(__n); + _M_initialize_value(__value); + } + + + vector(const vector& __x) + : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator())) + { + const_iterator __xbegin = __x.begin(), __xend = __x.end(); + _M_initialize(__x.size()); + _M_copy_aligned(__xbegin, __xend, begin()); + } + + + vector(vector&&) = default; + + private: + + vector(vector&& __x, const allocator_type& __a, true_type) noexcept + : _Base(std::move(__x), __a) + { } + + + vector(vector&& __x, const allocator_type& __a, false_type) + : _Base(__a) + { + if (__x.get_allocator() == __a) + this->_M_move_data(std::move(__x)); + else + { + _M_initialize(__x.size()); + _M_copy_aligned(__x.begin(), __x.end(), begin()); + __x.clear(); + } + } + + public: + + vector(vector&& __x, const __type_identity_t& __a) + noexcept(_Bit_alloc_traits::_S_always_equal()) + : vector(std::move(__x), __a, + typename _Bit_alloc_traits::is_always_equal{}) + { } + + + vector(const vector& __x, const __type_identity_t& __a) + : _Base(__a) + { + _M_initialize(__x.size()); + _M_copy_aligned(__x.begin(), __x.end(), begin()); + } + + + vector(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_initialize_range(__l.begin(), __l.end(), + random_access_iterator_tag()); + } + + + + template> + + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_initialize_range(__first, __last, + std::__iterator_category(__first)); + } +# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + ~vector() noexcept { } + + + vector& + operator=(const vector& __x) + { + if (&__x == this) + return *this; + + if (_Bit_alloc_traits::_S_propagate_on_copy_assign()) + { + if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator()) + { + this->_M_deallocate(); + std::__alloc_on_copy(_M_get_Bit_allocator(), + __x._M_get_Bit_allocator()); + _M_initialize(__x.size()); + } + else + std::__alloc_on_copy(_M_get_Bit_allocator(), + __x._M_get_Bit_allocator()); + } + + if (__x.size() > capacity()) + { + this->_M_deallocate(); + _M_initialize(__x.size()); + } + this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), + begin()); + return *this; + } + + + + vector& + operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move()) + { + if (_Bit_alloc_traits::_S_propagate_on_move_assign() + || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator()) + { + this->_M_deallocate(); + this->_M_move_data(std::move(__x)); + std::__alloc_on_move(_M_get_Bit_allocator(), + __x._M_get_Bit_allocator()); + } + else + { + if (__x.size() > capacity()) + { + this->_M_deallocate(); + _M_initialize(__x.size()); + } + this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), + begin()); + __x.clear(); + } + return *this; + } + + + vector& + operator=(initializer_list __l) + { + this->assign(__l.begin(), __l.end()); + return *this; + } + + + + + + + + void + assign(size_type __n, const bool& __x) + { _M_fill_assign(__n, __x); } + + + template> + + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } +# 952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + void + assign(initializer_list __l) + { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); } + + + [[__nodiscard__]] + iterator + begin() noexcept + { return iterator(this->_M_impl._M_start._M_p, 0); } + + [[__nodiscard__]] + const_iterator + begin() const noexcept + { return const_iterator(this->_M_impl._M_start._M_p, 0); } + + [[__nodiscard__]] + iterator + end() noexcept + { return this->_M_impl._M_finish; } + + [[__nodiscard__]] + const_iterator + end() const noexcept + { return this->_M_impl._M_finish; } + + [[__nodiscard__]] + reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + [[__nodiscard__]] + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + [[__nodiscard__]] + reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + [[__nodiscard__]] + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + + [[__nodiscard__]] + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_impl._M_start._M_p, 0); } + + [[__nodiscard__]] + const_iterator + cend() const noexcept + { return this->_M_impl._M_finish; } + + [[__nodiscard__]] + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + [[__nodiscard__]] + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + + [[__nodiscard__]] + size_type + size() const noexcept + { return size_type(end() - begin()); } + + [[__nodiscard__]] + size_type + max_size() const noexcept + { + const size_type __isize = + __gnu_cxx::__numeric_traits::__max + - int(_S_word_bit) + 1; + const size_type __asize + = _Bit_alloc_traits::max_size(_M_get_Bit_allocator()); + return (__asize <= __isize / int(_S_word_bit) + ? __asize * int(_S_word_bit) : __isize); + } + + [[__nodiscard__]] + size_type + capacity() const noexcept + { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0) + - begin()); } + + [[__nodiscard__]] + bool + empty() const noexcept + { return begin() == end(); } + + [[__nodiscard__]] + reference + operator[](size_type __n) + { return begin()[__n]; } + + [[__nodiscard__]] + const_reference + operator[](size_type __n) const + { return begin()[__n]; } + + protected: + + void + _M_range_check(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"), + + + __n, this->size()); + } + + public: + + reference + at(size_type __n) + { + _M_range_check(__n); + return (*this)[__n]; + } + + + const_reference + at(size_type __n) const + { + _M_range_check(__n); + return (*this)[__n]; + } + + + void + reserve(size_type __n) + { + if (__n > max_size()) + __throw_length_error(("vector::reserve")); + if (capacity() < __n) + _M_reallocate(__n); + } + + [[__nodiscard__]] + reference + front() + { return *begin(); } + + [[__nodiscard__]] + const_reference + front() const + { return *begin(); } + + [[__nodiscard__]] + reference + back() + { return *(end() - 1); } + + [[__nodiscard__]] + const_reference + back() const + { return *(end() - 1); } + + + void + push_back(bool __x) + { + if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) + *this->_M_impl._M_finish++ = __x; + else + _M_insert_aux(end(), __x); + } + + + void + swap(vector& __x) noexcept + { + + do { if (std::__is_constant_evaluated() && !bool(_Bit_alloc_traits::propagate_on_container_swap::value || _M_get_Bit_allocator() == __x._M_get_Bit_allocator())) __builtin_unreachable(); } while (false); + + + this->_M_impl._M_swap_data(__x._M_impl); + _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(), + __x._M_get_Bit_allocator()); + } + + + + static void + swap(reference __x, reference __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + + iterator + + insert(const_iterator __position, const bool& __x) + + + + { + const difference_type __n = __position - begin(); + if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr() + && __position == end()) + *this->_M_impl._M_finish++ = __x; + else + _M_insert_aux(__position._M_const_cast(), __x); + return begin() + __n; + } + + + __attribute__ ((__deprecated__ ("use '" "insert(position, false)" "' instead"))) + iterator + insert(const_iterator __position) + { return this->insert(__position._M_const_cast(), false); } + + + + template> + + iterator + insert(const_iterator __position, + _InputIterator __first, _InputIterator __last) + { + difference_type __offset = __position - cbegin(); + _M_insert_range(__position._M_const_cast(), + __first, __last, + std::__iterator_category(__first)); + return begin() + __offset; + } +# 1202 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + iterator + insert(const_iterator __position, size_type __n, const bool& __x) + { + difference_type __offset = __position - cbegin(); + _M_fill_insert(__position._M_const_cast(), __n, __x); + return begin() + __offset; + } +# 1217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + iterator + insert(const_iterator __p, initializer_list __l) + { return this->insert(__p, __l.begin(), __l.end()); } + + + + void + pop_back() + { --this->_M_impl._M_finish; } + + + iterator + + erase(const_iterator __position) + + + + { return _M_erase(__position._M_const_cast()); } + + + iterator + + erase(const_iterator __first, const_iterator __last) + + + + { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } + + + void + resize(size_type __new_size, bool __x = bool()) + { + if (__new_size < size()) + _M_erase_at_end(begin() + difference_type(__new_size)); + else + insert(end(), __new_size - size(), __x); + } + + + + void + shrink_to_fit() + { _M_shrink_to_fit(); } + + + + void + flip() noexcept + { + _Bit_type * const __end = this->_M_impl._M_end_addr(); + for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p) + *__p = ~*__p; + } + + + void + clear() noexcept + { _M_erase_at_end(begin()); } + + + template + + + reference + + + + emplace_back(_Args&&... __args) + { + push_back(bool(__args...)); + + return back(); + + } + + template + + iterator + emplace(const_iterator __pos, _Args&&... __args) + { return insert(__pos, bool(__args...)); } + + + protected: + + + iterator + _M_copy_aligned(const_iterator __first, const_iterator __last, + iterator __result) + { + _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p); + return std::copy(const_iterator(__last._M_p, 0), __last, + iterator(__q, 0)); + } + + + void + _M_initialize(size_type __n) + { + if (__n) + { + _Bit_pointer __q = this->_M_allocate(__n); + this->_M_impl._M_end_of_storage = __q + _S_nword(__n); + iterator __start = iterator(std::__addressof(*__q), 0); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __start + difference_type(__n); + } + } + + + void + _M_initialize_value(bool __x) noexcept + { + if (_Bit_type* __p = this->_M_impl._M_start._M_p) + __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x); + } + + + void + _M_reallocate(size_type __n); + + + + bool + _M_shrink_to_fit(); +# 1362 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + template + + void + _M_initialize_range(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + for (; __first != __last; ++__first) + push_back(*__first); + } + + template + + void + _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __n = std::distance(__first, __last); + _M_initialize(__n); + std::copy(__first, __last, begin()); + } +# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + void + _M_fill_assign(size_t __n, bool __x) + { + if (__n > size()) + { + _M_initialize_value(__x); + insert(end(), __n - size(), __x); + } + else + { + _M_erase_at_end(begin() + __n); + _M_initialize_value(__x); + } + } + + template + + void + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + iterator __cur = begin(); + for (; __first != __last && __cur != end(); ++__cur, (void)++__first) + *__cur = *__first; + if (__first == __last) + _M_erase_at_end(__cur); + else + insert(end(), __first, __last); + } + + template + + void + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __len = std::distance(__first, __last); + if (__len < size()) + _M_erase_at_end(std::copy(__first, __last, begin())); + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, size()); + std::copy(__first, __mid, begin()); + insert(end(), __mid, __last); + } + } +# 1466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + void + _M_fill_insert(iterator __position, size_type __n, bool __x); + + template + + void + _M_insert_range(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag) + { + for (; __first != __last; ++__first) + { + __pos = insert(__pos, *__first); + ++__pos; + } + } + + template + + void + _M_insert_range(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag); + + + void + _M_insert_aux(iterator __position, bool __x); + + + size_type + _M_check_len(size_type __n, const char* __s) const + { + if (max_size() - size() < __n) + __throw_length_error((__s)); + + const size_type __len = size() + std::max(size(), __n); + return (__len < size() || __len > max_size()) ? max_size() : __len; + } + + + void + _M_erase_at_end(iterator __pos) + { this->_M_impl._M_finish = __pos; } + + + iterator + _M_erase(iterator __pos); + + + iterator + _M_erase(iterator __first, iterator __last); + + protected: + + + + + + + void data() = delete; + + + + }; + + + + + + inline void + __fill_bvector(_Bit_type* __v, unsigned int __first, unsigned int __last, + bool __x) noexcept + { + const _Bit_type __fmask = ~0ul << __first; + const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last); + const _Bit_type __mask = __fmask & __lmask; + + if (__x) + *__v |= __mask; + else + *__v &= ~__mask; + } + + + __attribute__((__nonnull__)) + + inline void + __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) noexcept + { +# 1561 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type)); + } + + + + inline void + __fill_a1(std::_Bit_iterator __first, + std::_Bit_iterator __last, const bool& __x) + { + if (__first._M_p != __last._M_p) + { + _Bit_type* __first_p = __first._M_p; + if (__first._M_offset != 0) + __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x); + + __fill_bvector_n(__first_p, __last._M_p - __first_p, __x); + + if (__last._M_offset != 0) + __fill_bvector(__last._M_p, 0, __last._M_offset, __x); + } + else if (__first._M_offset != __last._M_offset) + __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x); + } + + + + + template + struct hash> + : public __hash_base> + { + size_t + operator()(const std::vector&) const noexcept; + }; + + + +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/vector.tcc" 1 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/vector.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + + void + vector<_Tp, _Alloc>:: + reserve(size_type __n) + { + if (__n > this->max_size()) + __throw_length_error(("vector::reserve")); + if (this->capacity() < __n) + { + const size_type __old_size = size(); + pointer __tmp; + + if constexpr (_S_use_relocate()) + { + __tmp = this->_M_allocate(__n); + _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish, + __tmp, _M_get_Tp_allocator()); + } + else + + { + __tmp = _M_allocate_and_copy(__n, + std::__make_move_if_noexcept_iterator(this->_M_impl._M_start), + std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish)); + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + } + ; + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __tmp; + this->_M_impl._M_finish = __tmp + __old_size; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + } + } + + + template + template + + + typename vector<_Tp, _Alloc>::reference + + + + vector<_Tp, _Alloc>:: + emplace_back(_Args&&... __args) + { + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::forward<_Args>(__args)...); + ++this->_M_impl._M_finish; + ; + } + else + _M_realloc_insert(end(), std::forward<_Args>(__args)...); + + return back(); + + } + + + template + + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + + insert(const_iterator __position, const value_type& __x) + + + + { + const size_type __n = __position - begin(); + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + do { if (std::__is_constant_evaluated() && !bool(__position != const_iterator())) __builtin_unreachable(); } while (false); + if (!(__position != const_iterator())) + __builtin_unreachable(); + + if (__position == end()) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + __x); + ++this->_M_impl._M_finish; + ; + } + else + { + + const auto __pos = begin() + (__position - cbegin()); + + + _Temporary_value __x_copy(this, __x); + _M_insert_aux(__pos, std::move(__x_copy._M_val())); + + + + } + } + else + + _M_realloc_insert(begin() + (__position - cbegin()), __x); + + + + + return iterator(this->_M_impl._M_start + __n); + } + + template + + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + _M_erase(iterator __position) + { + if (__position + 1 != end()) + std::move(__position + 1, end(), __position); + --this->_M_impl._M_finish; + _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); + ; + return __position; + } + + template + + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + _M_erase(iterator __first, iterator __last) + { + if (__first != __last) + { + if (__last != end()) + std::move(__last, end(), __first); + _M_erase_at_end(__first.base() + (end() - __last)); + } + return __first; + } + + template + + vector<_Tp, _Alloc>& + vector<_Tp, _Alloc>:: + operator=(const vector<_Tp, _Alloc>& __x) + { + if (std::__addressof(__x) != this) + { + ; + + if (_Alloc_traits::_S_propagate_on_copy_assign()) + { + if (!_Alloc_traits::_S_always_equal() + && _M_get_Tp_allocator() != __x._M_get_Tp_allocator()) + { + + this->clear(); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = nullptr; + this->_M_impl._M_finish = nullptr; + this->_M_impl._M_end_of_storage = nullptr; + } + std::__alloc_on_copy(_M_get_Tp_allocator(), + __x._M_get_Tp_allocator()); + } + + const size_type __xlen = __x.size(); + if (__xlen > capacity()) + { + pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), + __x.end()); + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __tmp; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen; + } + else if (size() >= __xlen) + { + std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), + end(), _M_get_Tp_allocator()); + } + else + { + std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(), + this->_M_impl._M_start); + std::__uninitialized_copy_a(__x._M_impl._M_start + size(), + __x._M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + } + this->_M_impl._M_finish = this->_M_impl._M_start + __xlen; + } + return *this; + } + + template + + void + vector<_Tp, _Alloc>:: + _M_fill_assign(size_t __n, const value_type& __val) + { + if (__n > capacity()) + { + vector __tmp(__n, __val, _M_get_Tp_allocator()); + __tmp._M_impl._M_swap_data(this->_M_impl); + } + else if (__n > size()) + { + std::fill(begin(), end(), __val); + const size_type __add = __n - size(); + ; + this->_M_impl._M_finish = + std::__uninitialized_fill_n_a(this->_M_impl._M_finish, + __add, __val, _M_get_Tp_allocator()); + ; + } + else + _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val)); + } + + template + template + + void + vector<_Tp, _Alloc>:: + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + pointer __cur(this->_M_impl._M_start); + for (; __first != __last && __cur != this->_M_impl._M_finish; + ++__cur, (void)++__first) + *__cur = *__first; + if (__first == __last) + _M_erase_at_end(__cur); + else + _M_range_insert(end(), __first, __last, + std::__iterator_category(__first)); + } + + template + template + + void + vector<_Tp, _Alloc>:: + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __len = std::distance(__first, __last); + + if (__len > capacity()) + { + _S_check_init_len(__len, _M_get_Tp_allocator()); + pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + ; + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __tmp; + this->_M_impl._M_finish = this->_M_impl._M_start + __len; + this->_M_impl._M_end_of_storage = this->_M_impl._M_finish; + } + else if (size() >= __len) + _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, size()); + std::copy(__first, __mid, this->_M_impl._M_start); + const size_type __attribute__((__unused__)) __n = __len - size(); + ; + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__mid, __last, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + ; + } + } + + + template + + auto + vector<_Tp, _Alloc>:: + _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator + { + const auto __n = __position - cbegin(); + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + if (__position == cend()) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::move(__v)); + ++this->_M_impl._M_finish; + ; + } + else + _M_insert_aux(begin() + __n, std::move(__v)); + else + _M_realloc_insert(begin() + __n, std::move(__v)); + + return iterator(this->_M_impl._M_start + __n); + } + + template + template + + auto + vector<_Tp, _Alloc>:: + _M_emplace_aux(const_iterator __position, _Args&&... __args) + -> iterator + { + const auto __n = __position - cbegin(); + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + if (__position == cend()) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::forward<_Args>(__args)...); + ++this->_M_impl._M_finish; + ; + } + else + { + + + + _Temporary_value __tmp(this, std::forward<_Args>(__args)...); + _M_insert_aux(begin() + __n, std::move(__tmp._M_val())); + } + else + _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...); + + return iterator(this->_M_impl._M_start + __n); + } + + template + template + + void + vector<_Tp, _Alloc>:: + _M_insert_aux(iterator __position, _Arg&& __arg) + + + + + + + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::move(*(this->_M_impl._M_finish - 1))); + ++this->_M_impl._M_finish; + ; + + + + std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1); + + + + + + *__position = std::forward<_Arg>(__arg); + + } + + + template + template + + void + vector<_Tp, _Alloc>:: + _M_realloc_insert(iterator __position, _Args&&... __args) + + + + + + + { + const size_type __len = + _M_check_len(size_type(1), "vector::_M_realloc_insert"); + pointer __old_start = this->_M_impl._M_start; + pointer __old_finish = this->_M_impl._M_finish; + const size_type __elems_before = __position - begin(); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + try + { + + + + + + _Alloc_traits::construct(this->_M_impl, + __new_start + __elems_before, + + std::forward<_Args>(__args)...); + + + + __new_finish = pointer(); + + + if constexpr (_S_use_relocate()) + { + __new_finish = _S_relocate(__old_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + + ++__new_finish; + + __new_finish = _S_relocate(__position.base(), __old_finish, + __new_finish, _M_get_Tp_allocator()); + } + else + + { + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__old_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + + ++__new_finish; + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__position.base(), __old_finish, + __new_finish, _M_get_Tp_allocator()); + } + } + catch(...) + { + if (!__new_finish) + _Alloc_traits::destroy(this->_M_impl, + __new_start + __elems_before); + else + std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + throw; + } + + if constexpr (!_S_use_relocate()) + + std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); + ; + _M_deallocate(__old_start, + this->_M_impl._M_end_of_storage - __old_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + + template + + void + vector<_Tp, _Alloc>:: + _M_fill_insert(iterator __position, size_type __n, const value_type& __x) + { + if (__n != 0) + { + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >= __n) + { + + + + _Temporary_value __tmp(this, __x); + value_type& __x_copy = __tmp._M_val(); + + const size_type __elems_after = end() - __position; + pointer __old_finish(this->_M_impl._M_finish); + if (__elems_after > __n) + { + ; + std::__uninitialized_move_a(__old_finish - __n, + __old_finish, + __old_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n; + ; + std::move_backward(__position.base(), __old_finish - __n, __old_finish); + + std::fill(__position.base(), __position.base() + __n, + __x_copy); + } + else + { + ; + this->_M_impl._M_finish = + std::__uninitialized_fill_n_a(__old_finish, + __n - __elems_after, + __x_copy, + _M_get_Tp_allocator()); + ; + std::__uninitialized_move_a(__position.base(), __old_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __elems_after; + ; + std::fill(__position.base(), __old_finish, __x_copy); + } + } + else + { + + + pointer __old_start = this->_M_impl._M_start; + pointer __old_finish = this->_M_impl._M_finish; + const pointer __pos = __position.base(); + + const size_type __len = + _M_check_len(__n, "vector::_M_fill_insert"); + const size_type __elems_before = __pos - __old_start; + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + try + { + + std::__uninitialized_fill_n_a(__new_start + __elems_before, + __n, __x, + _M_get_Tp_allocator()); + __new_finish = pointer(); + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__old_start, __pos, __new_start, _M_get_Tp_allocator()); + + __new_finish += __n; + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__pos, __old_finish, __new_finish, _M_get_Tp_allocator()); + } + catch(...) + { + if (!__new_finish) + std::_Destroy(__new_start + __elems_before, + __new_start + __elems_before + __n, + _M_get_Tp_allocator()); + else + std::_Destroy(__new_start, __new_finish, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + throw; + } + std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); + ; + _M_deallocate(__old_start, + this->_M_impl._M_end_of_storage - __old_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } + + + template + + void + vector<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + if (__n != 0) + { + const size_type __size = size(); + size_type __navail = size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish); + + if (__size > max_size() || __navail > max_size() - __size) + __builtin_unreachable(); + + if (__navail >= __n) + { + ; + this->_M_impl._M_finish = + std::__uninitialized_default_n_a(this->_M_impl._M_finish, + __n, _M_get_Tp_allocator()); + ; + } + else + { + + + pointer __old_start = this->_M_impl._M_start; + pointer __old_finish = this->_M_impl._M_finish; + + const size_type __len = + _M_check_len(__n, "vector::_M_default_append"); + pointer __new_start(this->_M_allocate(__len)); + if constexpr (_S_use_relocate()) + { + try + { + std::__uninitialized_default_n_a(__new_start + __size, + __n, _M_get_Tp_allocator()); + } + catch(...) + { + _M_deallocate(__new_start, __len); + throw; + } + _S_relocate(__old_start, __old_finish, + __new_start, _M_get_Tp_allocator()); + } + else + { + pointer __destroy_from = pointer(); + try + { + std::__uninitialized_default_n_a(__new_start + __size, + __n, _M_get_Tp_allocator()); + __destroy_from = __new_start + __size; + std::__uninitialized_move_if_noexcept_a( + __old_start, __old_finish, + __new_start, _M_get_Tp_allocator()); + } + catch(...) + { + if (__destroy_from) + std::_Destroy(__destroy_from, __destroy_from + __n, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + throw; + } + std::_Destroy(__old_start, __old_finish, + _M_get_Tp_allocator()); + } + ; + _M_deallocate(__old_start, + this->_M_impl._M_end_of_storage - __old_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_start + __size + __n; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } + + template + + bool + vector<_Tp, _Alloc>:: + _M_shrink_to_fit() + { + if (capacity() == size()) + return false; + ; + return std::__shrink_to_fit_aux::_S_do_it(*this); + } + + + template + template + + void + vector<_Tp, _Alloc>:: + _M_range_insert(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag) + { + if (__pos == end()) + { + for (; __first != __last; ++__first) + insert(end(), *__first); + } + else if (__first != __last) + { + vector __tmp(__first, __last, _M_get_Tp_allocator()); + insert(__pos, + std::make_move_iterator(__tmp.begin()), + std::make_move_iterator(__tmp.end())); + } + } + + template + template + + void + vector<_Tp, _Alloc>:: + _M_range_insert(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag) + { + if (__first != __last) + { + const size_type __n = std::distance(__first, __last); + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >= __n) + { + const size_type __elems_after = end() - __position; + pointer __old_finish(this->_M_impl._M_finish); + if (__elems_after > __n) + { + ; + std::__uninitialized_move_a(this->_M_impl._M_finish - __n, + this->_M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n; + ; + std::move_backward(__position.base(), __old_finish - __n, __old_finish); + + std::copy(__first, __last, __position); + } + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, __elems_after); + ; + std::__uninitialized_copy_a(__mid, __last, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n - __elems_after; + ; + std::__uninitialized_move_a(__position.base(), + __old_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __elems_after; + ; + std::copy(__first, __mid, __position); + } + } + else + { + + + + pointer __old_start = this->_M_impl._M_start; + pointer __old_finish = this->_M_impl._M_finish; + + const size_type __len = + _M_check_len(__n, "vector::_M_range_insert"); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + try + { + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__old_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + __new_finish + = std::__uninitialized_copy_a(__first, __last, + __new_finish, + _M_get_Tp_allocator()); + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__position.base(), __old_finish, + __new_finish, _M_get_Tp_allocator()); + } + catch(...) + { + std::_Destroy(__new_start, __new_finish, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + throw; + } + std::_Destroy(__old_start, __old_finish, + _M_get_Tp_allocator()); + ; + _M_deallocate(__old_start, + this->_M_impl._M_end_of_storage - __old_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } + + + + template + + void + vector:: + _M_reallocate(size_type __n) + { + _Bit_pointer __q = this->_M_allocate(__n); + iterator __start(std::__addressof(*__q), 0); + iterator __finish(_M_copy_aligned(begin(), end(), __start)); + this->_M_deallocate(); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __finish; + this->_M_impl._M_end_of_storage = __q + _S_nword(__n); + } + + template + + void + vector:: + _M_fill_insert(iterator __position, size_type __n, bool __x) + { + if (__n == 0) + return; + if (capacity() - size() >= __n) + { + std::copy_backward(__position, end(), + this->_M_impl._M_finish + difference_type(__n)); + std::fill(__position, __position + difference_type(__n), __x); + this->_M_impl._M_finish += difference_type(__n); + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_fill_insert"); + _Bit_pointer __q = this->_M_allocate(__len); + iterator __start(std::__addressof(*__q), 0); + iterator __i = _M_copy_aligned(begin(), __position, __start); + std::fill(__i, __i + difference_type(__n), __x); + iterator __finish = std::copy(__position, end(), + __i + difference_type(__n)); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage = __q + _S_nword(__len); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __finish; + } + } + + template + template + + void + vector:: + _M_insert_range(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag) + { + if (__first != __last) + { + size_type __n = std::distance(__first, __last); + if (capacity() - size() >= __n) + { + std::copy_backward(__position, end(), + this->_M_impl._M_finish + + difference_type(__n)); + std::copy(__first, __last, __position); + this->_M_impl._M_finish += difference_type(__n); + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_insert_range"); + const iterator __begin = begin(), __end = end(); + _Bit_pointer __q = this->_M_allocate(__len); + iterator __start(std::__addressof(*__q), 0); + iterator __i = _M_copy_aligned(__begin, __position, __start); + __i = std::copy(__first, __last, __i); + iterator __finish = std::copy(__position, __end, __i); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage = __q + _S_nword(__len); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __finish; + } + } + } + + template + + void + vector:: + _M_insert_aux(iterator __position, bool __x) + { + if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) + { + std::copy_backward(__position, this->_M_impl._M_finish, + this->_M_impl._M_finish + 1); + *__position = __x; + ++this->_M_impl._M_finish; + } + else + { + const size_type __len = + _M_check_len(size_type(1), "vector::_M_insert_aux"); + _Bit_pointer __q = this->_M_allocate(__len); + iterator __start(std::__addressof(*__q), 0); + iterator __i = _M_copy_aligned(begin(), __position, __start); + *__i++ = __x; + iterator __finish = std::copy(__position, end(), __i); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage = __q + _S_nword(__len); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __finish; + } + } + + template + + typename vector::iterator + vector:: + _M_erase(iterator __position) + { + if (__position + 1 != end()) + std::copy(__position + 1, end(), __position); + --this->_M_impl._M_finish; + return __position; + } + + template + + typename vector::iterator + vector:: + _M_erase(iterator __first, iterator __last) + { + if (__first != __last) + _M_erase_at_end(std::copy(__last, end(), __first)); + return __first; + } + + + template + + bool + vector:: + _M_shrink_to_fit() + { + if (capacity() - size() < int(_S_word_bit)) + return false; + try + { + if (size_type __n = size()) + _M_reallocate(__n); + else + { + this->_M_deallocate(); + this->_M_impl._M_reset(); + } + return true; + } + catch(...) + { return false; } + } + + + + +} + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + size_t + hash>:: + operator()(const std::vector& __b) const noexcept + { + size_t __hash = 0; + const size_t __words = __b.size() / _S_word_bit; + if (__words) + { + const size_t __clength = __words * sizeof(_Bit_type); + __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength); + } + + const size_t __extrabits = __b.size() % _S_word_bit; + if (__extrabits) + { + _Bit_type __hiword = *__b._M_impl._M_finish._M_p; + __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits); + + const size_t __clength + = (__extrabits + 8 - 1) / 8; + if (__words) + __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash); + else + __hash = std::_Hash_impl::hash(&__hiword, __clength); + } + + return __hash; + } + + +} +# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 + + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 1 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 + + + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 +# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 2 3 + +extern "C++" +{ + +namespace std +{ + + using ::max_align_t; +} + + + +namespace std +{ + + + + + enum class byte : unsigned char {}; + + template struct __byte_operand { }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + + + + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; +# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + + template + using __byte_op_t = typename __byte_operand<_IntegerType>::__type; + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType> + operator<<(byte __b, _IntegerType __shift) noexcept + { return (byte)(unsigned char)((unsigned)__b << __shift); } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType> + operator>>(byte __b, _IntegerType __shift) noexcept + { return (byte)(unsigned char)((unsigned)__b >> __shift); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator|(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator&(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator^(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator~(byte __b) noexcept + { return (byte)(unsigned char)~(unsigned)__b; } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType>& + operator<<=(byte& __b, _IntegerType __shift) noexcept + { return __b = __b << __shift; } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType>& + operator>>=(byte& __b, _IntegerType __shift) noexcept + { return __b = __b >> __shift; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator|=(byte& __l, byte __r) noexcept + { return __l = __l | __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator&=(byte& __l, byte __r) noexcept + { return __l = __l & __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator^=(byte& __l, byte __r) noexcept + { return __l = __l ^ __r; } + + template + [[nodiscard,__gnu__::__always_inline__]] + constexpr _IntegerType + to_integer(__byte_op_t<_IntegerType> __b) noexcept + { return _IntegerType(__b); } + + +} + +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace pmr +{ + + + + + + + class memory_resource + { + static constexpr size_t _S_max_align = alignof(max_align_t); + + public: + memory_resource() = default; + memory_resource(const memory_resource&) = default; + virtual ~memory_resource(); + + memory_resource& operator=(const memory_resource&) = default; + + [[nodiscard]] + void* + allocate(size_t __bytes, size_t __alignment = _S_max_align) + __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3))) + { return ::operator new(__bytes, do_allocate(__bytes, __alignment)); } + + void + deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align) + __attribute__((__nonnull__)) + { return do_deallocate(__p, __bytes, __alignment); } + + [[nodiscard]] + bool + is_equal(const memory_resource& __other) const noexcept + { return do_is_equal(__other); } + + private: + virtual void* + do_allocate(size_t __bytes, size_t __alignment) = 0; + + virtual void + do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0; + + virtual bool + do_is_equal(const memory_resource& __other) const noexcept = 0; + }; + + [[nodiscard]] + inline bool + operator==(const memory_resource& __a, const memory_resource& __b) noexcept + { return &__a == &__b || __a.is_equal(__b); } + + + [[nodiscard]] + inline bool + operator!=(const memory_resource& __a, const memory_resource& __b) noexcept + { return !(__a == __b); } +# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + class polymorphic_allocator + { + + + template + struct __not_pair { using type = void; }; + + template + struct __not_pair> { }; + + public: + using value_type = _Tp; + + polymorphic_allocator() noexcept + { + extern memory_resource* get_default_resource() noexcept + __attribute__((__returns_nonnull__)); + _M_resource = get_default_resource(); + } + + polymorphic_allocator(memory_resource* __r) noexcept + __attribute__((__nonnull__)) + : _M_resource(__r) + { ; } + + polymorphic_allocator(const polymorphic_allocator& __other) = default; + + template + polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept + : _M_resource(__x.resource()) + { } + + polymorphic_allocator& + operator=(const polymorphic_allocator&) = delete; + + [[nodiscard]] + _Tp* + allocate(size_t __n) + __attribute__((__returns_nonnull__)) + { + if ((__gnu_cxx::__int_traits::__max / sizeof(_Tp)) < __n) + std::__throw_bad_array_new_length(); + return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp), + alignof(_Tp))); + } + + void + deallocate(_Tp* __p, size_t __n) noexcept + __attribute__((__nonnull__)) + { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); } +# 224 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + __attribute__((__nonnull__)) + typename __not_pair<_Tp1>::type + construct(_Tp1* __p, _Args&&... __args) + { + + + using __use_tag + = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>; + if constexpr (is_base_of_v<__uses_alloc0, __use_tag>) + ::new(__p) _Tp1(std::forward<_Args>(__args)...); + else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>) + ::new(__p) _Tp1(allocator_arg, *this, + std::forward<_Args>(__args)...); + else + ::new(__p) _Tp1(std::forward<_Args>(__args)..., *this); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t, + tuple<_Args1...> __x, tuple<_Args2...> __y) + { + auto __x_tag = + __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this); + auto __y_tag = + __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this); + index_sequence_for<_Args1...> __x_i; + index_sequence_for<_Args2...> __y_i; + + ::new(__p) pair<_Tp1, _Tp2>(piecewise_construct, + _S_construct_p(__x_tag, __x_i, __x), + _S_construct_p(__y_tag, __y_i, __y)); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p) + { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y) + { + this->construct(__p, piecewise_construct, + std::forward_as_tuple(std::forward<_Up>(__x)), + std::forward_as_tuple(std::forward<_Vp>(__y))); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, const std::pair<_Up, _Vp>& __pr) + { + this->construct(__p, piecewise_construct, + std::forward_as_tuple(__pr.first), + std::forward_as_tuple(__pr.second)); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr) + { + this->construct(__p, piecewise_construct, + std::forward_as_tuple(std::forward<_Up>(__pr.first)), + std::forward_as_tuple(std::forward<_Vp>(__pr.second))); + } +# 307 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + + __attribute__((__nonnull__)) + void + destroy(_Up* __p) + { __p->~_Up(); } + + polymorphic_allocator + select_on_container_copy_construction() const noexcept + { return polymorphic_allocator(); } + + memory_resource* + resource() const noexcept + __attribute__((__returns_nonnull__)) + { return _M_resource; } + + + + [[nodiscard]] + friend bool + operator==(const polymorphic_allocator& __a, + const polymorphic_allocator& __b) noexcept + { return *__a.resource() == *__b.resource(); } + + + [[nodiscard]] + friend bool + operator!=(const polymorphic_allocator& __a, + const polymorphic_allocator& __b) noexcept + { return !(__a == __b); } + + + private: + + using __uses_alloc1_ = __uses_alloc1; + using __uses_alloc2_ = __uses_alloc2; + + template + static tuple<_Args&&...> + _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t) + { return std::move(__t); } + + template + static tuple + _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>, + tuple<_Args...>& __t) + { + return { + allocator_arg, *__ua._M_a, std::get<_Ind>(std::move(__t))... + }; + } + + template + static tuple<_Args&&..., polymorphic_allocator> + _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>, + tuple<_Args...>& __t) + { return { std::get<_Ind>(std::move(__t))..., *__ua._M_a }; } + + + memory_resource* _M_resource; + }; + + template + [[nodiscard]] + inline bool + operator==(const polymorphic_allocator<_Tp1>& __a, + const polymorphic_allocator<_Tp2>& __b) noexcept + { return *__a.resource() == *__b.resource(); } + + + template + [[nodiscard]] + inline bool + operator!=(const polymorphic_allocator<_Tp1>& __a, + const polymorphic_allocator<_Tp2>& __b) noexcept + { return !(__a == __b); } + + +} + + template struct allocator_traits; + + + template + struct allocator_traits> + { + + using allocator_type = pmr::polymorphic_allocator<_Tp>; + + + using value_type = _Tp; + + + using pointer = _Tp*; + + + using const_pointer = const _Tp*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + + + + using propagate_on_container_copy_assignment = false_type; + using propagate_on_container_move_assignment = false_type; + using propagate_on_container_swap = false_type; + + static allocator_type + select_on_container_copy_construction(const allocator_type&) noexcept + { return allocator_type(); } + + + + using is_always_equal = false_type; + + template + using rebind_alloc = pmr::polymorphic_allocator<_Up>; + + template + using rebind_traits = allocator_traits>; +# 446 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + [[nodiscard]] static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 461 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + [[nodiscard]] static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer) + { return __a.allocate(__n); } +# 473 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + static void + construct(allocator_type& __a, _Up* __p, _Args&&... __args) + { __a.construct(__p, std::forward<_Args>(__args)...); } +# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + static void + destroy(allocator_type&, _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { __p->~_Up(); } + + + + + + static size_type + max_size(const allocator_type&) noexcept + { return size_t(-1) / sizeof(value_type); } + }; + + +} +# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace pmr { + template + using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>; + } +# 96 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 3 +} +# 16 "src/platform/inputs.h" 2 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdint" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdint" 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdint" 3 +namespace std +{ + + using ::int8_t; + using ::int16_t; + using ::int32_t; + using ::int64_t; + + using ::int_fast8_t; + using ::int_fast16_t; + using ::int_fast32_t; + using ::int_fast64_t; + + using ::int_least8_t; + using ::int_least16_t; + using ::int_least32_t; + using ::int_least64_t; + + using ::intmax_t; + using ::intptr_t; + + using ::uint8_t; + using ::uint16_t; + using ::uint32_t; + using ::uint64_t; + + using ::uint_fast8_t; + using ::uint_fast16_t; + using ::uint_fast32_t; + using ::uint_fast64_t; + + using ::uint_least8_t; + using ::uint_least16_t; + using ::uint_least32_t; + using ::uint_least64_t; + + using ::uintmax_t; + using ::uintptr_t; +# 142 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdint" 3 +} +# 17 "src/platform/inputs.h" 2 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 1 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + class bad_function_call : public std::exception + { + public: + virtual ~bad_function_call() noexcept; + + const char* what() const noexcept; + }; + + + + + + + + template + struct __is_location_invariant + : is_trivially_copyable<_Tp>::type + { }; + + class _Undefined_class; + + union _Nocopy_types + { + void* _M_object; + const void* _M_const_object; + void (*_M_function_pointer)(); + void (_Undefined_class::*_M_member_pointer)(); + }; + + union [[gnu::may_alias]] _Any_data + { + void* _M_access() noexcept { return &_M_pod_data[0]; } + const void* _M_access() const noexcept { return &_M_pod_data[0]; } + + template + _Tp& + _M_access() noexcept + { return *static_cast<_Tp*>(_M_access()); } + + template + const _Tp& + _M_access() const noexcept + { return *static_cast(_M_access()); } + + _Nocopy_types _M_unused; + char _M_pod_data[sizeof(_Nocopy_types)]; + }; + + enum _Manager_operation + { + __get_type_info, + __get_functor_ptr, + __clone_functor, + __destroy_functor + }; + + template + class function; + + + class _Function_base + { + public: + static const size_t _M_max_size = sizeof(_Nocopy_types); + static const size_t _M_max_align = __alignof__(_Nocopy_types); + + template + class _Base_manager + { + protected: + static const bool __stored_locally = + (__is_location_invariant<_Functor>::value + && sizeof(_Functor) <= _M_max_size + && __alignof__(_Functor) <= _M_max_align + && (_M_max_align % __alignof__(_Functor) == 0)); + + using _Local_storage = integral_constant; + + + static _Functor* + _M_get_pointer(const _Any_data& __source) noexcept + { + if constexpr (__stored_locally) + { + const _Functor& __f = __source._M_access<_Functor>(); + return const_cast<_Functor*>(std::__addressof(__f)); + } + else + return __source._M_access<_Functor*>(); + } + + private: + + + template + static void + _M_create(_Any_data& __dest, _Fn&& __f, true_type) + { + ::new (__dest._M_access()) _Functor(std::forward<_Fn>(__f)); + } + + + template + static void + _M_create(_Any_data& __dest, _Fn&& __f, false_type) + { + __dest._M_access<_Functor*>() + = new _Functor(std::forward<_Fn>(__f)); + } + + + static void + _M_destroy(_Any_data& __victim, true_type) + { + __victim._M_access<_Functor>().~_Functor(); + } + + + static void + _M_destroy(_Any_data& __victim, false_type) + { + delete __victim._M_access<_Functor*>(); + } + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { + case __get_type_info: + + __dest._M_access() = &typeid(_Functor); + + + + break; + + case __get_functor_ptr: + __dest._M_access<_Functor*>() = _M_get_pointer(__source); + break; + + case __clone_functor: + _M_init_functor(__dest, + *const_cast(_M_get_pointer(__source))); + break; + + case __destroy_functor: + _M_destroy(__dest, _Local_storage()); + break; + } + return false; + } + + template + static void + _M_init_functor(_Any_data& __functor, _Fn&& __f) + noexcept(__and_<_Local_storage, + is_nothrow_constructible<_Functor, _Fn>>::value) + { + _M_create(__functor, std::forward<_Fn>(__f), _Local_storage()); + } + + template + static bool + _M_not_empty_function(const function<_Signature>& __f) noexcept + { return static_cast(__f); } + + template + static bool + _M_not_empty_function(_Tp* __fp) noexcept + { return __fp != nullptr; } + + template + static bool + _M_not_empty_function(_Tp _Class::* __mp) noexcept + { return __mp != nullptr; } + + template + static bool + _M_not_empty_function(const _Tp&) noexcept + { return true; } + }; + + _Function_base() = default; + + ~_Function_base() + { + if (_M_manager) + _M_manager(_M_functor, _M_functor, __destroy_functor); + } + + bool _M_empty() const { return !_M_manager; } + + using _Manager_type + = bool (*)(_Any_data&, const _Any_data&, _Manager_operation); + + _Any_data _M_functor{}; + _Manager_type _M_manager{}; + }; + + template + class _Function_handler; + + template + class _Function_handler<_Res(_ArgTypes...), _Functor> + : public _Function_base::_Base_manager<_Functor> + { + using _Base = _Function_base::_Base_manager<_Functor>; + + public: + static bool + _M_manager(_Any_data& __dest, const _Any_data& __source, + _Manager_operation __op) + { + switch (__op) + { + + case __get_type_info: + __dest._M_access() = &typeid(_Functor); + break; + + case __get_functor_ptr: + __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source); + break; + + default: + _Base::_M_manager(__dest, __source, __op); + } + return false; + } + + static _Res + _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) + { + return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor), + std::forward<_ArgTypes>(__args)...); + } + + template + static constexpr bool + _S_nothrow_init() noexcept + { + return __and_>::value; + } + }; + + + template<> + class _Function_handler + { + public: + static bool + _M_manager(_Any_data&, const _Any_data&, _Manager_operation) + { return false; } + }; + + + + + + template::value> + struct _Target_handler + : _Function_handler<_Signature, typename remove_cv<_Functor>::type> + { }; + + template + struct _Target_handler<_Signature, _Functor, false> + : _Function_handler + { }; + + + + + + + template + class function<_Res(_ArgTypes...)> + : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, + private _Function_base + { + + + template, function>::value> + using _Decay_t + = typename __enable_if_t>::type; + + template, + typename _Res2 = __invoke_result<_DFunc&, _ArgTypes...>> + struct _Callable + : __is_invocable_impl<_Res2, _Res>::type + { }; + + template + using _Requires = __enable_if_t<_Cond::value, _Tp>; + + template + using _Handler + = _Function_handler<_Res(_ArgTypes...), __decay_t<_Functor>>; + + public: + typedef _Res result_type; + + + + + + + + function() noexcept + : _Function_base() { } + + + + + + function(nullptr_t) noexcept + : _Function_base() { } +# 386 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + function(const function& __x) + : _Function_base() + { + if (static_cast(__x)) + { + __x._M_manager(_M_functor, __x._M_functor, __clone_functor); + _M_invoker = __x._M_invoker; + _M_manager = __x._M_manager; + } + } +# 404 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + function(function&& __x) noexcept + : _Function_base(), _M_invoker(__x._M_invoker) + { + if (static_cast(__x)) + { + _M_functor = __x._M_functor; + _M_manager = __x._M_manager; + __x._M_manager = nullptr; + __x._M_invoker = nullptr; + } + } +# 433 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + template>> + function(_Functor&& __f) + noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>()) + : _Function_base() + { + static_assert(is_copy_constructible<__decay_t<_Functor>>::value, + "std::function target must be copy-constructible"); + static_assert(is_constructible<__decay_t<_Functor>, _Functor>::value, + "std::function target must be constructible from the " + "constructor argument"); + + using _My_handler = _Handler<_Functor>; + + if (_My_handler::_M_not_empty_function(__f)) + { + _My_handler::_M_init_functor(_M_functor, + std::forward<_Functor>(__f)); + _M_invoker = &_My_handler::_M_invoke; + _M_manager = &_My_handler::_M_manager; + } + } +# 468 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + function& + operator=(const function& __x) + { + function(__x).swap(*this); + return *this; + } +# 486 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + function& + operator=(function&& __x) noexcept + { + function(std::move(__x)).swap(*this); + return *this; + } +# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + function& + operator=(nullptr_t) noexcept + { + if (_M_manager) + { + _M_manager(_M_functor, _M_functor, __destroy_functor); + _M_manager = nullptr; + _M_invoker = nullptr; + } + return *this; + } +# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + template + _Requires<_Callable<_Functor>, function&> + operator=(_Functor&& __f) + noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>()) + { + function(std::forward<_Functor>(__f)).swap(*this); + return *this; + } + + + template + function& + operator=(reference_wrapper<_Functor> __f) noexcept + { + function(__f).swap(*this); + return *this; + } +# 556 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + void swap(function& __x) noexcept + { + std::swap(_M_functor, __x._M_functor); + std::swap(_M_manager, __x._M_manager); + std::swap(_M_invoker, __x._M_invoker); + } +# 573 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + explicit operator bool() const noexcept + { return !_M_empty(); } +# 586 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + _Res + operator()(_ArgTypes... __args) const + { + if (_M_empty()) + __throw_bad_function_call(); + return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); + } +# 605 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + const type_info& + target_type() const noexcept + { + if (_M_manager) + { + _Any_data __typeinfo_result; + _M_manager(__typeinfo_result, _M_functor, __get_type_info); + if (auto __ti = __typeinfo_result._M_access()) + return *__ti; + } + return typeid(void); + } +# 630 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + template + _Functor* + target() noexcept + { + const function* __const_this = this; + const _Functor* __func = __const_this->template target<_Functor>(); + + + return *const_cast<_Functor**>(&__func); + } + + template + const _Functor* + target() const noexcept + { + if constexpr (is_object<_Functor>::value) + { + + + using _Handler = _Target_handler<_Res(_ArgTypes...), _Functor>; + + if (_M_manager == &_Handler::_M_manager + + || (_M_manager && typeid(_Functor) == target_type()) + + ) + { + _Any_data __ptr; + _M_manager(__ptr, _M_functor, __get_functor_ptr); + return __ptr._M_access(); + } + } + return nullptr; + } + + + private: + using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); + _Invoker_type _M_invoker = nullptr; + }; + + + template + struct __function_guide_helper + { }; + + template + struct __function_guide_helper< + _Res (_Tp::*) (_Args...) noexcept(_Nx) + > + { using type = _Res(_Args...); }; + + template + struct __function_guide_helper< + _Res (_Tp::*) (_Args...) & noexcept(_Nx) + > + { using type = _Res(_Args...); }; + + template + struct __function_guide_helper< + _Res (_Tp::*) (_Args...) const noexcept(_Nx) + > + { using type = _Res(_Args...); }; + + template + struct __function_guide_helper< + _Res (_Tp::*) (_Args...) const & noexcept(_Nx) + > + { using type = _Res(_Args...); }; +# 715 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + template + using __function_guide_t = typename __function_guide_helper<_Op>::type; + + + template + function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>; + + template> + function(_Fn) -> function<_Signature>; +# 735 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + template + inline bool + operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept + { return !static_cast(__f); } + + + + template + inline bool + operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept + { return !static_cast(__f); } + + + + + + + + template + inline bool + operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept + { return static_cast(__f); } + + + template + inline bool + operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept + { return static_cast(__f); } +# 774 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 + template + inline void + swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept + { __x.swap(__y); } + + + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::true_type + { }; + } + + + +} +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 2 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/unordered_map" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/unordered_map" 3 + + + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 1 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + class _Hashtable; + +namespace __detail +{ + + + + + + template + struct _Hashtable_base; + + + + template + inline typename std::iterator_traits<_Iterator>::difference_type + __distance_fw(_Iterator __first, _Iterator __last, + std::input_iterator_tag) + { return __first != __last ? 1 : 0; } + + template + inline typename std::iterator_traits<_Iterator>::difference_type + __distance_fw(_Iterator __first, _Iterator __last, + std::forward_iterator_tag) + { return std::distance(__first, __last); } + + template + inline typename std::iterator_traits<_Iterator>::difference_type + __distance_fw(_Iterator __first, _Iterator __last) + { return __distance_fw(__first, __last, + std::__iterator_category(__first)); } + + struct _Identity + { + template + _Tp&& + operator()(_Tp&& __x) const noexcept + { return std::forward<_Tp>(__x); } + }; + + struct _Select1st + { + template + struct __1st_type; + + template + struct __1st_type> + { using type = _Tp; }; + + template + struct __1st_type> + { using type = const _Tp; }; + + template + struct __1st_type<_Pair&> + { using type = typename __1st_type<_Pair>::type&; }; + + template + typename __1st_type<_Tp>::type&& + operator()(_Tp&& __x) const noexcept + { return std::forward<_Tp>(__x).first; } + }; + + template + struct _ConvertToValueType; + + template + struct _ConvertToValueType<_Identity, _Value> + { + template + constexpr _Kt&& + operator()(_Kt&& __k) const noexcept + { return std::forward<_Kt>(__k); } + }; + + template + struct _ConvertToValueType<_Select1st, _Value> + { + constexpr _Value&& + operator()(_Value&& __x) const noexcept + { return std::move(__x); } + + constexpr const _Value& + operator()(const _Value& __x) const noexcept + { return __x; } + + template + constexpr std::pair<_Kt, _Val>&& + operator()(std::pair<_Kt, _Val>&& __x) const noexcept + { return std::move(__x); } + + template + constexpr const std::pair<_Kt, _Val>& + operator()(const std::pair<_Kt, _Val>& __x) const noexcept + { return __x; } + }; + + template + struct _NodeBuilder; + + template<> + struct _NodeBuilder<_Select1st> + { + template + static auto + _S_build(_Kt&& __k, _Arg&& __arg, const _NodeGenerator& __node_gen) + -> typename _NodeGenerator::__node_type* + { + return __node_gen(std::forward<_Kt>(__k), + std::forward<_Arg>(__arg).second); + } + }; + + template<> + struct _NodeBuilder<_Identity> + { + template + static auto + _S_build(_Kt&& __k, _Arg&&, const _NodeGenerator& __node_gen) + -> typename _NodeGenerator::__node_type* + { return __node_gen(std::forward<_Kt>(__k)); } + }; + + template + struct _Hashtable_alloc; + + + + template + struct _ReuseOrAllocNode + { + private: + using __node_alloc_type = _NodeAlloc; + using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>; + using __node_alloc_traits = + typename __hashtable_alloc::__node_alloc_traits; + + public: + using __node_type = typename __hashtable_alloc::__node_type; + + _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h) + : _M_nodes(__nodes), _M_h(__h) { } + _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete; + + ~_ReuseOrAllocNode() + { _M_h._M_deallocate_nodes(_M_nodes); } + + template + __node_type* + operator()(_Args&&... __args) const + { + if (_M_nodes) + { + __node_type* __node = _M_nodes; + _M_nodes = _M_nodes->_M_next(); + __node->_M_nxt = nullptr; + auto& __a = _M_h._M_node_allocator(); + __node_alloc_traits::destroy(__a, __node->_M_valptr()); + try + { + __node_alloc_traits::construct(__a, __node->_M_valptr(), + std::forward<_Args>(__args)...); + } + catch(...) + { + _M_h._M_deallocate_node_ptr(__node); + throw; + } + return __node; + } + return _M_h._M_allocate_node(std::forward<_Args>(__args)...); + } + + private: + mutable __node_type* _M_nodes; + __hashtable_alloc& _M_h; + }; + + + + template + struct _AllocNode + { + private: + using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>; + + public: + using __node_type = typename __hashtable_alloc::__node_type; + + _AllocNode(__hashtable_alloc& __h) + : _M_h(__h) { } + + template + __node_type* + operator()(_Args&&... __args) const + { return _M_h._M_allocate_node(std::forward<_Args>(__args)...); } + + private: + __hashtable_alloc& _M_h; + }; +# 279 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 + template + struct _Hashtable_traits + { + using __hash_cached = __bool_constant<_Cache_hash_code>; + using __constant_iterators = __bool_constant<_Constant_iterators>; + using __unique_keys = __bool_constant<_Unique_keys>; + }; + + + + + + + + template + struct _Hashtable_hash_traits + { + static constexpr std::size_t + __small_size_threshold() noexcept + { return std::__is_fast_hash<_Hash>::value ? 0 : 20; } + }; +# 309 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 + struct _Hash_node_base + { + _Hash_node_base* _M_nxt; + + _Hash_node_base() noexcept : _M_nxt() { } + + _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { } + }; + + + + + + + template + struct _Hash_node_value_base + { + typedef _Value value_type; + + __gnu_cxx::__aligned_buffer<_Value> _M_storage; + + _Value* + _M_valptr() noexcept + { return _M_storage._M_ptr(); } + + const _Value* + _M_valptr() const noexcept + { return _M_storage._M_ptr(); } + + _Value& + _M_v() noexcept + { return *_M_valptr(); } + + const _Value& + _M_v() const noexcept + { return *_M_valptr(); } + }; + + + + + template + struct _Hash_node_code_cache + { }; + + + + + template<> + struct _Hash_node_code_cache + { std::size_t _M_hash_code; }; + + template + struct _Hash_node_value + : _Hash_node_value_base<_Value> + , _Hash_node_code_cache<_Cache_hash_code> + { }; + + + + + template + struct _Hash_node + : _Hash_node_base + , _Hash_node_value<_Value, _Cache_hash_code> + { + _Hash_node* + _M_next() const noexcept + { return static_cast<_Hash_node*>(this->_M_nxt); } + }; + + + template + struct _Node_iterator_base + { + using __node_type = _Hash_node<_Value, _Cache_hash_code>; + + __node_type* _M_cur; + + _Node_iterator_base() : _M_cur(nullptr) { } + _Node_iterator_base(__node_type* __p) noexcept + : _M_cur(__p) { } + + void + _M_incr() noexcept + { _M_cur = _M_cur->_M_next(); } + + friend bool + operator==(const _Node_iterator_base& __x, const _Node_iterator_base& __y) + noexcept + { return __x._M_cur == __y._M_cur; } + + + friend bool + operator!=(const _Node_iterator_base& __x, const _Node_iterator_base& __y) + noexcept + { return __x._M_cur != __y._M_cur; } + + }; + + + template + struct _Node_iterator + : public _Node_iterator_base<_Value, __cache> + { + private: + using __base_type = _Node_iterator_base<_Value, __cache>; + using __node_type = typename __base_type::__node_type; + + public: + using value_type = _Value; + using difference_type = std::ptrdiff_t; + using iterator_category = std::forward_iterator_tag; + + using pointer = __conditional_t<__constant_iterators, + const value_type*, value_type*>; + + using reference = __conditional_t<__constant_iterators, + const value_type&, value_type&>; + + _Node_iterator() = default; + + explicit + _Node_iterator(__node_type* __p) noexcept + : __base_type(__p) { } + + reference + operator*() const noexcept + { return this->_M_cur->_M_v(); } + + pointer + operator->() const noexcept + { return this->_M_cur->_M_valptr(); } + + _Node_iterator& + operator++() noexcept + { + this->_M_incr(); + return *this; + } + + _Node_iterator + operator++(int) noexcept + { + _Node_iterator __tmp(*this); + this->_M_incr(); + return __tmp; + } + }; + + + template + struct _Node_const_iterator + : public _Node_iterator_base<_Value, __cache> + { + private: + using __base_type = _Node_iterator_base<_Value, __cache>; + using __node_type = typename __base_type::__node_type; + + public: + typedef _Value value_type; + typedef std::ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + typedef const value_type* pointer; + typedef const value_type& reference; + + _Node_const_iterator() = default; + + explicit + _Node_const_iterator(__node_type* __p) noexcept + : __base_type(__p) { } + + _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators, + __cache>& __x) noexcept + : __base_type(__x._M_cur) { } + + reference + operator*() const noexcept + { return this->_M_cur->_M_v(); } + + pointer + operator->() const noexcept + { return this->_M_cur->_M_valptr(); } + + _Node_const_iterator& + operator++() noexcept + { + this->_M_incr(); + return *this; + } + + _Node_const_iterator + operator++(int) noexcept + { + _Node_const_iterator __tmp(*this); + this->_M_incr(); + return __tmp; + } + }; + + + + + + + struct _Mod_range_hashing + { + typedef std::size_t first_argument_type; + typedef std::size_t second_argument_type; + typedef std::size_t result_type; + + result_type + operator()(first_argument_type __num, + second_argument_type __den) const noexcept + { return __num % __den; } + }; + + + + + + + struct _Default_ranged_hash { }; + + + + struct _Prime_rehash_policy + { + using __has_load_factor = true_type; + + _Prime_rehash_policy(float __z = 1.0) noexcept + : _M_max_load_factor(__z), _M_next_resize(0) { } + + float + max_load_factor() const noexcept + { return _M_max_load_factor; } + + + std::size_t + _M_next_bkt(std::size_t __n) const; + + + std::size_t + _M_bkt_for_elements(std::size_t __n) const + { return __builtin_ceil(__n / (double)_M_max_load_factor); } + + + + + + std::pair + _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, + std::size_t __n_ins) const; + + typedef std::size_t _State; + + _State + _M_state() const + { return _M_next_resize; } + + void + _M_reset() noexcept + { _M_next_resize = 0; } + + void + _M_reset(_State __state) + { _M_next_resize = __state; } + + static const std::size_t _S_growth_factor = 2; + + float _M_max_load_factor; + mutable std::size_t _M_next_resize; + }; + + + struct _Mask_range_hashing + { + typedef std::size_t first_argument_type; + typedef std::size_t second_argument_type; + typedef std::size_t result_type; + + result_type + operator()(first_argument_type __num, + second_argument_type __den) const noexcept + { return __num & (__den - 1); } + }; + + + inline std::size_t + __clp2(std::size_t __n) noexcept + { + using __gnu_cxx::__int_traits; + + if (__n < 2) + return __n; + const unsigned __lz = sizeof(size_t) > sizeof(long) + ? __builtin_clzll(__n - 1ull) + : __builtin_clzl(__n - 1ul); + + return (size_t(1) << (__int_traits::__digits - __lz - 1)) << 1; + } + + + + struct _Power2_rehash_policy + { + using __has_load_factor = true_type; + + _Power2_rehash_policy(float __z = 1.0) noexcept + : _M_max_load_factor(__z), _M_next_resize(0) { } + + float + max_load_factor() const noexcept + { return _M_max_load_factor; } + + + + std::size_t + _M_next_bkt(std::size_t __n) noexcept + { + if (__n == 0) + + + + return 1; + + const auto __max_width = std::min(sizeof(size_t), 8); + const auto __max_bkt = size_t(1) << (__max_width * 8 - 1); + std::size_t __res = __clp2(__n); + + if (__res == 0) + __res = __max_bkt; + else if (__res == 1) + + + + __res = 2; + + if (__res == __max_bkt) + + + + _M_next_resize = size_t(-1); + else + _M_next_resize + = __builtin_floor(__res * (double)_M_max_load_factor); + + return __res; + } + + + std::size_t + _M_bkt_for_elements(std::size_t __n) const noexcept + { return __builtin_ceil(__n / (double)_M_max_load_factor); } + + + + + + std::pair + _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, + std::size_t __n_ins) noexcept + { + if (__n_elt + __n_ins > _M_next_resize) + { + + + + double __min_bkts + = std::max(__n_elt + __n_ins, _M_next_resize ? 0 : 11) + / (double)_M_max_load_factor; + if (__min_bkts >= __n_bkt) + return { true, + _M_next_bkt(std::max(__builtin_floor(__min_bkts) + 1, + __n_bkt * _S_growth_factor)) }; + + _M_next_resize + = __builtin_floor(__n_bkt * (double)_M_max_load_factor); + return { false, 0 }; + } + else + return { false, 0 }; + } + + typedef std::size_t _State; + + _State + _M_state() const noexcept + { return _M_next_resize; } + + void + _M_reset() noexcept + { _M_next_resize = 0; } + + void + _M_reset(_State __state) noexcept + { _M_next_resize = __state; } + + static const std::size_t _S_growth_factor = 2; + + float _M_max_load_factor; + std::size_t _M_next_resize; + }; +# 732 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 + template + struct _Map_base { }; + + + template + struct _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> + { + using mapped_type = _Val; + }; + + + template + struct _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true> + { + private: + using __hashtable_base = _Hashtable_base<_Key, pair, + _Select1st, _Equal, _Hash, + _RangeHash, _Unused, + _Traits>; + + using __hashtable = _Hashtable<_Key, pair, _Alloc, + _Select1st, _Equal, _Hash, _RangeHash, + _Unused, _RehashPolicy, _Traits>; + + using __hash_code = typename __hashtable_base::__hash_code; + + public: + using key_type = typename __hashtable_base::key_type; + using mapped_type = _Val; + + mapped_type& + operator[](const key_type& __k); + + mapped_type& + operator[](key_type&& __k); + + + + mapped_type& + at(const key_type& __k) + { + auto __ite = static_cast<__hashtable*>(this)->find(__k); + if (!__ite._M_cur) + __throw_out_of_range(("unordered_map::at")); + return __ite->second; + } + + const mapped_type& + at(const key_type& __k) const + { + auto __ite = static_cast(this)->find(__k); + if (!__ite._M_cur) + __throw_out_of_range(("unordered_map::at")); + return __ite->second; + } + }; + + template + auto + _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>:: + operator[](const key_type& __k) + -> mapped_type& + { + __hashtable* __h = static_cast<__hashtable*>(this); + __hash_code __code = __h->_M_hash_code(__k); + std::size_t __bkt = __h->_M_bucket_index(__code); + if (auto __node = __h->_M_find_node(__bkt, __k, __code)) + return __node->_M_v().second; + + typename __hashtable::_Scoped_node __node { + __h, + std::piecewise_construct, + std::tuple(__k), + std::tuple<>() + }; + auto __pos + = __h->_M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node = nullptr; + return __pos->second; + } + + template + auto + _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>:: + operator[](key_type&& __k) + -> mapped_type& + { + __hashtable* __h = static_cast<__hashtable*>(this); + __hash_code __code = __h->_M_hash_code(__k); + std::size_t __bkt = __h->_M_bucket_index(__code); + if (auto __node = __h->_M_find_node(__bkt, __k, __code)) + return __node->_M_v().second; + + typename __hashtable::_Scoped_node __node { + __h, + std::piecewise_construct, + std::forward_as_tuple(std::move(__k)), + std::tuple<>() + }; + auto __pos + = __h->_M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node = nullptr; + return __pos->second; + } + + + template + struct _Map_base, + _Alloc, _Select1st, _Equal, _Hash, + _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq> + : _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, _Hash, + _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq> + { }; + + + + + + + template + struct _Insert_base + { + protected: + using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey, + _Equal, _Hash, _RangeHash, + _Unused, _Traits>; + + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, + _Unused, _RehashPolicy, _Traits>; + + using __hash_cached = typename _Traits::__hash_cached; + using __constant_iterators = typename _Traits::__constant_iterators; + + using __hashtable_alloc = _Hashtable_alloc< + __alloc_rebind<_Alloc, _Hash_node<_Value, + __hash_cached::value>>>; + + using value_type = typename __hashtable_base::value_type; + using size_type = typename __hashtable_base::size_type; + + using __unique_keys = typename _Traits::__unique_keys; + using __node_alloc_type = typename __hashtable_alloc::__node_alloc_type; + using __node_gen_type = _AllocNode<__node_alloc_type>; + + __hashtable& + _M_conjure_hashtable() + { return *(static_cast<__hashtable*>(this)); } + + template + void + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter&, true_type __uks); + + template + void + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter&, false_type __uks); + + public: + using iterator = _Node_iterator<_Value, __constant_iterators::value, + __hash_cached::value>; + + using const_iterator = _Node_const_iterator<_Value, + __constant_iterators::value, + __hash_cached::value>; + + using __ireturn_type = __conditional_t<__unique_keys::value, + std::pair, + iterator>; + + __ireturn_type + insert(const value_type& __v) + { + __hashtable& __h = _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__v, __node_gen, __unique_keys{}); + } + + iterator + insert(const_iterator __hint, const value_type& __v) + { + __hashtable& __h = _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, __v, __node_gen, __unique_keys{}); + } + + template + std::pair + try_emplace(const_iterator, _KType&& __k, _Args&&... __args) + { + __hashtable& __h = _M_conjure_hashtable(); + auto __code = __h._M_hash_code(__k); + std::size_t __bkt = __h._M_bucket_index(__code); + if (auto __node = __h._M_find_node(__bkt, __k, __code)) + return { iterator(__node), false }; + + typename __hashtable::_Scoped_node __node { + &__h, + std::piecewise_construct, + std::forward_as_tuple(std::forward<_KType>(__k)), + std::forward_as_tuple(std::forward<_Args>(__args)...) + }; + auto __it + = __h._M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node = nullptr; + return { __it, true }; + } + + void + insert(initializer_list __l) + { this->insert(__l.begin(), __l.end()); } + + template + void + insert(_InputIterator __first, _InputIterator __last) + { + __hashtable& __h = _M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return _M_insert_range(__first, __last, __node_gen, __unique_keys{}); + } + }; + + template + template + void + _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>:: + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter& __node_gen, true_type __uks) + { + __hashtable& __h = _M_conjure_hashtable(); + for (; __first != __last; ++__first) + __h._M_insert(*__first, __node_gen, __uks); + } + + template + template + void + _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>:: + _M_insert_range(_InputIterator __first, _InputIterator __last, + const _NodeGetter& __node_gen, false_type __uks) + { + using __rehash_type = typename __hashtable::__rehash_type; + using __rehash_state = typename __hashtable::__rehash_state; + using pair_type = std::pair; + + size_type __n_elt = __detail::__distance_fw(__first, __last); + if (__n_elt == 0) + return; + + __hashtable& __h = _M_conjure_hashtable(); + __rehash_type& __rehash = __h._M_rehash_policy; + const __rehash_state& __saved_state = __rehash._M_state(); + pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count, + __h._M_element_count, + __n_elt); + + if (__do_rehash.first) + __h._M_rehash(__do_rehash.second, __saved_state); + + for (; __first != __last; ++__first) + __h._M_insert(*__first, __node_gen, __uks); + } + + + + + + + + template + struct _Insert; + + + template + struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits, true> + : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits> + { + using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + using value_type = typename __base_type::value_type; + using iterator = typename __base_type::iterator; + using const_iterator = typename __base_type::const_iterator; + using __ireturn_type = typename __base_type::__ireturn_type; + + using __unique_keys = typename __base_type::__unique_keys; + using __hashtable = typename __base_type::__hashtable; + using __node_gen_type = typename __base_type::__node_gen_type; + + using __base_type::insert; + + __ireturn_type + insert(value_type&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(std::move(__v), __node_gen, __unique_keys{}); + } + + iterator + insert(const_iterator __hint, value_type&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + __node_gen_type __node_gen(__h); + return __h._M_insert(__hint, std::move(__v), __node_gen, + __unique_keys{}); + } + }; + + + template + struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> + : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits> + { + using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + using value_type = typename __base_type::value_type; + using iterator = typename __base_type::iterator; + using const_iterator = typename __base_type::const_iterator; + + using __unique_keys = typename __base_type::__unique_keys; + using __hashtable = typename __base_type::__hashtable; + using __ireturn_type = typename __base_type::__ireturn_type; + + using __base_type::insert; + + template + using __is_cons = std::is_constructible; + + template + using _IFcons = std::enable_if<__is_cons<_Pair>::value>; + + template + using _IFconsp = typename _IFcons<_Pair>::type; + + template> + __ireturn_type + insert(_Pair&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + return __h._M_emplace(__unique_keys{}, std::forward<_Pair>(__v)); + } + + template> + iterator + insert(const_iterator __hint, _Pair&& __v) + { + __hashtable& __h = this->_M_conjure_hashtable(); + return __h._M_emplace(__hint, __unique_keys{}, + std::forward<_Pair>(__v)); + } + }; + + template + using __has_load_factor = typename _Policy::__has_load_factor; + + + + + + + + template> + struct _Rehash_base; + + + template + struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, + false_type > + { + }; + + + template + struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, + true_type > + { + private: + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + public: + float + max_load_factor() const noexcept + { + const __hashtable* __this = static_cast(this); + return __this->__rehash_policy().max_load_factor(); + } + + void + max_load_factor(float __z) + { + __hashtable* __this = static_cast<__hashtable*>(this); + __this->__rehash_policy(_RehashPolicy(__z)); + } + + void + reserve(std::size_t __n) + { + __hashtable* __this = static_cast<__hashtable*>(this); + __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n)); + } + }; + + + + + + + + template + struct _Hashtable_ebo_helper; + + + template + struct _Hashtable_ebo_helper<_Nm, _Tp, true> + : private _Tp + { + _Hashtable_ebo_helper() noexcept(noexcept(_Tp())) : _Tp() { } + + template + _Hashtable_ebo_helper(_OtherTp&& __tp) + : _Tp(std::forward<_OtherTp>(__tp)) + { } + + const _Tp& _M_cget() const { return static_cast(*this); } + _Tp& _M_get() { return static_cast<_Tp&>(*this); } + }; + + + template + struct _Hashtable_ebo_helper<_Nm, _Tp, false> + { + _Hashtable_ebo_helper() = default; + + template + _Hashtable_ebo_helper(_OtherTp&& __tp) + : _M_tp(std::forward<_OtherTp>(__tp)) + { } + + const _Tp& _M_cget() const { return _M_tp; } + _Tp& _M_get() { return _M_tp; } + + private: + _Tp _M_tp{}; + }; + + + + + + + + template + struct _Local_iterator_base; +# 1272 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 + template + struct _Hash_code_base + : private _Hashtable_ebo_helper<1, _Hash> + { + private: + using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>; + + + friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, false>; + + public: + typedef _Hash hasher; + + hasher + hash_function() const + { return _M_hash(); } + + protected: + typedef std::size_t __hash_code; + + + + _Hash_code_base() = default; + + _Hash_code_base(const _Hash& __hash) : __ebo_hash(__hash) { } + + __hash_code + _M_hash_code(const _Key& __k) const + { + static_assert(__is_invocable{}, + "hash function must be invocable with an argument of key type"); + return _M_hash()(__k); + } + + template + __hash_code + _M_hash_code_tr(const _Kt& __k) const + { + static_assert(__is_invocable{}, + "hash function must be invocable with an argument of key type"); + return _M_hash()(__k); + } + + __hash_code + _M_hash_code(const _Hash&, + const _Hash_node_value<_Value, true>& __n) const + { return __n._M_hash_code; } + + + + template + __hash_code + _M_hash_code(const _H2&, + const _Hash_node_value<_Value, __cache_hash_code>& __n) const + { return _M_hash_code(_ExtractKey{}(__n._M_v())); } + + __hash_code + _M_hash_code(const _Hash_node_value<_Value, false>& __n) const + { return _M_hash_code(_ExtractKey{}(__n._M_v())); } + + __hash_code + _M_hash_code(const _Hash_node_value<_Value, true>& __n) const + { return __n._M_hash_code; } + + std::size_t + _M_bucket_index(__hash_code __c, std::size_t __bkt_count) const + { return _RangeHash{}(__c, __bkt_count); } + + std::size_t + _M_bucket_index(const _Hash_node_value<_Value, false>& __n, + std::size_t __bkt_count) const + noexcept( noexcept(declval()(declval())) + && noexcept(declval()((__hash_code)0, + (std::size_t)0)) ) + { + return _RangeHash{}(_M_hash_code(_ExtractKey{}(__n._M_v())), + __bkt_count); + } + + std::size_t + _M_bucket_index(const _Hash_node_value<_Value, true>& __n, + std::size_t __bkt_count) const + noexcept( noexcept(declval()((__hash_code)0, + (std::size_t)0)) ) + { return _RangeHash{}(__n._M_hash_code, __bkt_count); } + + void + _M_store_code(_Hash_node_code_cache&, __hash_code) const + { } + + void + _M_copy_code(_Hash_node_code_cache&, + const _Hash_node_code_cache&) const + { } + + void + _M_store_code(_Hash_node_code_cache& __n, __hash_code __c) const + { __n._M_hash_code = __c; } + + void + _M_copy_code(_Hash_node_code_cache& __to, + const _Hash_node_code_cache& __from) const + { __to._M_hash_code = __from._M_hash_code; } + + void + _M_swap(_Hash_code_base& __x) + { std::swap(__ebo_hash::_M_get(), __x.__ebo_hash::_M_get()); } + + const _Hash& + _M_hash() const { return __ebo_hash::_M_cget(); } + }; + + + template + struct _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, true> + : public _Node_iterator_base<_Value, true> + { + protected: + using __base_node_iter = _Node_iterator_base<_Value, true>; + using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, true>; + + _Local_iterator_base() = default; + _Local_iterator_base(const __hash_code_base&, + _Hash_node<_Value, true>* __p, + std::size_t __bkt, std::size_t __bkt_count) + : __base_node_iter(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) + { } + + void + _M_incr() + { + __base_node_iter::_M_incr(); + if (this->_M_cur) + { + std::size_t __bkt + = _RangeHash{}(this->_M_cur->_M_hash_code, _M_bucket_count); + if (__bkt != _M_bucket) + this->_M_cur = nullptr; + } + } + + std::size_t _M_bucket; + std::size_t _M_bucket_count; + + public: + std::size_t + _M_get_bucket() const { return _M_bucket; } + }; + + + + + + template::value> + struct _Hash_code_storage + { + __gnu_cxx::__aligned_buffer<_Tp> _M_storage; + + _Tp* + _M_h() { return _M_storage._M_ptr(); } + + const _Tp* + _M_h() const { return _M_storage._M_ptr(); } + }; + + + template + struct _Hash_code_storage<_Tp, true> + { + static_assert( std::is_empty<_Tp>::value, "Type must be empty" ); + + + + _Tp* + _M_h() { return reinterpret_cast<_Tp*>(this); } + + const _Tp* + _M_h() const { return reinterpret_cast(this); } + }; + + template + using __hash_code_for_local_iter + = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, false>>; + + + template + struct _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, false> + : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _Hash, _RangeHash, + _Unused> + , _Node_iterator_base<_Value, false> + { + protected: + using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, false>; + using __node_iter_base = _Node_iterator_base<_Value, false>; + + _Local_iterator_base() : _M_bucket_count(-1) { } + + _Local_iterator_base(const __hash_code_base& __base, + _Hash_node<_Value, false>* __p, + std::size_t __bkt, std::size_t __bkt_count) + : __node_iter_base(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) + { _M_init(__base); } + + ~_Local_iterator_base() + { + if (_M_bucket_count != size_t(-1)) + _M_destroy(); + } + + _Local_iterator_base(const _Local_iterator_base& __iter) + : __node_iter_base(__iter._M_cur), _M_bucket(__iter._M_bucket) + , _M_bucket_count(__iter._M_bucket_count) + { + if (_M_bucket_count != size_t(-1)) + _M_init(*__iter._M_h()); + } + + _Local_iterator_base& + operator=(const _Local_iterator_base& __iter) + { + if (_M_bucket_count != -1) + _M_destroy(); + this->_M_cur = __iter._M_cur; + _M_bucket = __iter._M_bucket; + _M_bucket_count = __iter._M_bucket_count; + if (_M_bucket_count != -1) + _M_init(*__iter._M_h()); + return *this; + } + + void + _M_incr() + { + __node_iter_base::_M_incr(); + if (this->_M_cur) + { + std::size_t __bkt = this->_M_h()->_M_bucket_index(*this->_M_cur, + _M_bucket_count); + if (__bkt != _M_bucket) + this->_M_cur = nullptr; + } + } + + std::size_t _M_bucket; + std::size_t _M_bucket_count; + + void + _M_init(const __hash_code_base& __base) + { ::new(this->_M_h()) __hash_code_base(__base); } + + void + _M_destroy() { this->_M_h()->~__hash_code_base(); } + + public: + std::size_t + _M_get_bucket() const { return _M_bucket; } + }; + + + template + struct _Local_iterator + : public _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, __cache> + { + private: + using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, __cache>; + using __hash_code_base = typename __base_type::__hash_code_base; + + public: + using value_type = _Value; + using pointer = __conditional_t<__constant_iterators, + const value_type*, value_type*>; + using reference = __conditional_t<__constant_iterators, + const value_type&, value_type&>; + using difference_type = ptrdiff_t; + using iterator_category = forward_iterator_tag; + + _Local_iterator() = default; + + _Local_iterator(const __hash_code_base& __base, + _Hash_node<_Value, __cache>* __n, + std::size_t __bkt, std::size_t __bkt_count) + : __base_type(__base, __n, __bkt, __bkt_count) + { } + + reference + operator*() const + { return this->_M_cur->_M_v(); } + + pointer + operator->() const + { return this->_M_cur->_M_valptr(); } + + _Local_iterator& + operator++() + { + this->_M_incr(); + return *this; + } + + _Local_iterator + operator++(int) + { + _Local_iterator __tmp(*this); + this->_M_incr(); + return __tmp; + } + }; + + + template + struct _Local_const_iterator + : public _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, __cache> + { + private: + using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, __cache>; + using __hash_code_base = typename __base_type::__hash_code_base; + + public: + typedef _Value value_type; + typedef const value_type* pointer; + typedef const value_type& reference; + typedef std::ptrdiff_t difference_type; + typedef std::forward_iterator_tag iterator_category; + + _Local_const_iterator() = default; + + _Local_const_iterator(const __hash_code_base& __base, + _Hash_node<_Value, __cache>* __n, + std::size_t __bkt, std::size_t __bkt_count) + : __base_type(__base, __n, __bkt, __bkt_count) + { } + + _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, + __constant_iterators, + __cache>& __x) + : __base_type(__x) + { } + + reference + operator*() const + { return this->_M_cur->_M_v(); } + + pointer + operator->() const + { return this->_M_cur->_M_valptr(); } + + _Local_const_iterator& + operator++() + { + this->_M_incr(); + return *this; + } + + _Local_const_iterator + operator++(int) + { + _Local_const_iterator __tmp(*this); + this->_M_incr(); + return __tmp; + } + }; +# 1664 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 + template + struct _Hashtable_base + : public _Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, + _Unused, _Traits::__hash_cached::value>, + private _Hashtable_ebo_helper<0, _Equal> + { + public: + typedef _Key key_type; + typedef _Value value_type; + typedef _Equal key_equal; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + using __traits_type = _Traits; + using __hash_cached = typename __traits_type::__hash_cached; + + using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, + _Hash, _RangeHash, _Unused, + __hash_cached::value>; + + using __hash_code = typename __hash_code_base::__hash_code; + + private: + using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>; + + static bool + _S_equals(__hash_code, const _Hash_node_code_cache&) + { return true; } + + static bool + _S_node_equals(const _Hash_node_code_cache&, + const _Hash_node_code_cache&) + { return true; } + + static bool + _S_equals(__hash_code __c, const _Hash_node_code_cache& __n) + { return __c == __n._M_hash_code; } + + static bool + _S_node_equals(const _Hash_node_code_cache& __lhn, + const _Hash_node_code_cache& __rhn) + { return __lhn._M_hash_code == __rhn._M_hash_code; } + + protected: + _Hashtable_base() = default; + + _Hashtable_base(const _Hash& __hash, const _Equal& __eq) + : __hash_code_base(__hash), _EqualEBO(__eq) + { } + + bool + _M_key_equals(const _Key& __k, + const _Hash_node_value<_Value, + __hash_cached::value>& __n) const + { + static_assert(__is_invocable{}, + "key equality predicate must be invocable with two arguments of " + "key type"); + return _M_eq()(__k, _ExtractKey{}(__n._M_v())); + } + + template + bool + _M_key_equals_tr(const _Kt& __k, + const _Hash_node_value<_Value, + __hash_cached::value>& __n) const + { + static_assert( + __is_invocable{}, + "key equality predicate must be invocable with two arguments of " + "key type"); + return _M_eq()(__k, _ExtractKey{}(__n._M_v())); + } + + bool + _M_equals(const _Key& __k, __hash_code __c, + const _Hash_node_value<_Value, __hash_cached::value>& __n) const + { return _S_equals(__c, __n) && _M_key_equals(__k, __n); } + + template + bool + _M_equals_tr(const _Kt& __k, __hash_code __c, + const _Hash_node_value<_Value, + __hash_cached::value>& __n) const + { return _S_equals(__c, __n) && _M_key_equals_tr(__k, __n); } + + bool + _M_node_equals( + const _Hash_node_value<_Value, __hash_cached::value>& __lhn, + const _Hash_node_value<_Value, __hash_cached::value>& __rhn) const + { + return _S_node_equals(__lhn, __rhn) + && _M_key_equals(_ExtractKey{}(__lhn._M_v()), __rhn); + } + + void + _M_swap(_Hashtable_base& __x) + { + __hash_code_base::_M_swap(__x); + std::swap(_EqualEBO::_M_get(), __x._EqualEBO::_M_get()); + } + + const _Equal& + _M_eq() const { return _EqualEBO::_M_cget(); } + }; +# 1780 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 + template + struct _Equality; + + + template + struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true> + { + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + bool + _M_equal(const __hashtable&) const; + }; + + template + bool + _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>:: + _M_equal(const __hashtable& __other) const + { + using __node_type = typename __hashtable::__node_type; + const __hashtable* __this = static_cast(this); + if (__this->size() != __other.size()) + return false; + + for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx) + { + std::size_t __ybkt = __other._M_bucket_index(*__itx._M_cur); + auto __prev_n = __other._M_buckets[__ybkt]; + if (!__prev_n) + return false; + + for (__node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);; + __n = __n->_M_next()) + { + if (__n->_M_v() == *__itx) + break; + + if (!__n->_M_nxt + || __other._M_bucket_index(*__n->_M_next()) != __ybkt) + return false; + } + } + + return true; + } + + + template + struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> + { + using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + bool + _M_equal(const __hashtable&) const; + }; + + template + bool + _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false>:: + _M_equal(const __hashtable& __other) const + { + using __node_type = typename __hashtable::__node_type; + const __hashtable* __this = static_cast(this); + if (__this->size() != __other.size()) + return false; + + for (auto __itx = __this->begin(); __itx != __this->end();) + { + std::size_t __x_count = 1; + auto __itx_end = __itx; + for (++__itx_end; __itx_end != __this->end() + && __this->key_eq()(_ExtractKey{}(*__itx), + _ExtractKey{}(*__itx_end)); + ++__itx_end) + ++__x_count; + + std::size_t __ybkt = __other._M_bucket_index(*__itx._M_cur); + auto __y_prev_n = __other._M_buckets[__ybkt]; + if (!__y_prev_n) + return false; + + __node_type* __y_n = static_cast<__node_type*>(__y_prev_n->_M_nxt); + for (;;) + { + if (__this->key_eq()(_ExtractKey{}(__y_n->_M_v()), + _ExtractKey{}(*__itx))) + break; + + auto __y_ref_n = __y_n; + for (__y_n = __y_n->_M_next(); __y_n; __y_n = __y_n->_M_next()) + if (!__other._M_node_equals(*__y_ref_n, *__y_n)) + break; + + if (!__y_n || __other._M_bucket_index(*__y_n) != __ybkt) + return false; + } + + typename __hashtable::const_iterator __ity(__y_n); + for (auto __ity_end = __ity; __ity_end != __other.end(); ++__ity_end) + if (--__x_count == 0) + break; + + if (__x_count != 0) + return false; + + if (!std::is_permutation(__itx, __itx_end, __ity)) + return false; + + __itx = __itx_end; + } + return true; + } + + + + + + template + struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc> + { + private: + using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>; + + template + struct __get_value_type; + template + struct __get_value_type<_Hash_node<_Val, _Cache_hash_code>> + { using type = _Val; }; + + public: + using __node_type = typename _NodeAlloc::value_type; + using __node_alloc_type = _NodeAlloc; + + using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>; + + using __value_alloc_traits = typename __node_alloc_traits::template + rebind_traits::type>; + + using __node_ptr = __node_type*; + using __node_base = _Hash_node_base; + using __node_base_ptr = __node_base*; + using __buckets_alloc_type = + __alloc_rebind<__node_alloc_type, __node_base_ptr>; + using __buckets_alloc_traits = std::allocator_traits<__buckets_alloc_type>; + using __buckets_ptr = __node_base_ptr*; + + _Hashtable_alloc() = default; + _Hashtable_alloc(const _Hashtable_alloc&) = default; + _Hashtable_alloc(_Hashtable_alloc&&) = default; + + template + _Hashtable_alloc(_Alloc&& __a) + : __ebo_node_alloc(std::forward<_Alloc>(__a)) + { } + + __node_alloc_type& + _M_node_allocator() + { return __ebo_node_alloc::_M_get(); } + + const __node_alloc_type& + _M_node_allocator() const + { return __ebo_node_alloc::_M_cget(); } + + + template + __node_ptr + _M_allocate_node(_Args&&... __args); + + + void + _M_deallocate_node(__node_ptr __n); + + + void + _M_deallocate_node_ptr(__node_ptr __n); + + + + void + _M_deallocate_nodes(__node_ptr __n); + + __buckets_ptr + _M_allocate_buckets(std::size_t __bkt_count); + + void + _M_deallocate_buckets(__buckets_ptr, std::size_t __bkt_count); + }; + + + + template + template + auto + _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args) + -> __node_ptr + { + auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1); + __node_ptr __n = std::__to_address(__nptr); + try + { + ::new ((void*)__n) __node_type; + __node_alloc_traits::construct(_M_node_allocator(), + __n->_M_valptr(), + std::forward<_Args>(__args)...); + return __n; + } + catch(...) + { + __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1); + throw; + } + } + + template + void + _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_ptr __n) + { + __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr()); + _M_deallocate_node_ptr(__n); + } + + template + void + _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node_ptr(__node_ptr __n) + { + typedef typename __node_alloc_traits::pointer _Ptr; + auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n); + __n->~__node_type(); + __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1); + } + + template + void + _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_ptr __n) + { + while (__n) + { + __node_ptr __tmp = __n; + __n = __n->_M_next(); + _M_deallocate_node(__tmp); + } + } + + template + auto + _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __bkt_count) + -> __buckets_ptr + { + __buckets_alloc_type __alloc(_M_node_allocator()); + + auto __ptr = __buckets_alloc_traits::allocate(__alloc, __bkt_count); + __buckets_ptr __p = std::__to_address(__ptr); + __builtin_memset(__p, 0, __bkt_count * sizeof(__node_base_ptr)); + return __p; + } + + template + void + _Hashtable_alloc<_NodeAlloc>:: + _M_deallocate_buckets(__buckets_ptr __bkts, + std::size_t __bkt_count) + { + typedef typename __buckets_alloc_traits::pointer _Ptr; + auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts); + __buckets_alloc_type __alloc(_M_node_allocator()); + __buckets_alloc_traits::deallocate(__alloc, __ptr, __bkt_count); + } + + +} + + +} +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/enable_special_members.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/enable_special_members.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + struct _Enable_default_constructor_tag + { + explicit constexpr _Enable_default_constructor_tag() = default; + }; + + + + + + +template + struct _Enable_default_constructor + { + constexpr _Enable_default_constructor() noexcept = default; + constexpr _Enable_default_constructor(_Enable_default_constructor const&) + noexcept = default; + constexpr _Enable_default_constructor(_Enable_default_constructor&&) + noexcept = default; + _Enable_default_constructor& + operator=(_Enable_default_constructor const&) noexcept = default; + _Enable_default_constructor& + operator=(_Enable_default_constructor&&) noexcept = default; + + + constexpr explicit + _Enable_default_constructor(_Enable_default_constructor_tag) { } + }; + + + + + + + +template + struct _Enable_destructor { }; + + + + + + +template + struct _Enable_copy_move { }; +# 96 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/enable_special_members.h" 3 +template + struct _Enable_special_members + : private _Enable_default_constructor<_Default, _Tag>, + private _Enable_destructor<_Destructor, _Tag>, + private _Enable_copy_move<_Copy, _CopyAssignment, + _Move, _MoveAssignment, + _Tag> + { }; + + + +template + struct _Enable_default_constructor + { + constexpr _Enable_default_constructor() noexcept = delete; + constexpr _Enable_default_constructor(_Enable_default_constructor const&) + noexcept = default; + constexpr _Enable_default_constructor(_Enable_default_constructor&&) + noexcept = default; + _Enable_default_constructor& + operator=(_Enable_default_constructor const&) noexcept = default; + _Enable_default_constructor& + operator=(_Enable_default_constructor&&) noexcept = default; + + + constexpr explicit + _Enable_default_constructor(_Enable_default_constructor_tag) { } + }; + +template + struct _Enable_destructor + { ~_Enable_destructor() noexcept = delete; }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = default; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = default; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + +template + struct _Enable_copy_move + { + constexpr _Enable_copy_move() noexcept = default; + constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; + constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move const&) noexcept = delete; + _Enable_copy_move& + operator=(_Enable_copy_move&&) noexcept = delete; + }; + + + +} +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/node_handle.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/node_handle.h" 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/node_handle.h" 3 + template + class _Node_handle_common + { + using _AllocTraits = allocator_traits<_NodeAlloc>; + + public: + using allocator_type = __alloc_rebind<_NodeAlloc, _Val>; + + allocator_type + get_allocator() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __builtin_unreachable(); } while (false); + return allocator_type(_M_alloc._M_alloc); + } + + explicit operator bool() const noexcept { return _M_ptr != nullptr; } + + [[nodiscard]] bool empty() const noexcept { return _M_ptr == nullptr; } + + + protected: + constexpr _Node_handle_common() noexcept : _M_ptr() { } + + ~_Node_handle_common() + { + if (!empty()) + _M_reset(); + } + + _Node_handle_common(_Node_handle_common&& __nh) noexcept + : _M_ptr(__nh._M_ptr) + { + if (_M_ptr) + _M_move(std::move(__nh)); + } + + _Node_handle_common& + operator=(_Node_handle_common&& __nh) noexcept + { + if (empty()) + { + if (!__nh.empty()) + _M_move(std::move(__nh)); + } + else if (__nh.empty()) + _M_reset(); + else + { + + _AllocTraits::destroy(*_M_alloc, _M_ptr->_M_valptr()); + _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1); + + _M_alloc = __nh._M_alloc.release(); + _M_ptr = __nh._M_ptr; + __nh._M_ptr = nullptr; + } + return *this; + } + + _Node_handle_common(typename _AllocTraits::pointer __ptr, + const _NodeAlloc& __alloc) + : _M_ptr(__ptr), _M_alloc(__alloc) + { + do { if (std::__is_constant_evaluated() && !bool(__ptr != nullptr)) __builtin_unreachable(); } while (false); + } + + void + _M_swap(_Node_handle_common& __nh) noexcept + { + if (empty()) + { + if (!__nh.empty()) + _M_move(std::move(__nh)); + } + else if (__nh.empty()) + __nh._M_move(std::move(*this)); + else + { + using std::swap; + swap(_M_ptr, __nh._M_ptr); + _M_alloc.swap(__nh._M_alloc); + } + } + + private: + + + + void + _M_move(_Node_handle_common&& __nh) noexcept + { + ::new (std::__addressof(_M_alloc)) _NodeAlloc(__nh._M_alloc.release()); + _M_ptr = __nh._M_ptr; + __nh._M_ptr = nullptr; + } + + + + + void + _M_reset() noexcept + { + _NodeAlloc __alloc = _M_alloc.release(); + _AllocTraits::destroy(__alloc, _M_ptr->_M_valptr()); + _AllocTraits::deallocate(__alloc, _M_ptr, 1); + _M_ptr = nullptr; + } + + protected: + typename _AllocTraits::pointer _M_ptr; + + private: + + + union _Optional_alloc + { + _Optional_alloc() { } + ~_Optional_alloc() { } + + _Optional_alloc(_Optional_alloc&&) = delete; + _Optional_alloc& operator=(_Optional_alloc&&) = delete; + + _Optional_alloc(const _NodeAlloc& __alloc) noexcept + : _M_alloc(__alloc) + { } + + + void + operator=(_NodeAlloc&& __alloc) noexcept + { + using _ATr = _AllocTraits; + if constexpr (_ATr::propagate_on_container_move_assignment::value) + _M_alloc = std::move(__alloc); + else if constexpr (!_AllocTraits::is_always_equal::value) + do { if (std::__is_constant_evaluated() && !bool(_M_alloc == __alloc)) __builtin_unreachable(); } while (false); + } + + + void + swap(_Optional_alloc& __other) noexcept + { + using std::swap; + if constexpr (_AllocTraits::propagate_on_container_swap::value) + swap(_M_alloc, __other._M_alloc); + else if constexpr (!_AllocTraits::is_always_equal::value) + do { if (std::__is_constant_evaluated() && !bool(_M_alloc == __other._M_alloc)) __builtin_unreachable(); } while (false); + } + + + _NodeAlloc& operator*() noexcept { return _M_alloc; } + + + _NodeAlloc release() noexcept + { + _NodeAlloc __tmp = std::move(_M_alloc); + _M_alloc.~_NodeAlloc(); + return __tmp; + } + + struct _Empty { }; + + [[__no_unique_address__]] _Empty _M_empty; + [[__no_unique_address__]] _NodeAlloc _M_alloc; + }; + + [[__no_unique_address__]] _Optional_alloc _M_alloc; + + template + friend class _Rb_tree; + + + }; + + + template + class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc> + { + public: + constexpr _Node_handle() noexcept = default; + ~_Node_handle() = default; + _Node_handle(_Node_handle&&) noexcept = default; + + _Node_handle& + operator=(_Node_handle&&) noexcept = default; + + using key_type = _Key; + using mapped_type = typename _Value::second_type; + + key_type& + key() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __builtin_unreachable(); } while (false); + return *_M_pkey; + } + + mapped_type& + mapped() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __builtin_unreachable(); } while (false); + return *_M_pmapped; + } + + void + swap(_Node_handle& __nh) noexcept + { + this->_M_swap(__nh); + using std::swap; + swap(_M_pkey, __nh._M_pkey); + swap(_M_pmapped, __nh._M_pmapped); + } + + friend void + swap(_Node_handle& __x, _Node_handle& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + private: + using _AllocTraits = allocator_traits<_NodeAlloc>; + + _Node_handle(typename _AllocTraits::pointer __ptr, + const _NodeAlloc& __alloc) + : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) + { + if (__ptr) + { + auto& __key = const_cast<_Key&>(__ptr->_M_valptr()->first); + _M_pkey = _S_pointer_to(__key); + _M_pmapped = _S_pointer_to(__ptr->_M_valptr()->second); + } + else + { + _M_pkey = nullptr; + _M_pmapped = nullptr; + } + } + + template + using __pointer + = __ptr_rebind>; + + __pointer<_Key> _M_pkey = nullptr; + __pointer _M_pmapped = nullptr; + + template + __pointer<_Tp> + _S_pointer_to(_Tp& __obj) + { return pointer_traits<__pointer<_Tp>>::pointer_to(__obj); } + + const key_type& + _M_key() const noexcept { return key(); } + + template + friend class _Rb_tree; + + template + friend class _Hashtable; + }; + + + template + class _Node_handle<_Value, _Value, _NodeAlloc> + : public _Node_handle_common<_Value, _NodeAlloc> + { + public: + constexpr _Node_handle() noexcept = default; + ~_Node_handle() = default; + _Node_handle(_Node_handle&&) noexcept = default; + + _Node_handle& + operator=(_Node_handle&&) noexcept = default; + + using value_type = _Value; + + value_type& + value() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __builtin_unreachable(); } while (false); + return *this->_M_ptr->_M_valptr(); + } + + void + swap(_Node_handle& __nh) noexcept + { this->_M_swap(__nh); } + + friend void + swap(_Node_handle& __x, _Node_handle& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + private: + using _AllocTraits = allocator_traits<_NodeAlloc>; + + _Node_handle(typename _AllocTraits::pointer __ptr, + const _NodeAlloc& __alloc) + : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { } + + const value_type& + _M_key() const noexcept { return value(); } + + template + friend class _Rb_tree; + + template + friend class _Hashtable; + }; + + + template + struct _Node_insert_return + { + _Iterator position = _Iterator(); + bool inserted = false; + _NodeHandle node; + }; + + + + +} +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + using __cache_default + = __not_<__and_< + __is_fast_hash<_Hash>, + + __is_nothrow_invocable>>; + + + + + template + using _Hashtable_enable_default_ctor + = _Enable_default_constructor<__and_, + is_default_constructible<_Hash>, + is_default_constructible<_Allocator>>{}, + __detail::_Hash_node_base>; +# 177 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 + template + class _Hashtable + : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _Traits>, + public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>, + public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>, + public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>, + public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>, + private __detail::_Hashtable_alloc< + __alloc_rebind<_Alloc, + __detail::_Hash_node<_Value, + _Traits::__hash_cached::value>>>, + private _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc> + { + static_assert(is_same::type, _Value>::value, + "unordered container must have a non-const, non-volatile value_type"); + + static_assert(is_same{}, + "unordered container must have the same value_type as its allocator"); + + + using __traits_type = _Traits; + using __hash_cached = typename __traits_type::__hash_cached; + using __constant_iterators = typename __traits_type::__constant_iterators; + using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>; + using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>; + + using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>; + + using __node_value_type = + __detail::_Hash_node_value<_Value, __hash_cached::value>; + using __node_ptr = typename __hashtable_alloc::__node_ptr; + using __value_alloc_traits = + typename __hashtable_alloc::__value_alloc_traits; + using __node_alloc_traits = + typename __hashtable_alloc::__node_alloc_traits; + using __node_base = typename __hashtable_alloc::__node_base; + using __node_base_ptr = typename __hashtable_alloc::__node_base_ptr; + using __buckets_ptr = typename __hashtable_alloc::__buckets_ptr; + + using __insert_base = __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _Hash, + _RangeHash, _Unused, + _RehashPolicy, _Traits>; + using __enable_default_ctor + = _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc>; + + public: + typedef _Key key_type; + typedef _Value value_type; + typedef _Alloc allocator_type; + typedef _Equal key_equal; + + + + typedef typename __value_alloc_traits::pointer pointer; + typedef typename __value_alloc_traits::const_pointer const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + + using iterator = typename __insert_base::iterator; + + using const_iterator = typename __insert_base::const_iterator; + + using local_iterator = __detail::_Local_iterator; + + using const_local_iterator = __detail::_Local_const_iterator< + key_type, _Value, + _ExtractKey, _Hash, _RangeHash, _Unused, + __constant_iterators::value, __hash_cached::value>; + + private: + using __rehash_type = _RehashPolicy; + using __rehash_state = typename __rehash_type::_State; + + using __unique_keys = typename __traits_type::__unique_keys; + + using __hashtable_base = __detail:: + _Hashtable_base<_Key, _Value, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, _Traits>; + + using __hash_code_base = typename __hashtable_base::__hash_code_base; + using __hash_code = typename __hashtable_base::__hash_code; + using __ireturn_type = typename __insert_base::__ireturn_type; + + using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc, + _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, + _Equal, _Hash, _RangeHash, _Unused, + _RehashPolicy, _Traits>; + + using __reuse_or_alloc_node_gen_t = + __detail::_ReuseOrAllocNode<__node_alloc_type>; + using __alloc_node_gen_t = + __detail::_AllocNode<__node_alloc_type>; + using __node_builder_t = + __detail::_NodeBuilder<_ExtractKey>; + + + struct _Scoped_node + { + + _Scoped_node(__node_ptr __n, __hashtable_alloc* __h) + : _M_h(__h), _M_node(__n) { } + + + template + _Scoped_node(__hashtable_alloc* __h, _Args&&... __args) + : _M_h(__h), + _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...)) + { } + + + ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); }; + + _Scoped_node(const _Scoped_node&) = delete; + _Scoped_node& operator=(const _Scoped_node&) = delete; + + __hashtable_alloc* _M_h; + __node_ptr _M_node; + }; + + template + static constexpr + __conditional_t::value, + const value_type&, value_type&&> + __fwd_value_for(value_type& __val) noexcept + { return std::move(__val); } + + + + + + struct __hash_code_base_access : __hash_code_base + { using __hash_code_base::_M_bucket_index; }; + + + static_assert(is_nothrow_default_constructible<_RangeHash>::value, + "Functor used to map hash code to bucket index" + " must be nothrow default constructible"); + static_assert(noexcept( + std::declval()((std::size_t)0, (std::size_t)0)), + "Functor used to map hash code to bucket index must be" + " noexcept"); + + + static_assert(is_nothrow_default_constructible<_ExtractKey>::value, + "_ExtractKey must be nothrow default constructible"); + static_assert(noexcept( + std::declval()(std::declval<_Value>())), + "_ExtractKey functor must be noexcept invocable"); + + template + friend struct __detail::_Map_base; + + template + friend struct __detail::_Insert_base; + + template + friend struct __detail::_Insert; + + template + friend struct __detail::_Equality; + + public: + using size_type = typename __hashtable_base::size_type; + using difference_type = typename __hashtable_base::difference_type; + + + using node_type = _Node_handle<_Key, _Value, __node_alloc_type>; + using insert_return_type = _Node_insert_return; + + + private: + __buckets_ptr _M_buckets = &_M_single_bucket; + size_type _M_bucket_count = 1; + __node_base _M_before_begin; + size_type _M_element_count = 0; + _RehashPolicy _M_rehash_policy; + + + + + + + + __node_base_ptr _M_single_bucket = nullptr; + + void + _M_update_bbegin() + { + if (_M_begin()) + _M_buckets[_M_bucket_index(*_M_begin())] = &_M_before_begin; + } + + void + _M_update_bbegin(__node_ptr __n) + { + _M_before_begin._M_nxt = __n; + _M_update_bbegin(); + } + + bool + _M_uses_single_bucket(__buckets_ptr __bkts) const + { return __builtin_expect(__bkts == &_M_single_bucket, false); } + + bool + _M_uses_single_bucket() const + { return _M_uses_single_bucket(_M_buckets); } + + static constexpr size_t + __small_size_threshold() noexcept + { + return + __detail::_Hashtable_hash_traits<_Hash>::__small_size_threshold(); + } + + __hashtable_alloc& + _M_base_alloc() { return *this; } + + __buckets_ptr + _M_allocate_buckets(size_type __bkt_count) + { + if (__builtin_expect(__bkt_count == 1, false)) + { + _M_single_bucket = nullptr; + return &_M_single_bucket; + } + + return __hashtable_alloc::_M_allocate_buckets(__bkt_count); + } + + void + _M_deallocate_buckets(__buckets_ptr __bkts, size_type __bkt_count) + { + if (_M_uses_single_bucket(__bkts)) + return; + + __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count); + } + + void + _M_deallocate_buckets() + { _M_deallocate_buckets(_M_buckets, _M_bucket_count); } + + + + __node_ptr + _M_bucket_begin(size_type __bkt) const; + + __node_ptr + _M_begin() const + { return static_cast<__node_ptr>(_M_before_begin._M_nxt); } + + + + template + void + _M_assign_elements(_Ht&&); + + template + void + _M_assign(_Ht&&, const _NodeGenerator&); + + void + _M_move_assign(_Hashtable&&, true_type); + + void + _M_move_assign(_Hashtable&&, false_type); + + void + _M_reset() noexcept; + + _Hashtable(const _Hash& __h, const _Equal& __eq, + const allocator_type& __a) + : __hashtable_base(__h, __eq), + __hashtable_alloc(__node_alloc_type(__a)), + __enable_default_ctor(_Enable_default_constructor_tag{}) + { } + + template + static constexpr bool + _S_nothrow_move() + { + + + + + + if constexpr (_No_realloc) + if constexpr (is_nothrow_copy_constructible<_Hash>()) + return is_nothrow_copy_constructible<_Equal>(); + return false; + + } + + _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, + true_type ) + noexcept(_S_nothrow_move()); + + _Hashtable(_Hashtable&&, __node_alloc_type&&, + false_type ); + + template + _Hashtable(_InputIterator __first, _InputIterator __last, + size_type __bkt_count_hint, + const _Hash&, const _Equal&, const allocator_type&, + true_type __uks); + + template + _Hashtable(_InputIterator __first, _InputIterator __last, + size_type __bkt_count_hint, + const _Hash&, const _Equal&, const allocator_type&, + false_type __uks); + + public: + + _Hashtable() = default; + + _Hashtable(const _Hashtable&); + + _Hashtable(const _Hashtable&, const allocator_type&); + + explicit + _Hashtable(size_type __bkt_count_hint, + const _Hash& __hf = _Hash(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()); + + + _Hashtable(_Hashtable&& __ht) + noexcept(_S_nothrow_move()) + : _Hashtable(std::move(__ht), std::move(__ht._M_node_allocator()), + true_type{}) + { } + + _Hashtable(_Hashtable&& __ht, const allocator_type& __a) + noexcept(_S_nothrow_move<__node_alloc_traits::_S_always_equal()>()) + : _Hashtable(std::move(__ht), __node_alloc_type(__a), + typename __node_alloc_traits::is_always_equal{}) + { } + + explicit + _Hashtable(const allocator_type& __a) + : __hashtable_alloc(__node_alloc_type(__a)), + __enable_default_ctor(_Enable_default_constructor_tag{}) + { } + + template + _Hashtable(_InputIterator __f, _InputIterator __l, + size_type __bkt_count_hint = 0, + const _Hash& __hf = _Hash(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Hashtable(__f, __l, __bkt_count_hint, __hf, __eql, __a, + __unique_keys{}) + { } + + _Hashtable(initializer_list __l, + size_type __bkt_count_hint = 0, + const _Hash& __hf = _Hash(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint, + __hf, __eql, __a, __unique_keys{}) + { } + + _Hashtable& + operator=(const _Hashtable& __ht); + + _Hashtable& + operator=(_Hashtable&& __ht) + noexcept(__node_alloc_traits::_S_nothrow_move() + && is_nothrow_move_assignable<_Hash>::value + && is_nothrow_move_assignable<_Equal>::value) + { + constexpr bool __move_storage = + __node_alloc_traits::_S_propagate_on_move_assign() + || __node_alloc_traits::_S_always_equal(); + _M_move_assign(std::move(__ht), __bool_constant<__move_storage>()); + return *this; + } + + _Hashtable& + operator=(initializer_list __l) + { + __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); + _M_before_begin._M_nxt = nullptr; + clear(); + + + auto __l_bkt_count = _M_rehash_policy._M_bkt_for_elements(__l.size()); + + + if (_M_bucket_count < __l_bkt_count) + rehash(__l_bkt_count); + + this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys{}); + return *this; + } + + ~_Hashtable() noexcept; + + void + swap(_Hashtable&) + noexcept(__and_<__is_nothrow_swappable<_Hash>, + __is_nothrow_swappable<_Equal>>::value); + + + iterator + begin() noexcept + { return iterator(_M_begin()); } + + const_iterator + begin() const noexcept + { return const_iterator(_M_begin()); } + + iterator + end() noexcept + { return iterator(nullptr); } + + const_iterator + end() const noexcept + { return const_iterator(nullptr); } + + const_iterator + cbegin() const noexcept + { return const_iterator(_M_begin()); } + + const_iterator + cend() const noexcept + { return const_iterator(nullptr); } + + size_type + size() const noexcept + { return _M_element_count; } + + [[__nodiscard__]] bool + empty() const noexcept + { return size() == 0; } + + allocator_type + get_allocator() const noexcept + { return allocator_type(this->_M_node_allocator()); } + + size_type + max_size() const noexcept + { return __node_alloc_traits::max_size(this->_M_node_allocator()); } + + + key_equal + key_eq() const + { return this->_M_eq(); } + + + + + size_type + bucket_count() const noexcept + { return _M_bucket_count; } + + size_type + max_bucket_count() const noexcept + { return max_size(); } + + size_type + bucket_size(size_type __bkt) const + { return std::distance(begin(__bkt), end(__bkt)); } + + size_type + bucket(const key_type& __k) const + { return _M_bucket_index(this->_M_hash_code(__k)); } + + local_iterator + begin(size_type __bkt) + { + return local_iterator(*this, _M_bucket_begin(__bkt), + __bkt, _M_bucket_count); + } + + local_iterator + end(size_type __bkt) + { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); } + + const_local_iterator + begin(size_type __bkt) const + { + return const_local_iterator(*this, _M_bucket_begin(__bkt), + __bkt, _M_bucket_count); + } + + const_local_iterator + end(size_type __bkt) const + { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } + + + const_local_iterator + cbegin(size_type __bkt) const + { + return const_local_iterator(*this, _M_bucket_begin(__bkt), + __bkt, _M_bucket_count); + } + + const_local_iterator + cend(size_type __bkt) const + { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } + + float + load_factor() const noexcept + { + return static_cast(size()) / static_cast(bucket_count()); + } + + + + + + + const _RehashPolicy& + __rehash_policy() const + { return _M_rehash_policy; } + + void + __rehash_policy(const _RehashPolicy& __pol) + { _M_rehash_policy = __pol; } + + + iterator + find(const key_type& __k); + + const_iterator + find(const key_type& __k) const; + + size_type + count(const key_type& __k) const; + + std::pair + equal_range(const key_type& __k); + + std::pair + equal_range(const key_type& __k) const; +# 789 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 + private: + + size_type + _M_bucket_index(const __node_value_type& __n) const noexcept + { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); } + + size_type + _M_bucket_index(__hash_code __c) const + { return __hash_code_base::_M_bucket_index(__c, _M_bucket_count); } + + __node_base_ptr + _M_find_before_node(const key_type&); + + + + __node_base_ptr + _M_find_before_node(size_type, const key_type&, __hash_code) const; + + template + __node_base_ptr + _M_find_before_node_tr(size_type, const _Kt&, __hash_code) const; + + __node_ptr + _M_find_node(size_type __bkt, const key_type& __key, + __hash_code __c) const + { + __node_base_ptr __before_n = _M_find_before_node(__bkt, __key, __c); + if (__before_n) + return static_cast<__node_ptr>(__before_n->_M_nxt); + return nullptr; + } + + template + __node_ptr + _M_find_node_tr(size_type __bkt, const _Kt& __key, + __hash_code __c) const + { + auto __before_n = _M_find_before_node_tr(__bkt, __key, __c); + if (__before_n) + return static_cast<__node_ptr>(__before_n->_M_nxt); + return nullptr; + } + + + void + _M_insert_bucket_begin(size_type, __node_ptr); + + + void + _M_remove_bucket_begin(size_type __bkt, __node_ptr __next_n, + size_type __next_bkt); + + + __node_base_ptr + _M_get_previous_node(size_type __bkt, __node_ptr __n); + + pair + _M_compute_hash_code(const_iterator __hint, const key_type& __k) const; + + + + + iterator + _M_insert_unique_node(size_type __bkt, __hash_code, + __node_ptr __n, size_type __n_elt = 1); + + + + iterator + _M_insert_multi_node(__node_ptr __hint, + __hash_code __code, __node_ptr __n); + + template + std::pair + _M_emplace(true_type __uks, _Args&&... __args); + + template + iterator + _M_emplace(false_type __uks, _Args&&... __args) + { return _M_emplace(cend(), __uks, std::forward<_Args>(__args)...); } + + + template + iterator + _M_emplace(const_iterator, true_type __uks, _Args&&... __args) + { return _M_emplace(__uks, std::forward<_Args>(__args)...).first; } + + template + iterator + _M_emplace(const_iterator, false_type __uks, _Args&&... __args); + + template + std::pair + _M_insert_unique(_Kt&&, _Arg&&, const _NodeGenerator&); + + template + static __conditional_t< + __and_<__is_nothrow_invocable<_Hash&, const key_type&>, + __not_<__is_nothrow_invocable<_Hash&, _Kt>>>::value, + key_type, _Kt&&> + _S_forward_key(_Kt&& __k) + { return std::forward<_Kt>(__k); } + + static const key_type& + _S_forward_key(const key_type& __k) + { return __k; } + + static key_type&& + _S_forward_key(key_type&& __k) + { return std::move(__k); } + + template + std::pair + _M_insert_unique_aux(_Arg&& __arg, const _NodeGenerator& __node_gen) + { + return _M_insert_unique( + _S_forward_key(_ExtractKey{}(std::forward<_Arg>(__arg))), + std::forward<_Arg>(__arg), __node_gen); + } + + template + std::pair + _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, + true_type ) + { + using __to_value + = __detail::_ConvertToValueType<_ExtractKey, value_type>; + return _M_insert_unique_aux( + __to_value{}(std::forward<_Arg>(__arg)), __node_gen); + } + + template + iterator + _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, + false_type __uks) + { + using __to_value + = __detail::_ConvertToValueType<_ExtractKey, value_type>; + return _M_insert(cend(), + __to_value{}(std::forward<_Arg>(__arg)), __node_gen, __uks); + } + + + template + iterator + _M_insert(const_iterator, _Arg&& __arg, + const _NodeGenerator& __node_gen, true_type __uks) + { + return + _M_insert(std::forward<_Arg>(__arg), __node_gen, __uks).first; + } + + + template + iterator + _M_insert(const_iterator, _Arg&&, + const _NodeGenerator&, false_type __uks); + + size_type + _M_erase(true_type __uks, const key_type&); + + size_type + _M_erase(false_type __uks, const key_type&); + + iterator + _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n); + + public: + + template + __ireturn_type + emplace(_Args&&... __args) + { return _M_emplace(__unique_keys{}, std::forward<_Args>(__args)...); } + + template + iterator + emplace_hint(const_iterator __hint, _Args&&... __args) + { + return _M_emplace(__hint, __unique_keys{}, + std::forward<_Args>(__args)...); + } + + + + + iterator + erase(const_iterator); + + + iterator + erase(iterator __it) + { return erase(const_iterator(__it)); } + + size_type + erase(const key_type& __k) + { return _M_erase(__unique_keys{}, __k); } + + iterator + erase(const_iterator, const_iterator); + + void + clear() noexcept; + + + + void rehash(size_type __bkt_count); + + + + + + + insert_return_type + _M_reinsert_node(node_type&& __nh) + { + insert_return_type __ret; + if (__nh.empty()) + __ret.position = end(); + else + { + do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __nh.get_allocator())) __builtin_unreachable(); } while (false); + + const key_type& __k = __nh._M_key(); + __hash_code __code = this->_M_hash_code(__k); + size_type __bkt = _M_bucket_index(__code); + if (__node_ptr __n = _M_find_node(__bkt, __k, __code)) + { + __ret.node = std::move(__nh); + __ret.position = iterator(__n); + __ret.inserted = false; + } + else + { + __ret.position + = _M_insert_unique_node(__bkt, __code, __nh._M_ptr); + __nh._M_ptr = nullptr; + __ret.inserted = true; + } + } + return __ret; + } + + + iterator + _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh) + { + if (__nh.empty()) + return end(); + + do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __nh.get_allocator())) __builtin_unreachable(); } while (false); + + const key_type& __k = __nh._M_key(); + auto __code = this->_M_hash_code(__k); + auto __ret + = _M_insert_multi_node(__hint._M_cur, __code, __nh._M_ptr); + __nh._M_ptr = nullptr; + return __ret; + } + + private: + node_type + _M_extract_node(size_t __bkt, __node_base_ptr __prev_n) + { + __node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt); + if (__prev_n == _M_buckets[__bkt]) + _M_remove_bucket_begin(__bkt, __n->_M_next(), + __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0); + else if (__n->_M_nxt) + { + size_type __next_bkt = _M_bucket_index(*__n->_M_next()); + if (__next_bkt != __bkt) + _M_buckets[__next_bkt] = __prev_n; + } + + __prev_n->_M_nxt = __n->_M_nxt; + __n->_M_nxt = nullptr; + --_M_element_count; + return { __n, this->_M_node_allocator() }; + } + + public: + + node_type + extract(const_iterator __pos) + { + size_t __bkt = _M_bucket_index(*__pos._M_cur); + return _M_extract_node(__bkt, + _M_get_previous_node(__bkt, __pos._M_cur)); + } + + + node_type + extract(const _Key& __k) + { + node_type __nh; + __hash_code __code = this->_M_hash_code(__k); + std::size_t __bkt = _M_bucket_index(__code); + if (__node_base_ptr __prev_node = _M_find_before_node(__bkt, __k, __code)) + __nh = _M_extract_node(__bkt, __prev_node); + return __nh; + } + + + template + void + _M_merge_unique(_Compatible_Hashtable& __src) + { + static_assert(is_same_v, "Node types are compatible"); + do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) __builtin_unreachable(); } while (false); + + auto __n_elt = __src.size(); + for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;) + { + auto __pos = __i++; + const key_type& __k = _ExtractKey{}(*__pos); + __hash_code __code + = this->_M_hash_code(__src.hash_function(), *__pos._M_cur); + size_type __bkt = _M_bucket_index(__code); + if (_M_find_node(__bkt, __k, __code) == nullptr) + { + auto __nh = __src.extract(__pos); + _M_insert_unique_node(__bkt, __code, __nh._M_ptr, __n_elt); + __nh._M_ptr = nullptr; + __n_elt = 1; + } + else if (__n_elt != 1) + --__n_elt; + } + } + + + template + void + _M_merge_multi(_Compatible_Hashtable& __src) + { + static_assert(is_same_v, "Node types are compatible"); + do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) __builtin_unreachable(); } while (false); + + __node_ptr __hint = nullptr; + this->reserve(size() + __src.size()); + for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;) + { + auto __pos = __i++; + __hash_code __code + = this->_M_hash_code(__src.hash_function(), *__pos._M_cur); + auto __nh = __src.extract(__pos); + __hint = _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur; + __nh._M_ptr = nullptr; + } + } + + + private: + + void _M_rehash_aux(size_type __bkt_count, true_type __uks); + + + void _M_rehash_aux(size_type __bkt_count, false_type __uks); + + + + void _M_rehash(size_type __bkt_count, const __rehash_state& __state); + }; + + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_bucket_begin(size_type __bkt) const + -> __node_ptr + { + __node_base_ptr __n = _M_buckets[__bkt]; + return __n ? static_cast<__node_ptr>(__n->_M_nxt) : nullptr; + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _Hashtable(size_type __bkt_count_hint, + const _Hash& __h, const _Equal& __eq, const allocator_type& __a) + : _Hashtable(__h, __eq, __a) + { + auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint); + if (__bkt_count > _M_bucket_count) + { + _M_buckets = _M_allocate_buckets(__bkt_count); + _M_bucket_count = __bkt_count; + } + } + + template + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _Hashtable(_InputIterator __f, _InputIterator __l, + size_type __bkt_count_hint, + const _Hash& __h, const _Equal& __eq, + const allocator_type& __a, true_type ) + : _Hashtable(__bkt_count_hint, __h, __eq, __a) + { this->insert(__f, __l); } + + template + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _Hashtable(_InputIterator __f, _InputIterator __l, + size_type __bkt_count_hint, + const _Hash& __h, const _Equal& __eq, + const allocator_type& __a, false_type __uks) + : _Hashtable(__h, __eq, __a) + { + auto __nb_elems = __detail::__distance_fw(__f, __l); + auto __bkt_count = + _M_rehash_policy._M_next_bkt( + std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems), + __bkt_count_hint)); + + if (__bkt_count > _M_bucket_count) + { + _M_buckets = _M_allocate_buckets(__bkt_count); + _M_bucket_count = __bkt_count; + } + + __alloc_node_gen_t __node_gen(*this); + for (; __f != __l; ++__f) + _M_insert(*__f, __node_gen, __uks); + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + operator=(const _Hashtable& __ht) + -> _Hashtable& + { + if (&__ht == this) + return *this; + + if (__node_alloc_traits::_S_propagate_on_copy_assign()) + { + auto& __this_alloc = this->_M_node_allocator(); + auto& __that_alloc = __ht._M_node_allocator(); + if (!__node_alloc_traits::_S_always_equal() + && __this_alloc != __that_alloc) + { + + this->_M_deallocate_nodes(_M_begin()); + _M_before_begin._M_nxt = nullptr; + _M_deallocate_buckets(); + _M_buckets = nullptr; + std::__alloc_on_copy(__this_alloc, __that_alloc); + __hashtable_base::operator=(__ht); + _M_bucket_count = __ht._M_bucket_count; + _M_element_count = __ht._M_element_count; + _M_rehash_policy = __ht._M_rehash_policy; + __alloc_node_gen_t __alloc_node_gen(*this); + try + { + _M_assign(__ht, __alloc_node_gen); + } + catch(...) + { + + + _M_reset(); + throw; + } + return *this; + } + std::__alloc_on_copy(__this_alloc, __that_alloc); + } + + + _M_assign_elements(__ht); + return *this; + } + + template + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_assign_elements(_Ht&& __ht) + { + __buckets_ptr __former_buckets = nullptr; + std::size_t __former_bucket_count = _M_bucket_count; + const __rehash_state& __former_state = _M_rehash_policy._M_state(); + + if (_M_bucket_count != __ht._M_bucket_count) + { + __former_buckets = _M_buckets; + _M_buckets = _M_allocate_buckets(__ht._M_bucket_count); + _M_bucket_count = __ht._M_bucket_count; + } + else + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__node_base_ptr)); + + try + { + __hashtable_base::operator=(std::forward<_Ht>(__ht)); + _M_element_count = __ht._M_element_count; + _M_rehash_policy = __ht._M_rehash_policy; + __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); + _M_before_begin._M_nxt = nullptr; + _M_assign(std::forward<_Ht>(__ht), __roan); + if (__former_buckets) + _M_deallocate_buckets(__former_buckets, __former_bucket_count); + } + catch(...) + { + if (__former_buckets) + { + + _M_deallocate_buckets(); + _M_rehash_policy._M_reset(__former_state); + _M_buckets = __former_buckets; + _M_bucket_count = __former_bucket_count; + } + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__node_base_ptr)); + throw; + } + } + + template + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_assign(_Ht&& __ht, const _NodeGenerator& __node_gen) + { + __buckets_ptr __buckets = nullptr; + if (!_M_buckets) + _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count); + + try + { + if (!__ht._M_before_begin._M_nxt) + return; + + + + __node_ptr __ht_n = __ht._M_begin(); + __node_ptr __this_n + = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); + this->_M_copy_code(*__this_n, *__ht_n); + _M_update_bbegin(__this_n); + + + __node_ptr __prev_n = __this_n; + for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next()) + { + __this_n = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); + __prev_n->_M_nxt = __this_n; + this->_M_copy_code(*__this_n, *__ht_n); + size_type __bkt = _M_bucket_index(*__this_n); + if (!_M_buckets[__bkt]) + _M_buckets[__bkt] = __prev_n; + __prev_n = __this_n; + } + } + catch(...) + { + clear(); + if (__buckets) + _M_deallocate_buckets(); + throw; + } + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_reset() noexcept + { + _M_rehash_policy._M_reset(); + _M_bucket_count = 1; + _M_single_bucket = nullptr; + _M_buckets = &_M_single_bucket; + _M_before_begin._M_nxt = nullptr; + _M_element_count = 0; + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_move_assign(_Hashtable&& __ht, true_type) + { + if (__builtin_expect(std::__addressof(__ht) == this, false)) + return; + + this->_M_deallocate_nodes(_M_begin()); + _M_deallocate_buckets(); + __hashtable_base::operator=(std::move(__ht)); + _M_rehash_policy = __ht._M_rehash_policy; + if (!__ht._M_uses_single_bucket()) + _M_buckets = __ht._M_buckets; + else + { + _M_buckets = &_M_single_bucket; + _M_single_bucket = __ht._M_single_bucket; + } + + _M_bucket_count = __ht._M_bucket_count; + _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; + _M_element_count = __ht._M_element_count; + std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator()); + + + _M_update_bbegin(); + __ht._M_reset(); + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_move_assign(_Hashtable&& __ht, false_type) + { + if (__ht._M_node_allocator() == this->_M_node_allocator()) + _M_move_assign(std::move(__ht), true_type{}); + else + { + + _M_assign_elements(std::move(__ht)); + __ht.clear(); + } + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _Hashtable(const _Hashtable& __ht) + : __hashtable_base(__ht), + __map_base(__ht), + __rehash_base(__ht), + __hashtable_alloc( + __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())), + __enable_default_ctor(__ht), + _M_buckets(nullptr), + _M_bucket_count(__ht._M_bucket_count), + _M_element_count(__ht._M_element_count), + _M_rehash_policy(__ht._M_rehash_policy) + { + __alloc_node_gen_t __alloc_node_gen(*this); + _M_assign(__ht, __alloc_node_gen); + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, + true_type ) + noexcept(_S_nothrow_move()) + : __hashtable_base(__ht), + __map_base(__ht), + __rehash_base(__ht), + __hashtable_alloc(std::move(__a)), + __enable_default_ctor(__ht), + _M_buckets(__ht._M_buckets), + _M_bucket_count(__ht._M_bucket_count), + _M_before_begin(__ht._M_before_begin._M_nxt), + _M_element_count(__ht._M_element_count), + _M_rehash_policy(__ht._M_rehash_policy) + { + + if (__ht._M_uses_single_bucket()) + { + _M_buckets = &_M_single_bucket; + _M_single_bucket = __ht._M_single_bucket; + } + + + _M_update_bbegin(); + + __ht._M_reset(); + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _Hashtable(const _Hashtable& __ht, const allocator_type& __a) + : __hashtable_base(__ht), + __map_base(__ht), + __rehash_base(__ht), + __hashtable_alloc(__node_alloc_type(__a)), + __enable_default_ctor(__ht), + _M_buckets(), + _M_bucket_count(__ht._M_bucket_count), + _M_element_count(__ht._M_element_count), + _M_rehash_policy(__ht._M_rehash_policy) + { + __alloc_node_gen_t __alloc_node_gen(*this); + _M_assign(__ht, __alloc_node_gen); + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, + false_type ) + : __hashtable_base(__ht), + __map_base(__ht), + __rehash_base(__ht), + __hashtable_alloc(std::move(__a)), + __enable_default_ctor(__ht), + _M_buckets(nullptr), + _M_bucket_count(__ht._M_bucket_count), + _M_element_count(__ht._M_element_count), + _M_rehash_policy(__ht._M_rehash_policy) + { + if (__ht._M_node_allocator() == this->_M_node_allocator()) + { + if (__ht._M_uses_single_bucket()) + { + _M_buckets = &_M_single_bucket; + _M_single_bucket = __ht._M_single_bucket; + } + else + _M_buckets = __ht._M_buckets; + + + + _M_update_bbegin(__ht._M_begin()); + + __ht._M_reset(); + } + else + { + __alloc_node_gen_t __alloc_gen(*this); + + using _Fwd_Ht = __conditional_t< + __move_if_noexcept_cond::value, + const _Hashtable&, _Hashtable&&>; + _M_assign(std::forward<_Fwd_Ht>(__ht), __alloc_gen); + __ht.clear(); + } + } + + template + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + ~_Hashtable() noexcept + { + + + + static_assert(noexcept(declval() + ._M_bucket_index(declval(), + (std::size_t)0)), + "Cache the hash code or qualify your functors involved" + " in hash code and bucket index computation with noexcept"); + + clear(); + _M_deallocate_buckets(); + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + swap(_Hashtable& __x) + noexcept(__and_<__is_nothrow_swappable<_Hash>, + __is_nothrow_swappable<_Equal>>::value) + { + + + + this->_M_swap(__x); + + std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator()); + std::swap(_M_rehash_policy, __x._M_rehash_policy); + + + if (this->_M_uses_single_bucket()) + { + if (!__x._M_uses_single_bucket()) + { + _M_buckets = __x._M_buckets; + __x._M_buckets = &__x._M_single_bucket; + } + } + else if (__x._M_uses_single_bucket()) + { + __x._M_buckets = _M_buckets; + _M_buckets = &_M_single_bucket; + } + else + std::swap(_M_buckets, __x._M_buckets); + + std::swap(_M_bucket_count, __x._M_bucket_count); + std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt); + std::swap(_M_element_count, __x._M_element_count); + std::swap(_M_single_bucket, __x._M_single_bucket); + + + + _M_update_bbegin(); + __x._M_update_bbegin(); + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + find(const key_type& __k) + -> iterator + { + if (size() <= __small_size_threshold()) + { + for (auto __it = begin(); __it != end(); ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + return __it; + return end(); + } + + __hash_code __code = this->_M_hash_code(__k); + std::size_t __bkt = _M_bucket_index(__code); + return iterator(_M_find_node(__bkt, __k, __code)); + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + find(const key_type& __k) const + -> const_iterator + { + if (size() <= __small_size_threshold()) + { + for (auto __it = begin(); __it != end(); ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + return __it; + return end(); + } + + __hash_code __code = this->_M_hash_code(__k); + std::size_t __bkt = _M_bucket_index(__code); + return const_iterator(_M_find_node(__bkt, __k, __code)); + } +# 1724 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + count(const key_type& __k) const + -> size_type + { + auto __it = find(__k); + if (!__it._M_cur) + return 0; + + if (__unique_keys::value) + return 1; + + + + + size_type __result = 1; + for (auto __ref = __it++; + __it._M_cur && this->_M_node_equals(*__ref._M_cur, *__it._M_cur); + ++__it) + ++__result; + + return __result; + } +# 1785 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + equal_range(const key_type& __k) + -> pair + { + auto __ite = find(__k); + if (!__ite._M_cur) + return { __ite, __ite }; + + auto __beg = __ite++; + if (__unique_keys::value) + return { __beg, __ite }; + + + + + while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur)) + ++__ite; + + return { __beg, __ite }; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + equal_range(const key_type& __k) const + -> pair + { + auto __ite = find(__k); + if (!__ite._M_cur) + return { __ite, __ite }; + + auto __beg = __ite++; + if (__unique_keys::value) + return { __beg, __ite }; + + + + + while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur)) + ++__ite; + + return { __beg, __ite }; + } +# 1899 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_find_before_node(const key_type& __k) + -> __node_base_ptr + { + __node_base_ptr __prev_p = &_M_before_begin; + if (!__prev_p->_M_nxt) + return nullptr; + + for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt); + __p != nullptr; + __p = __p->_M_next()) + { + if (this->_M_key_equals(__k, *__p)) + return __prev_p; + + __prev_p = __p; + } + + return nullptr; + } + + + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_find_before_node(size_type __bkt, const key_type& __k, + __hash_code __code) const + -> __node_base_ptr + { + __node_base_ptr __prev_p = _M_buckets[__bkt]; + if (!__prev_p) + return nullptr; + + for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);; + __p = __p->_M_next()) + { + if (this->_M_equals(__k, __code, *__p)) + return __prev_p; + + if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt) + break; + __prev_p = __p; + } + + return nullptr; + } + + template + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_find_before_node_tr(size_type __bkt, const _Kt& __k, + __hash_code __code) const + -> __node_base_ptr + { + __node_base_ptr __prev_p = _M_buckets[__bkt]; + if (!__prev_p) + return nullptr; + + for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);; + __p = __p->_M_next()) + { + if (this->_M_equals_tr(__k, __code, *__p)) + return __prev_p; + + if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt) + break; + __prev_p = __p; + } + + return nullptr; + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_insert_bucket_begin(size_type __bkt, __node_ptr __node) + { + if (_M_buckets[__bkt]) + { + + + __node->_M_nxt = _M_buckets[__bkt]->_M_nxt; + _M_buckets[__bkt]->_M_nxt = __node; + } + else + { + + + + __node->_M_nxt = _M_before_begin._M_nxt; + _M_before_begin._M_nxt = __node; + + if (__node->_M_nxt) + + + _M_buckets[_M_bucket_index(*__node->_M_next())] = __node; + + _M_buckets[__bkt] = &_M_before_begin; + } + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_remove_bucket_begin(size_type __bkt, __node_ptr __next, + size_type __next_bkt) + { + if (!__next || __next_bkt != __bkt) + { + + + if (__next) + _M_buckets[__next_bkt] = _M_buckets[__bkt]; + + + if (&_M_before_begin == _M_buckets[__bkt]) + _M_before_begin._M_nxt = __next; + _M_buckets[__bkt] = nullptr; + } + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_get_previous_node(size_type __bkt, __node_ptr __n) + -> __node_base_ptr + { + __node_base_ptr __prev_n = _M_buckets[__bkt]; + while (__prev_n->_M_nxt != __n) + __prev_n = __prev_n->_M_nxt; + return __prev_n; + } + + template + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_emplace(true_type , _Args&&... __args) + -> pair + { + + _Scoped_node __node { this, std::forward<_Args>(__args)... }; + const key_type& __k = _ExtractKey{}(__node._M_node->_M_v()); + if (size() <= __small_size_threshold()) + { + for (auto __it = begin(); __it != end(); ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + + return { __it, false }; + } + + __hash_code __code = this->_M_hash_code(__k); + size_type __bkt = _M_bucket_index(__code); + if (size() > __small_size_threshold()) + if (__node_ptr __p = _M_find_node(__bkt, __k, __code)) + + return { iterator(__p), false }; + + + auto __pos = _M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node = nullptr; + return { __pos, true }; + } + + template + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_emplace(const_iterator __hint, false_type , + _Args&&... __args) + -> iterator + { + + _Scoped_node __node { this, std::forward<_Args>(__args)... }; + const key_type& __k = _ExtractKey{}(__node._M_node->_M_v()); + + auto __res = this->_M_compute_hash_code(__hint, __k); + auto __pos + = _M_insert_multi_node(__res.first._M_cur, __res.second, + __node._M_node); + __node._M_node = nullptr; + return __pos; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_compute_hash_code(const_iterator __hint, const key_type& __k) const + -> pair + { + if (size() <= __small_size_threshold()) + { + if (__hint != cend()) + { + for (auto __it = __hint; __it != cend(); ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + return { __it, this->_M_hash_code(*__it._M_cur) }; + } + + for (auto __it = cbegin(); __it != __hint; ++__it) + if (this->_M_key_equals(__k, *__it._M_cur)) + return { __it, this->_M_hash_code(*__it._M_cur) }; + } + + return { __hint, this->_M_hash_code(__k) }; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_insert_unique_node(size_type __bkt, __hash_code __code, + __node_ptr __node, size_type __n_elt) + -> iterator + { + const __rehash_state& __saved_state = _M_rehash_policy._M_state(); + std::pair __do_rehash + = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, + __n_elt); + + if (__do_rehash.first) + { + _M_rehash(__do_rehash.second, __saved_state); + __bkt = _M_bucket_index(__code); + } + + this->_M_store_code(*__node, __code); + + + _M_insert_bucket_begin(__bkt, __node); + ++_M_element_count; + return iterator(__node); + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_insert_multi_node(__node_ptr __hint, + __hash_code __code, __node_ptr __node) + -> iterator + { + const __rehash_state& __saved_state = _M_rehash_policy._M_state(); + std::pair __do_rehash + = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); + + if (__do_rehash.first) + _M_rehash(__do_rehash.second, __saved_state); + + this->_M_store_code(*__node, __code); + const key_type& __k = _ExtractKey{}(__node->_M_v()); + size_type __bkt = _M_bucket_index(__code); + + + + __node_base_ptr __prev + = __builtin_expect(__hint != nullptr, false) + && this->_M_equals(__k, __code, *__hint) + ? __hint + : _M_find_before_node(__bkt, __k, __code); + + if (__prev) + { + + __node->_M_nxt = __prev->_M_nxt; + __prev->_M_nxt = __node; + if (__builtin_expect(__prev == __hint, false)) + + + if (__node->_M_nxt + && !this->_M_equals(__k, __code, *__node->_M_next())) + { + size_type __next_bkt = _M_bucket_index(*__node->_M_next()); + if (__next_bkt != __bkt) + _M_buckets[__next_bkt] = __node; + } + } + else + + + + _M_insert_bucket_begin(__bkt, __node); + ++_M_element_count; + return iterator(__node); + } + + + template + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_insert_unique(_Kt&& __k, _Arg&& __v, + const _NodeGenerator& __node_gen) + -> pair + { + if (size() <= __small_size_threshold()) + for (auto __it = begin(); __it != end(); ++__it) + if (this->_M_key_equals_tr(__k, *__it._M_cur)) + return { __it, false }; + + __hash_code __code = this->_M_hash_code_tr(__k); + size_type __bkt = _M_bucket_index(__code); + + if (size() > __small_size_threshold()) + if (__node_ptr __node = _M_find_node_tr(__bkt, __k, __code)) + return { iterator(__node), false }; + + _Scoped_node __node { + __node_builder_t::_S_build(std::forward<_Kt>(__k), + std::forward<_Arg>(__v), + __node_gen), + this + }; + auto __pos + = _M_insert_unique_node(__bkt, __code, __node._M_node); + __node._M_node = nullptr; + return { __pos, true }; + } + + + template + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_insert(const_iterator __hint, _Arg&& __v, + const _NodeGenerator& __node_gen, + false_type ) + -> iterator + { + + _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this }; + + + auto __res = this->_M_compute_hash_code( + __hint, _ExtractKey{}(__node._M_node->_M_v())); + + auto __pos + = _M_insert_multi_node(__res.first._M_cur, __res.second, + __node._M_node); + __node._M_node = nullptr; + return __pos; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + erase(const_iterator __it) + -> iterator + { + __node_ptr __n = __it._M_cur; + std::size_t __bkt = _M_bucket_index(*__n); + + + + + __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n); + return _M_erase(__bkt, __prev_n, __n); + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n) + -> iterator + { + if (__prev_n == _M_buckets[__bkt]) + _M_remove_bucket_begin(__bkt, __n->_M_next(), + __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0); + else if (__n->_M_nxt) + { + size_type __next_bkt = _M_bucket_index(*__n->_M_next()); + if (__next_bkt != __bkt) + _M_buckets[__next_bkt] = __prev_n; + } + + __prev_n->_M_nxt = __n->_M_nxt; + iterator __result(__n->_M_next()); + this->_M_deallocate_node(__n); + --_M_element_count; + + return __result; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_erase(true_type , const key_type& __k) + -> size_type + { + __node_base_ptr __prev_n; + __node_ptr __n; + std::size_t __bkt; + if (size() <= __small_size_threshold()) + { + __prev_n = _M_find_before_node(__k); + if (!__prev_n) + return 0; + + + __n = static_cast<__node_ptr>(__prev_n->_M_nxt); + __bkt = _M_bucket_index(*__n); + } + else + { + __hash_code __code = this->_M_hash_code(__k); + __bkt = _M_bucket_index(__code); + + + __prev_n = _M_find_before_node(__bkt, __k, __code); + if (!__prev_n) + return 0; + + + __n = static_cast<__node_ptr>(__prev_n->_M_nxt); + } + + _M_erase(__bkt, __prev_n, __n); + return 1; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_erase(false_type , const key_type& __k) + -> size_type + { + std::size_t __bkt; + __node_base_ptr __prev_n; + __node_ptr __n; + if (size() <= __small_size_threshold()) + { + __prev_n = _M_find_before_node(__k); + if (!__prev_n) + return 0; + + + __n = static_cast<__node_ptr>(__prev_n->_M_nxt); + __bkt = _M_bucket_index(*__n); + } + else + { + __hash_code __code = this->_M_hash_code(__k); + __bkt = _M_bucket_index(__code); + + + __prev_n = _M_find_before_node(__bkt, __k, __code); + if (!__prev_n) + return 0; + + __n = static_cast<__node_ptr>(__prev_n->_M_nxt); + } + + + + + + + + __node_ptr __n_last = __n->_M_next(); + while (__n_last && this->_M_node_equals(*__n, *__n_last)) + __n_last = __n_last->_M_next(); + + std::size_t __n_last_bkt = __n_last ? _M_bucket_index(*__n_last) : __bkt; + + + size_type __result = 0; + do + { + __node_ptr __p = __n->_M_next(); + this->_M_deallocate_node(__n); + __n = __p; + ++__result; + } + while (__n != __n_last); + + _M_element_count -= __result; + if (__prev_n == _M_buckets[__bkt]) + _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt); + else if (__n_last_bkt != __bkt) + _M_buckets[__n_last_bkt] = __prev_n; + __prev_n->_M_nxt = __n_last; + return __result; + } + + template + auto + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + erase(const_iterator __first, const_iterator __last) + -> iterator + { + __node_ptr __n = __first._M_cur; + __node_ptr __last_n = __last._M_cur; + if (__n == __last_n) + return iterator(__n); + + std::size_t __bkt = _M_bucket_index(*__n); + + __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n); + bool __is_bucket_begin = __n == _M_bucket_begin(__bkt); + std::size_t __n_bkt = __bkt; + for (;;) + { + do + { + __node_ptr __tmp = __n; + __n = __n->_M_next(); + this->_M_deallocate_node(__tmp); + --_M_element_count; + if (!__n) + break; + __n_bkt = _M_bucket_index(*__n); + } + while (__n != __last_n && __n_bkt == __bkt); + if (__is_bucket_begin) + _M_remove_bucket_begin(__bkt, __n, __n_bkt); + if (__n == __last_n) + break; + __is_bucket_begin = true; + __bkt = __n_bkt; + } + + if (__n && (__n_bkt != __bkt || __is_bucket_begin)) + _M_buckets[__n_bkt] = __prev_n; + __prev_n->_M_nxt = __n; + return iterator(__n); + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + clear() noexcept + { + this->_M_deallocate_nodes(_M_begin()); + __builtin_memset(_M_buckets, 0, + _M_bucket_count * sizeof(__node_base_ptr)); + _M_element_count = 0; + _M_before_begin._M_nxt = nullptr; + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + rehash(size_type __bkt_count) + { + const __rehash_state& __saved_state = _M_rehash_policy._M_state(); + __bkt_count + = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1), + __bkt_count); + __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count); + + if (__bkt_count != _M_bucket_count) + _M_rehash(__bkt_count, __saved_state); + else + + + _M_rehash_policy._M_reset(__saved_state); + } + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_rehash(size_type __bkt_count, const __rehash_state& __state) + { + try + { + _M_rehash_aux(__bkt_count, __unique_keys{}); + } + catch(...) + { + + + _M_rehash_policy._M_reset(__state); + throw; + } + } + + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_rehash_aux(size_type __bkt_count, true_type ) + { + __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count); + __node_ptr __p = _M_begin(); + _M_before_begin._M_nxt = nullptr; + std::size_t __bbegin_bkt = 0; + while (__p) + { + __node_ptr __next = __p->_M_next(); + std::size_t __bkt + = __hash_code_base::_M_bucket_index(*__p, __bkt_count); + if (!__new_buckets[__bkt]) + { + __p->_M_nxt = _M_before_begin._M_nxt; + _M_before_begin._M_nxt = __p; + __new_buckets[__bkt] = &_M_before_begin; + if (__p->_M_nxt) + __new_buckets[__bbegin_bkt] = __p; + __bbegin_bkt = __bkt; + } + else + { + __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; + __new_buckets[__bkt]->_M_nxt = __p; + } + + __p = __next; + } + + _M_deallocate_buckets(); + _M_bucket_count = __bkt_count; + _M_buckets = __new_buckets; + } + + + + template + void + _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, + _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: + _M_rehash_aux(size_type __bkt_count, false_type ) + { + __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count); + __node_ptr __p = _M_begin(); + _M_before_begin._M_nxt = nullptr; + std::size_t __bbegin_bkt = 0; + std::size_t __prev_bkt = 0; + __node_ptr __prev_p = nullptr; + bool __check_bucket = false; + + while (__p) + { + __node_ptr __next = __p->_M_next(); + std::size_t __bkt + = __hash_code_base::_M_bucket_index(*__p, __bkt_count); + + if (__prev_p && __prev_bkt == __bkt) + { + + + + __p->_M_nxt = __prev_p->_M_nxt; + __prev_p->_M_nxt = __p; + + + + + + + __check_bucket = true; + } + else + { + if (__check_bucket) + { + + + if (__prev_p->_M_nxt) + { + std::size_t __next_bkt + = __hash_code_base::_M_bucket_index( + *__prev_p->_M_next(), __bkt_count); + if (__next_bkt != __prev_bkt) + __new_buckets[__next_bkt] = __prev_p; + } + __check_bucket = false; + } + + if (!__new_buckets[__bkt]) + { + __p->_M_nxt = _M_before_begin._M_nxt; + _M_before_begin._M_nxt = __p; + __new_buckets[__bkt] = &_M_before_begin; + if (__p->_M_nxt) + __new_buckets[__bbegin_bkt] = __p; + __bbegin_bkt = __bkt; + } + else + { + __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; + __new_buckets[__bkt]->_M_nxt = __p; + } + } + __prev_p = __p; + __prev_bkt = __bkt; + __p = __next; + } + + if (__check_bucket && __prev_p->_M_nxt) + { + std::size_t __next_bkt + = __hash_code_base::_M_bucket_index(*__prev_p->_M_next(), + __bkt_count); + if (__next_bkt != __prev_bkt) + __new_buckets[__next_bkt] = __prev_p; + } + + _M_deallocate_buckets(); + _M_bucket_count = __bkt_count; + _M_buckets = __new_buckets; + } + + + template class _Hash_merge_helper { }; + + + + + template + using _RequireNotAllocatorOrIntegral + = __enable_if_t, __is_allocator<_Hash>>::value>; + + + + +} +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 2 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>; + + template, + typename _Pred = std::equal_to<_Key>, + typename _Alloc = std::allocator >, + typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>> + using __umap_hashtable = _Hashtable<_Key, std::pair, + _Alloc, __detail::_Select1st, + _Pred, _Hash, + __detail::_Mod_range_hashing, + __detail::_Default_ranged_hash, + __detail::_Prime_rehash_policy, _Tr>; + + + template + using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>; + + template, + typename _Pred = std::equal_to<_Key>, + typename _Alloc = std::allocator >, + typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>> + using __ummap_hashtable = _Hashtable<_Key, std::pair, + _Alloc, __detail::_Select1st, + _Pred, _Hash, + __detail::_Mod_range_hashing, + __detail::_Default_ranged_hash, + __detail::_Prime_rehash_policy, _Tr>; + + template + class unordered_multimap; +# 105 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template, + typename _Pred = equal_to<_Key>, + typename _Alloc = allocator>> + class unordered_map + { + typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; + _Hashtable _M_h; + + public: + + + + typedef typename _Hashtable::key_type key_type; + typedef typename _Hashtable::value_type value_type; + typedef typename _Hashtable::mapped_type mapped_type; + typedef typename _Hashtable::hasher hasher; + typedef typename _Hashtable::key_equal key_equal; + typedef typename _Hashtable::allocator_type allocator_type; + + + + + typedef typename _Hashtable::pointer pointer; + typedef typename _Hashtable::const_pointer const_pointer; + typedef typename _Hashtable::reference reference; + typedef typename _Hashtable::const_reference const_reference; + typedef typename _Hashtable::iterator iterator; + typedef typename _Hashtable::const_iterator const_iterator; + typedef typename _Hashtable::local_iterator local_iterator; + typedef typename _Hashtable::const_local_iterator const_local_iterator; + typedef typename _Hashtable::size_type size_type; + typedef typename _Hashtable::difference_type difference_type; + + + + using node_type = typename _Hashtable::node_type; + using insert_return_type = typename _Hashtable::insert_return_type; + + + + + + unordered_map() = default; +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + explicit + unordered_map(size_type __n, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { } +# 178 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + unordered_map(_InputIterator __first, _InputIterator __last, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__first, __last, __n, __hf, __eql, __a) + { } + + + unordered_map(const unordered_map&) = default; + + + unordered_map(unordered_map&&) = default; + + + + + + explicit + unordered_map(const allocator_type& __a) + : _M_h(__a) + { } + + + + + + + unordered_map(const unordered_map& __umap, + const allocator_type& __a) + : _M_h(__umap._M_h, __a) + { } + + + + + + + unordered_map(unordered_map&& __umap, + const allocator_type& __a) + noexcept( noexcept(_Hashtable(std::move(__umap._M_h), __a)) ) + : _M_h(std::move(__umap._M_h), __a) + { } +# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + unordered_map(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__l, __n, __hf, __eql, __a) + { } + + unordered_map(size_type __n, const allocator_type& __a) + : unordered_map(__n, hasher(), key_equal(), __a) + { } + + unordered_map(size_type __n, const hasher& __hf, + const allocator_type& __a) + : unordered_map(__n, __hf, key_equal(), __a) + { } + + template + unordered_map(_InputIterator __first, _InputIterator __last, + size_type __n, + const allocator_type& __a) + : unordered_map(__first, __last, __n, hasher(), key_equal(), __a) + { } + + template + unordered_map(_InputIterator __first, _InputIterator __last, + size_type __n, const hasher& __hf, + const allocator_type& __a) + : unordered_map(__first, __last, __n, __hf, key_equal(), __a) + { } + + unordered_map(initializer_list __l, + size_type __n, + const allocator_type& __a) + : unordered_map(__l, __n, hasher(), key_equal(), __a) + { } + + unordered_map(initializer_list __l, + size_type __n, const hasher& __hf, + const allocator_type& __a) + : unordered_map(__l, __n, __hf, key_equal(), __a) + { } + + + unordered_map& + operator=(const unordered_map&) = default; + + + unordered_map& + operator=(unordered_map&&) = default; +# 296 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + unordered_map& + operator=(initializer_list __l) + { + _M_h = __l; + return *this; + } + + + allocator_type + get_allocator() const noexcept + { return _M_h.get_allocator(); } + + + + + [[__nodiscard__]] bool + empty() const noexcept + { return _M_h.empty(); } + + + size_type + size() const noexcept + { return _M_h.size(); } + + + size_type + max_size() const noexcept + { return _M_h.max_size(); } + + + + + + + + iterator + begin() noexcept + { return _M_h.begin(); } + + + + + + + const_iterator + begin() const noexcept + { return _M_h.begin(); } + + const_iterator + cbegin() const noexcept + { return _M_h.begin(); } + + + + + + + iterator + end() noexcept + { return _M_h.end(); } + + + + + + + const_iterator + end() const noexcept + { return _M_h.end(); } + + const_iterator + cend() const noexcept + { return _M_h.end(); } +# 393 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + std::pair + emplace(_Args&&... __args) + { return _M_h.emplace(std::forward<_Args>(__args)...); } +# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } + + + + node_type + extract(const_iterator __pos) + { + do { if (std::__is_constant_evaluated() && !bool(__pos != end())) __builtin_unreachable(); } while (false); + return _M_h.extract(__pos); + } + + + node_type + extract(const key_type& __key) + { return _M_h.extract(__key); } + + + insert_return_type + insert(node_type&& __nh) + { return _M_h._M_reinsert_node(std::move(__nh)); } + + + iterator + insert(const_iterator, node_type&& __nh) + { return _M_h._M_reinsert_node(std::move(__nh)).position; } +# 476 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + pair + try_emplace(const key_type& __k, _Args&&... __args) + { + return _M_h.try_emplace(cend(), __k, std::forward<_Args>(__args)...); + } + + + template + pair + try_emplace(key_type&& __k, _Args&&... __args) + { + return _M_h.try_emplace(cend(), std::move(__k), + std::forward<_Args>(__args)...); + } +# 520 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + iterator + try_emplace(const_iterator __hint, const key_type& __k, + _Args&&... __args) + { + return _M_h.try_emplace(__hint, __k, + std::forward<_Args>(__args)...).first; + } + + + template + iterator + try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args) + { + return _M_h.try_emplace(__hint, std::move(__k), + std::forward<_Args>(__args)...).first; + } +# 557 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + std::pair + insert(const value_type& __x) + { return _M_h.insert(__x); } + + + + std::pair + insert(value_type&& __x) + { return _M_h.insert(std::move(__x)); } + + template + __enable_if_t::value, + pair> + insert(_Pair&& __x) + { return _M_h.emplace(std::forward<_Pair>(__x)); } +# 596 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + iterator + insert(const_iterator __hint, const value_type& __x) + { return _M_h.insert(__hint, __x); } + + + + iterator + insert(const_iterator __hint, value_type&& __x) + { return _M_h.insert(__hint, std::move(__x)); } + + template + __enable_if_t::value, iterator> + insert(const_iterator __hint, _Pair&& __x) + { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); } +# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_h.insert(__first, __last); } +# 633 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + void + insert(initializer_list __l) + { _M_h.insert(__l); } +# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + pair + insert_or_assign(const key_type& __k, _Obj&& __obj) + { + auto __ret = _M_h.try_emplace(cend(), __k, + std::forward<_Obj>(__obj)); + if (!__ret.second) + __ret.first->second = std::forward<_Obj>(__obj); + return __ret; + } + + + template + pair + insert_or_assign(key_type&& __k, _Obj&& __obj) + { + auto __ret = _M_h.try_emplace(cend(), std::move(__k), + std::forward<_Obj>(__obj)); + if (!__ret.second) + __ret.first->second = std::forward<_Obj>(__obj); + return __ret; + } +# 708 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + iterator + insert_or_assign(const_iterator __hint, const key_type& __k, + _Obj&& __obj) + { + auto __ret = _M_h.try_emplace(__hint, __k, std::forward<_Obj>(__obj)); + if (!__ret.second) + __ret.first->second = std::forward<_Obj>(__obj); + return __ret.first; + } + + + template + iterator + insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj) + { + auto __ret = _M_h.try_emplace(__hint, std::move(__k), + std::forward<_Obj>(__obj)); + if (!__ret.second) + __ret.first->second = std::forward<_Obj>(__obj); + return __ret.first; + } +# 746 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + iterator + erase(const_iterator __position) + { return _M_h.erase(__position); } + + + iterator + erase(iterator __position) + { return _M_h.erase(__position); } +# 768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + size_type + erase(const key_type& __x) + { return _M_h.erase(__x); } +# 786 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_h.erase(__first, __last); } + + + + + + + + void + clear() noexcept + { _M_h.clear(); } +# 810 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + void + swap(unordered_map& __x) + noexcept( noexcept(_M_h.swap(__x._M_h)) ) + { _M_h.swap(__x._M_h); } + + + template + friend class std::_Hash_merge_helper; + + template + void + merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source) + { + using _Merge_helper = _Hash_merge_helper; + _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); + } + + template + void + merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source) + { merge(__source); } + + template + void + merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source) + { + using _Merge_helper = _Hash_merge_helper; + _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); + } + + template + void + merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source) + { merge(__source); } + + + + + + + hasher + hash_function() const + { return _M_h.hash_function(); } + + + + key_equal + key_eq() const + { return _M_h.key_eq(); } +# 874 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + iterator + find(const key_type& __x) + { return _M_h.find(__x); } +# 885 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + const_iterator + find(const key_type& __x) const + { return _M_h.find(__x); } +# 907 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + size_type + count(const key_type& __x) const + { return _M_h.count(__x); } +# 947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_h.equal_range(__x); } +# 959 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + std::pair + equal_range(const key_type& __x) const + { return _M_h.equal_range(__x); } +# 985 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + mapped_type& + operator[](const key_type& __k) + { return _M_h[__k]; } + + mapped_type& + operator[](key_type&& __k) + { return _M_h[std::move(__k)]; } +# 1002 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + mapped_type& + at(const key_type& __k) + { return _M_h.at(__k); } + + const mapped_type& + at(const key_type& __k) const + { return _M_h.at(__k); } + + + + + + size_type + bucket_count() const noexcept + { return _M_h.bucket_count(); } + + + size_type + max_bucket_count() const noexcept + { return _M_h.max_bucket_count(); } + + + + + + + size_type + bucket_size(size_type __n) const + { return _M_h.bucket_size(__n); } + + + + + + + size_type + bucket(const key_type& __key) const + { return _M_h.bucket(__key); } + + + + + + + + local_iterator + begin(size_type __n) + { return _M_h.begin(__n); } +# 1058 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + const_local_iterator + begin(size_type __n) const + { return _M_h.begin(__n); } + + const_local_iterator + cbegin(size_type __n) const + { return _M_h.cbegin(__n); } +# 1073 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + local_iterator + end(size_type __n) + { return _M_h.end(__n); } +# 1084 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + const_local_iterator + end(size_type __n) const + { return _M_h.end(__n); } + + const_local_iterator + cend(size_type __n) const + { return _M_h.cend(__n); } + + + + + + float + load_factor() const noexcept + { return _M_h.load_factor(); } + + + + float + max_load_factor() const noexcept + { return _M_h.max_load_factor(); } + + + + + + void + max_load_factor(float __z) + { _M_h.max_load_factor(__z); } +# 1121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + void + rehash(size_type __n) + { _M_h.rehash(__n); } +# 1132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + void + reserve(size_type __n) + { _M_h.reserve(__n); } + + template + friend bool + operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&, + const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&); + }; + + + + template>, + typename _Pred = equal_to<__iter_key_t<_InputIterator>>, + typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, + typename = _RequireInputIter<_InputIterator>, + typename = _RequireNotAllocatorOrIntegral<_Hash>, + typename = _RequireNotAllocator<_Pred>, + typename = _RequireAllocator<_Allocator>> + unordered_map(_InputIterator, _InputIterator, + typename unordered_map::size_type = {}, + _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) + -> unordered_map<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, + _Hash, _Pred, _Allocator>; + + template, + typename _Pred = equal_to<_Key>, + typename _Allocator = allocator>, + typename = _RequireNotAllocatorOrIntegral<_Hash>, + typename = _RequireNotAllocator<_Pred>, + typename = _RequireAllocator<_Allocator>> + unordered_map(initializer_list>, + typename unordered_map::size_type = {}, + _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) + -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>; + + template, + typename = _RequireAllocator<_Allocator>> + unordered_map(_InputIterator, _InputIterator, + typename unordered_map::size_type, _Allocator) + -> unordered_map<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, + hash<__iter_key_t<_InputIterator>>, + equal_to<__iter_key_t<_InputIterator>>, + _Allocator>; + + template, + typename = _RequireAllocator<_Allocator>> + unordered_map(_InputIterator, _InputIterator, _Allocator) + -> unordered_map<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, + hash<__iter_key_t<_InputIterator>>, + equal_to<__iter_key_t<_InputIterator>>, + _Allocator>; + + template, + typename = _RequireNotAllocatorOrIntegral<_Hash>, + typename = _RequireAllocator<_Allocator>> + unordered_map(_InputIterator, _InputIterator, + typename unordered_map::size_type, + _Hash, _Allocator) + -> unordered_map<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, _Hash, + equal_to<__iter_key_t<_InputIterator>>, _Allocator>; + + template> + unordered_map(initializer_list>, + typename unordered_map::size_type, + _Allocator) + -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; + + template> + unordered_map(initializer_list>, _Allocator) + -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; + + template, + typename = _RequireAllocator<_Allocator>> + unordered_map(initializer_list>, + typename unordered_map::size_type, + _Hash, _Allocator) + -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; +# 1250 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template, + typename _Pred = equal_to<_Key>, + typename _Alloc = allocator>> + class unordered_multimap + { + typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; + _Hashtable _M_h; + + public: + + + + typedef typename _Hashtable::key_type key_type; + typedef typename _Hashtable::value_type value_type; + typedef typename _Hashtable::mapped_type mapped_type; + typedef typename _Hashtable::hasher hasher; + typedef typename _Hashtable::key_equal key_equal; + typedef typename _Hashtable::allocator_type allocator_type; + + + + + typedef typename _Hashtable::pointer pointer; + typedef typename _Hashtable::const_pointer const_pointer; + typedef typename _Hashtable::reference reference; + typedef typename _Hashtable::const_reference const_reference; + typedef typename _Hashtable::iterator iterator; + typedef typename _Hashtable::const_iterator const_iterator; + typedef typename _Hashtable::local_iterator local_iterator; + typedef typename _Hashtable::const_local_iterator const_local_iterator; + typedef typename _Hashtable::size_type size_type; + typedef typename _Hashtable::difference_type difference_type; + + + + using node_type = typename _Hashtable::node_type; + + + + + + unordered_multimap() = default; +# 1301 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + explicit + unordered_multimap(size_type __n, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__n, __hf, __eql, __a) + { } +# 1322 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + unordered_multimap(_InputIterator __first, _InputIterator __last, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__first, __last, __n, __hf, __eql, __a) + { } + + + unordered_multimap(const unordered_multimap&) = default; + + + unordered_multimap(unordered_multimap&&) = default; + + + + + + explicit + unordered_multimap(const allocator_type& __a) + : _M_h(__a) + { } + + + + + + + unordered_multimap(const unordered_multimap& __ummap, + const allocator_type& __a) + : _M_h(__ummap._M_h, __a) + { } + + + + + + + unordered_multimap(unordered_multimap&& __ummap, + const allocator_type& __a) + noexcept( noexcept(_Hashtable(std::move(__ummap._M_h), __a)) ) + : _M_h(std::move(__ummap._M_h), __a) + { } +# 1378 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + unordered_multimap(initializer_list __l, + size_type __n = 0, + const hasher& __hf = hasher(), + const key_equal& __eql = key_equal(), + const allocator_type& __a = allocator_type()) + : _M_h(__l, __n, __hf, __eql, __a) + { } + + unordered_multimap(size_type __n, const allocator_type& __a) + : unordered_multimap(__n, hasher(), key_equal(), __a) + { } + + unordered_multimap(size_type __n, const hasher& __hf, + const allocator_type& __a) + : unordered_multimap(__n, __hf, key_equal(), __a) + { } + + template + unordered_multimap(_InputIterator __first, _InputIterator __last, + size_type __n, + const allocator_type& __a) + : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) + { } + + template + unordered_multimap(_InputIterator __first, _InputIterator __last, + size_type __n, const hasher& __hf, + const allocator_type& __a) + : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) + { } + + unordered_multimap(initializer_list __l, + size_type __n, + const allocator_type& __a) + : unordered_multimap(__l, __n, hasher(), key_equal(), __a) + { } + + unordered_multimap(initializer_list __l, + size_type __n, const hasher& __hf, + const allocator_type& __a) + : unordered_multimap(__l, __n, __hf, key_equal(), __a) + { } + + + unordered_multimap& + operator=(const unordered_multimap&) = default; + + + unordered_multimap& + operator=(unordered_multimap&&) = default; +# 1440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + unordered_multimap& + operator=(initializer_list __l) + { + _M_h = __l; + return *this; + } + + + allocator_type + get_allocator() const noexcept + { return _M_h.get_allocator(); } + + + + + [[__nodiscard__]] bool + empty() const noexcept + { return _M_h.empty(); } + + + size_type + size() const noexcept + { return _M_h.size(); } + + + size_type + max_size() const noexcept + { return _M_h.max_size(); } + + + + + + + + iterator + begin() noexcept + { return _M_h.begin(); } + + + + + + + const_iterator + begin() const noexcept + { return _M_h.begin(); } + + const_iterator + cbegin() const noexcept + { return _M_h.begin(); } + + + + + + + iterator + end() noexcept + { return _M_h.end(); } + + + + + + + const_iterator + end() const noexcept + { return _M_h.end(); } + + const_iterator + cend() const noexcept + { return _M_h.end(); } +# 1532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + iterator + emplace(_Args&&... __args) + { return _M_h.emplace(std::forward<_Args>(__args)...); } +# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + iterator + emplace_hint(const_iterator __pos, _Args&&... __args) + { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } +# 1574 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + iterator + insert(const value_type& __x) + { return _M_h.insert(__x); } + + iterator + insert(value_type&& __x) + { return _M_h.insert(std::move(__x)); } + + template + __enable_if_t::value, iterator> + insert(_Pair&& __x) + { return _M_h.emplace(std::forward<_Pair>(__x)); } +# 1608 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + iterator + insert(const_iterator __hint, const value_type& __x) + { return _M_h.insert(__hint, __x); } + + + + iterator + insert(const_iterator __hint, value_type&& __x) + { return _M_h.insert(__hint, std::move(__x)); } + + template + __enable_if_t::value, iterator> + insert(const_iterator __hint, _Pair&& __x) + { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); } +# 1633 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + template + void + insert(_InputIterator __first, _InputIterator __last) + { _M_h.insert(__first, __last); } +# 1646 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + void + insert(initializer_list __l) + { _M_h.insert(__l); } + + + + node_type + extract(const_iterator __pos) + { + do { if (std::__is_constant_evaluated() && !bool(__pos != end())) __builtin_unreachable(); } while (false); + return _M_h.extract(__pos); + } + + + node_type + extract(const key_type& __key) + { return _M_h.extract(__key); } + + + iterator + insert(node_type&& __nh) + { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); } + + + iterator + insert(const_iterator __hint, node_type&& __nh) + { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); } +# 1689 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + iterator + erase(const_iterator __position) + { return _M_h.erase(__position); } + + + iterator + erase(iterator __position) + { return _M_h.erase(__position); } +# 1710 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + size_type + erase(const key_type& __x) + { return _M_h.erase(__x); } +# 1729 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + iterator + erase(const_iterator __first, const_iterator __last) + { return _M_h.erase(__first, __last); } + + + + + + + + void + clear() noexcept + { _M_h.clear(); } +# 1753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + void + swap(unordered_multimap& __x) + noexcept( noexcept(_M_h.swap(__x._M_h)) ) + { _M_h.swap(__x._M_h); } + + + template + friend class std::_Hash_merge_helper; + + template + void + merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source) + { + using _Merge_helper + = _Hash_merge_helper; + _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); + } + + template + void + merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source) + { merge(__source); } + + template + void + merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source) + { + using _Merge_helper + = _Hash_merge_helper; + _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); + } + + template + void + merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source) + { merge(__source); } + + + + + + + hasher + hash_function() const + { return _M_h.hash_function(); } + + + + key_equal + key_eq() const + { return _M_h.key_eq(); } +# 1819 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + iterator + find(const key_type& __x) + { return _M_h.find(__x); } +# 1830 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + const_iterator + find(const key_type& __x) const + { return _M_h.find(__x); } +# 1848 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + size_type + count(const key_type& __x) const + { return _M_h.count(__x); } +# 1886 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + std::pair + equal_range(const key_type& __x) + { return _M_h.equal_range(__x); } +# 1898 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + std::pair + equal_range(const key_type& __x) const + { return _M_h.equal_range(__x); } +# 1914 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + size_type + bucket_count() const noexcept + { return _M_h.bucket_count(); } + + + size_type + max_bucket_count() const noexcept + { return _M_h.max_bucket_count(); } + + + + + + + size_type + bucket_size(size_type __n) const + { return _M_h.bucket_size(__n); } + + + + + + + size_type + bucket(const key_type& __key) const + { return _M_h.bucket(__key); } + + + + + + + + local_iterator + begin(size_type __n) + { return _M_h.begin(__n); } +# 1958 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + const_local_iterator + begin(size_type __n) const + { return _M_h.begin(__n); } + + const_local_iterator + cbegin(size_type __n) const + { return _M_h.cbegin(__n); } +# 1973 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + local_iterator + end(size_type __n) + { return _M_h.end(__n); } +# 1984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + const_local_iterator + end(size_type __n) const + { return _M_h.end(__n); } + + const_local_iterator + cend(size_type __n) const + { return _M_h.cend(__n); } + + + + + + float + load_factor() const noexcept + { return _M_h.load_factor(); } + + + + float + max_load_factor() const noexcept + { return _M_h.max_load_factor(); } + + + + + + void + max_load_factor(float __z) + { _M_h.max_load_factor(__z); } +# 2021 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + void + rehash(size_type __n) + { _M_h.rehash(__n); } +# 2032 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 + void + reserve(size_type __n) + { _M_h.reserve(__n); } + + template + friend bool + operator==(const unordered_multimap<_Key1, _Tp1, + _Hash1, _Pred1, _Alloc1>&, + const unordered_multimap<_Key1, _Tp1, + _Hash1, _Pred1, _Alloc1>&); + }; + + + + template>, + typename _Pred = equal_to<__iter_key_t<_InputIterator>>, + typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, + typename = _RequireInputIter<_InputIterator>, + typename = _RequireNotAllocatorOrIntegral<_Hash>, + typename = _RequireNotAllocator<_Pred>, + typename = _RequireAllocator<_Allocator>> + unordered_multimap(_InputIterator, _InputIterator, + unordered_multimap::size_type = {}, + _Hash = _Hash(), _Pred = _Pred(), + _Allocator = _Allocator()) + -> unordered_multimap<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, _Hash, _Pred, + _Allocator>; + + template, + typename _Pred = equal_to<_Key>, + typename _Allocator = allocator>, + typename = _RequireNotAllocatorOrIntegral<_Hash>, + typename = _RequireNotAllocator<_Pred>, + typename = _RequireAllocator<_Allocator>> + unordered_multimap(initializer_list>, + unordered_multimap::size_type = {}, + _Hash = _Hash(), _Pred = _Pred(), + _Allocator = _Allocator()) + -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>; + + template, + typename = _RequireAllocator<_Allocator>> + unordered_multimap(_InputIterator, _InputIterator, + unordered_multimap::size_type, _Allocator) + -> unordered_multimap<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, + hash<__iter_key_t<_InputIterator>>, + equal_to<__iter_key_t<_InputIterator>>, _Allocator>; + + template, + typename = _RequireAllocator<_Allocator>> + unordered_multimap(_InputIterator, _InputIterator, _Allocator) + -> unordered_multimap<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, + hash<__iter_key_t<_InputIterator>>, + equal_to<__iter_key_t<_InputIterator>>, _Allocator>; + + template, + typename = _RequireNotAllocatorOrIntegral<_Hash>, + typename = _RequireAllocator<_Allocator>> + unordered_multimap(_InputIterator, _InputIterator, + unordered_multimap::size_type, _Hash, + _Allocator) + -> unordered_multimap<__iter_key_t<_InputIterator>, + __iter_val_t<_InputIterator>, _Hash, + equal_to<__iter_key_t<_InputIterator>>, _Allocator>; + + template> + unordered_multimap(initializer_list>, + unordered_multimap::size_type, + _Allocator) + -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; + + template> + unordered_multimap(initializer_list>, _Allocator) + -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; + + template, + typename = _RequireAllocator<_Allocator>> + unordered_multimap(initializer_list>, + unordered_multimap::size_type, + _Hash, _Allocator) + -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; + + + + template + inline void + swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + template + inline void + swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + template + inline bool + operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return __x._M_h._M_equal(__y._M_h); } + + + template + inline bool + operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + + + template + inline bool + operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return __x._M_h._M_equal(__y._M_h); } + + + template + inline bool + operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, + const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) + { return !(__x == __y); } + + + + + + + template + struct _Hash_merge_helper< + std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>, + _Hash2, _Eq2> + { + private: + template + using unordered_map = std::unordered_map<_Tp...>; + template + using unordered_multimap = std::unordered_multimap<_Tp...>; + + friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>; + + static auto& + _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) + { return __map._M_h; } + + static auto& + _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) + { return __map._M_h; } + }; + + + template + struct _Hash_merge_helper< + std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>, + _Hash2, _Eq2> + { + private: + template + using unordered_map = std::unordered_map<_Tp...>; + template + using unordered_multimap = std::unordered_multimap<_Tp...>; + + friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>; + + static auto& + _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) + { return __map._M_h; } + + static auto& + _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) + { return __map._M_h; } + }; + + + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/unordered_map" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/erase_if.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/erase_if.h" 3 + + + + + +namespace std +{ + + + + + + + namespace __detail + { + template + typename _Container::size_type + __erase_nodes_if(_Container& __cont, _UnsafeContainer& __ucont, + _Predicate __pred) + { + typename _Container::size_type __num = 0; + for (auto __iter = __ucont.begin(), __last = __ucont.end(); + __iter != __last;) + { + if (__pred(*__iter)) + { + __iter = __cont.erase(__iter); + ++__num; + } + else + ++__iter; + } + return __num; + } + } + + +} +# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/unordered_map" 2 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace pmr + { + template, + typename _Pred = std::equal_to<_Key>> + using unordered_map + = std::unordered_map<_Key, _Tp, _Hash, _Pred, + polymorphic_allocator>>; + template, + typename _Pred = std::equal_to<_Key>> + using unordered_multimap + = std::unordered_multimap<_Key, _Tp, _Hash, _Pred, + polymorphic_allocator>>; + } + +} +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 2 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 1 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 3 + template + + bool + all_of(_IIter, _IIter, _Predicate); + + template + + bool + any_of(_IIter, _IIter, _Predicate); + + + template + + bool + binary_search(_FIter, _FIter, const _Tp&); + + template + + bool + binary_search(_FIter, _FIter, const _Tp&, _Compare); + + + template + constexpr + const _Tp& + clamp(const _Tp&, const _Tp&, const _Tp&); + + template + constexpr + const _Tp& + clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); + + + template + + _OIter + copy(_IIter, _IIter, _OIter); + + template + + _BIter2 + copy_backward(_BIter1, _BIter1, _BIter2); + + + template + + _OIter + copy_if(_IIter, _IIter, _OIter, _Predicate); + + template + + _OIter + copy_n(_IIter, _Size, _OIter); + + + + + + template + + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&); + + template + + pair<_FIter, _FIter> + equal_range(_FIter, _FIter, const _Tp&, _Compare); + + template + + void + fill(_FIter, _FIter, const _Tp&); + + template + + _OIter + fill_n(_OIter, _Size, const _Tp&); + + + + template + + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2); + + template + + _FIter1 + find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + + + + + template + + _IIter + find_if_not(_IIter, _IIter, _Predicate); + + + + + + + template + + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2); + + template + + bool + includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + void + inplace_merge(_BIter, _BIter, _BIter); + + template + void + inplace_merge(_BIter, _BIter, _BIter, _Compare); + + + template + + bool + is_heap(_RAIter, _RAIter); + + template + + bool + is_heap(_RAIter, _RAIter, _Compare); + + template + + _RAIter + is_heap_until(_RAIter, _RAIter); + + template + + _RAIter + is_heap_until(_RAIter, _RAIter, _Compare); + + template + + bool + is_partitioned(_IIter, _IIter, _Predicate); + + template + + bool + is_permutation(_FIter1, _FIter1, _FIter2); + + template + + bool + is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); + + template + + bool + is_sorted(_FIter, _FIter); + + template + + bool + is_sorted(_FIter, _FIter, _Compare); + + template + + _FIter + is_sorted_until(_FIter, _FIter); + + template + + _FIter + is_sorted_until(_FIter, _FIter, _Compare); + + + template + + void + iter_swap(_FIter1, _FIter2); + + template + + _FIter + lower_bound(_FIter, _FIter, const _Tp&); + + template + + _FIter + lower_bound(_FIter, _FIter, const _Tp&, _Compare); + + template + + void + make_heap(_RAIter, _RAIter); + + template + + void + make_heap(_RAIter, _RAIter, _Compare); + + template + constexpr + const _Tp& + max(const _Tp&, const _Tp&); + + template + constexpr + const _Tp& + max(const _Tp&, const _Tp&, _Compare); + + + + + template + constexpr + const _Tp& + min(const _Tp&, const _Tp&); + + template + constexpr + const _Tp& + min(const _Tp&, const _Tp&, _Compare); + + + + + template + constexpr + pair + minmax(const _Tp&, const _Tp&); + + template + constexpr + pair + minmax(const _Tp&, const _Tp&, _Compare); + + template + constexpr + pair<_FIter, _FIter> + minmax_element(_FIter, _FIter); + + template + constexpr + pair<_FIter, _FIter> + minmax_element(_FIter, _FIter, _Compare); + + template + constexpr + _Tp + min(initializer_list<_Tp>); + + template + constexpr + _Tp + min(initializer_list<_Tp>, _Compare); + + template + constexpr + _Tp + max(initializer_list<_Tp>); + + template + constexpr + _Tp + max(initializer_list<_Tp>, _Compare); + + template + constexpr + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>); + + template + constexpr + pair<_Tp, _Tp> + minmax(initializer_list<_Tp>, _Compare); + + + + + template + + bool + next_permutation(_BIter, _BIter); + + template + + bool + next_permutation(_BIter, _BIter, _Compare); + + + template + + bool + none_of(_IIter, _IIter, _Predicate); + + + + + + template + + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); + + template + + _RAIter + partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); + + + + + template + + pair<_OIter1, _OIter2> + partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); + + template + + _FIter + partition_point(_FIter, _FIter, _Predicate); + + + template + + void + pop_heap(_RAIter, _RAIter); + + template + + void + pop_heap(_RAIter, _RAIter, _Compare); + + template + + bool + prev_permutation(_BIter, _BIter); + + template + + bool + prev_permutation(_BIter, _BIter, _Compare); + + template + + void + push_heap(_RAIter, _RAIter); + + template + + void + push_heap(_RAIter, _RAIter, _Compare); + + + + template + + _FIter + remove(_FIter, _FIter, const _Tp&); + + template + + _FIter + remove_if(_FIter, _FIter, _Predicate); + + template + + _OIter + remove_copy(_IIter, _IIter, _OIter, const _Tp&); + + template + + _OIter + remove_copy_if(_IIter, _IIter, _OIter, _Predicate); + + + + template + + _OIter + replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); + + template + + _OIter + replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); + + + + template + + void + reverse(_BIter, _BIter); + + template + + _OIter + reverse_copy(_BIter, _BIter, _OIter); + +inline namespace _V2 { + + template + + _FIter + rotate(_FIter, _FIter, _FIter); + +} + + template + + _OIter + rotate_copy(_FIter, _FIter, _FIter, _OIter); +# 626 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 3 + template + void + shuffle(_RAIter, _RAIter, _UGenerator&&); + + + template + + void + sort_heap(_RAIter, _RAIter); + + template + + void + sort_heap(_RAIter, _RAIter, _Compare); + + + template + _BIter + stable_partition(_BIter, _BIter, _Predicate); +# 661 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 3 + template + + _FIter2 + swap_ranges(_FIter1, _FIter1, _FIter2); + + + + template + + _FIter + unique(_FIter, _FIter); + + template + + _FIter + unique(_FIter, _FIter, _BinaryPredicate); + + + + template + + _FIter + upper_bound(_FIter, _FIter, const _Tp&); + + template + + _FIter + upper_bound(_FIter, _FIter, const _Tp&, _Compare); + + + + template + + _FIter + adjacent_find(_FIter, _FIter); + + template + + _FIter + adjacent_find(_FIter, _FIter, _BinaryPredicate); + + template + + typename iterator_traits<_IIter>::difference_type + count(_IIter, _IIter, const _Tp&); + + template + + typename iterator_traits<_IIter>::difference_type + count_if(_IIter, _IIter, _Predicate); + + template + + bool + equal(_IIter1, _IIter1, _IIter2); + + template + + bool + equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + + _IIter + find(_IIter, _IIter, const _Tp&); + + template + + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); + + template + + _FIter1 + find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + + _IIter + find_if(_IIter, _IIter, _Predicate); + + template + + _Funct + for_each(_IIter, _IIter, _Funct); + + template + + void + generate(_FIter, _FIter, _Generator); + + template + + _OIter + generate_n(_OIter, _Size, _Generator); + + template + + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); + + template + + bool + lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); + + template + constexpr + _FIter + max_element(_FIter, _FIter); + + template + constexpr + _FIter + max_element(_FIter, _FIter, _Compare); + + template + + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + constexpr + _FIter + min_element(_FIter, _FIter); + + template + constexpr + _FIter + min_element(_FIter, _FIter, _Compare); + + template + + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2); + + template + + pair<_IIter1, _IIter2> + mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); + + template + + void + nth_element(_RAIter, _RAIter, _RAIter); + + template + + void + nth_element(_RAIter, _RAIter, _RAIter, _Compare); + + template + + void + partial_sort(_RAIter, _RAIter, _RAIter); + + template + + void + partial_sort(_RAIter, _RAIter, _RAIter, _Compare); + + template + + _BIter + partition(_BIter, _BIter, _Predicate); + + + template + __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) + void + random_shuffle(_RAIter, _RAIter); + + template + __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) + void + random_shuffle(_RAIter, _RAIter, + + _Generator&&); + + + + + + template + + void + replace(_FIter, _FIter, const _Tp&, const _Tp&); + + template + + void + replace_if(_FIter, _FIter, _Predicate, const _Tp&); + + template + + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2); + + template + + _FIter1 + search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); + + template + + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&); + + template + + _FIter + search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); + + template + + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, + _OIter, _Compare); + + template + + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); + + template + + _OIter + set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); + + template + + void + sort(_RAIter, _RAIter); + + template + + void + sort(_RAIter, _RAIter, _Compare); + + template + void + stable_sort(_RAIter, _RAIter); + + template + void + stable_sort(_RAIter, _RAIter, _Compare); + + template + + _OIter + transform(_IIter, _IIter, _OIter, _UnaryOperation); + + template + + _OIter + transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); + + template + + _OIter + unique_copy(_IIter, _IIter, _OIter); + + template + + _OIter + unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); + + + +} +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + + _Distance + __is_heap_until(_RandomAccessIterator __first, _Distance __n, + _Compare& __comp) + { + _Distance __parent = 0; + for (_Distance __child = 1; __child < __n; ++__child) + { + if (__comp(__first + __parent, __first + __child)) + return __child; + if ((__child & 1) == 0) + ++__parent; + } + return __n; + } + + + + template + + inline bool + __is_heap(_RandomAccessIterator __first, _Distance __n) + { + __gnu_cxx::__ops::_Iter_less_iter __comp; + return std::__is_heap_until(__first, __n, __comp) == __n; + } + + template + + inline bool + __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n) + { + typedef __decltype(__comp) _Cmp; + __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); + return std::__is_heap_until(__first, __n, __cmp) == __n; + } + + template + + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::__is_heap(__first, std::distance(__first, __last)); } + + template + + inline bool + __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + return std::__is_heap(__first, std::move(__comp), + std::distance(__first, __last)); + } + + + + + template + + void + __push_heap(_RandomAccessIterator __first, + _Distance __holeIndex, _Distance __topIndex, _Tp __value, + _Compare& __comp) + { + _Distance __parent = (__holeIndex - 1) / 2; + while (__holeIndex > __topIndex && __comp(__first + __parent, __value)) + { + *(__first + __holeIndex) = std::move(*(__first + __parent)); + __holeIndex = __parent; + __parent = (__holeIndex - 1) / 2; + } + *(__first + __holeIndex) = std::move(__value); + } +# 159 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline void + push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + + + + + ; + ; + ; + + __gnu_cxx::__ops::_Iter_less_val __comp; + _ValueType __value = std::move(*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), std::move(__value), __comp); + } +# 195 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline void + push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + + + + ; + ; + ; + + __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp))) + __cmp(std::move(__comp)); + _ValueType __value = std::move(*(__last - 1)); + std::__push_heap(__first, _DistanceType((__last - __first) - 1), + _DistanceType(0), std::move(__value), __cmp); + } + + template + + void + __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, + _Distance __len, _Tp __value, _Compare __comp) + { + const _Distance __topIndex = __holeIndex; + _Distance __secondChild = __holeIndex; + while (__secondChild < (__len - 1) / 2) + { + __secondChild = 2 * (__secondChild + 1); + if (__comp(__first + __secondChild, + __first + (__secondChild - 1))) + __secondChild--; + *(__first + __holeIndex) = std::move(*(__first + __secondChild)); + __holeIndex = __secondChild; + } + if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2) + { + __secondChild = 2 * (__secondChild + 1); + *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1))); + + __holeIndex = __secondChild - 1; + } + __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp))) + __cmp(std::move(__comp)); + std::__push_heap(__first, __holeIndex, __topIndex, + std::move(__value), __cmp); + } + + template + + inline void + __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _RandomAccessIterator __result, _Compare& __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + _ValueType __value = std::move(*__result); + *__result = std::move(*__first); + std::__adjust_heap(__first, _DistanceType(0), + _DistanceType(__last - __first), + std::move(__value), __comp); + } +# 280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline void + pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + ; + ; + + if (__last - __first > 1) + { + --__last; + __gnu_cxx::__ops::_Iter_less_iter __comp; + std::__pop_heap(__first, __last, __last, __comp); + } + } +# 314 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline void + pop_heap(_RandomAccessIterator __first, + _RandomAccessIterator __last, _Compare __comp) + { + + + + ; + ; + ; + ; + + if (__last - __first > 1) + { + typedef __decltype(__comp) _Cmp; + __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); + --__last; + std::__pop_heap(__first, __last, __last, __cmp); + } + } + + template + + void + __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare& __comp) + { + typedef typename iterator_traits<_RandomAccessIterator>::value_type + _ValueType; + typedef typename iterator_traits<_RandomAccessIterator>::difference_type + _DistanceType; + + if (__last - __first < 2) + return; + + const _DistanceType __len = __last - __first; + _DistanceType __parent = (__len - 2) / 2; + while (true) + { + _ValueType __value = std::move(*(__first + __parent)); + std::__adjust_heap(__first, __parent, __len, std::move(__value), + __comp); + if (__parent == 0) + return; + __parent--; + } + } +# 372 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + __gnu_cxx::__ops::_Iter_less_iter __comp; + std::__make_heap(__first, __last, __comp); + } +# 399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline void + make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + ; + ; + + typedef __decltype(__comp) _Cmp; + __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); + std::__make_heap(__first, __last, __cmp); + } + + template + + void + __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare& __comp) + { + while (__last - __first > 1) + { + --__last; + std::__pop_heap(__first, __last, __last, __comp); + } + } +# 437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + ; + + __gnu_cxx::__ops::_Iter_less_iter __comp; + std::__sort_heap(__first, __last, __comp); + } +# 465 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline void + sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + ; + ; + ; + + typedef __decltype(__comp) _Cmp; + __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); + std::__sort_heap(__first, __last, __cmp); + } +# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline _RandomAccessIterator + is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) + { + + + + + + ; + ; + + __gnu_cxx::__ops::_Iter_less_iter __comp; + return __first + + std::__is_heap_until(__first, std::distance(__first, __last), __comp); + } +# 523 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline _RandomAccessIterator + is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + ; + ; + + typedef __decltype(__comp) _Cmp; + __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); + return __first + + std::__is_heap_until(__first, std::distance(__first, __last), __cmp); + } +# 548 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) + { return std::is_heap_until(__first, __last) == __last; } +# 562 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 + template + + inline bool + is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Compare __comp) + { + + + + ; + ; + + const auto __dist = std::distance(__first, __last); + typedef __decltype(__comp) _Cmp; + __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); + return std::__is_heap_until(__first, __dist, __cmp) == __dist; + } + + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 2 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 1 3 +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 + namespace __detail + { + + + + template + constexpr bool + _Power_of_2(_Tp __x) + { + return ((__x - 1) & __x) == 0; + } + } +# 87 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 + template + class uniform_int_distribution + { + static_assert(std::is_integral<_IntType>::value, + "template argument must be an integral type"); + + public: + + typedef _IntType result_type; + + struct param_type + { + typedef uniform_int_distribution<_IntType> distribution_type; + + param_type() : param_type(0) { } + + explicit + param_type(_IntType __a, + _IntType __b = __gnu_cxx::__int_traits<_IntType>::__max) + : _M_a(__a), _M_b(__b) + { + do { if (std::__is_constant_evaluated() && !bool(_M_a <= _M_b)) __builtin_unreachable(); } while (false); + } + + result_type + a() const + { return _M_a; } + + result_type + b() const + { return _M_b; } + + friend bool + operator==(const param_type& __p1, const param_type& __p2) + { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } + + friend bool + operator!=(const param_type& __p1, const param_type& __p2) + { return !(__p1 == __p2); } + + private: + _IntType _M_a; + _IntType _M_b; + }; + + public: + + + + uniform_int_distribution() : uniform_int_distribution(0) { } + + + + + explicit + uniform_int_distribution(_IntType __a, + _IntType __b + = __gnu_cxx::__int_traits<_IntType>::__max) + : _M_param(__a, __b) + { } + + explicit + uniform_int_distribution(const param_type& __p) + : _M_param(__p) + { } + + + + + + + void + reset() { } + + result_type + a() const + { return _M_param.a(); } + + result_type + b() const + { return _M_param.b(); } + + + + + param_type + param() const + { return _M_param; } + + + + + + void + param(const param_type& __param) + { _M_param = __param; } + + + + + result_type + min() const + { return this->a(); } + + + + + result_type + max() const + { return this->b(); } + + + + + template + result_type + operator()(_UniformRandomBitGenerator& __urng) + { return this->operator()(__urng, _M_param); } + + template + result_type + operator()(_UniformRandomBitGenerator& __urng, + const param_type& __p); + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomBitGenerator& __urng) + { this->__generate(__f, __t, __urng, _M_param); } + + template + void + __generate(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomBitGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + template + void + __generate(result_type* __f, result_type* __t, + _UniformRandomBitGenerator& __urng, + const param_type& __p) + { this->__generate_impl(__f, __t, __urng, __p); } + + + + + + friend bool + operator==(const uniform_int_distribution& __d1, + const uniform_int_distribution& __d2) + { return __d1._M_param == __d2._M_param; } + + private: + template + void + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomBitGenerator& __urng, + const param_type& __p); + + param_type _M_param; + + + + + template + static _Up + _S_nd(_Urbg& __g, _Up __range) + { + using _Up_traits = __gnu_cxx::__int_traits<_Up>; + using _Wp_traits = __gnu_cxx::__int_traits<_Wp>; + static_assert(!_Up_traits::__is_signed, "U must be unsigned"); + static_assert(!_Wp_traits::__is_signed, "W must be unsigned"); + static_assert(_Wp_traits::__digits == (2 * _Up_traits::__digits), + "W must be twice as wide as U"); + + + + + _Wp __product = _Wp(__g()) * _Wp(__range); + _Up __low = _Up(__product); + if (__low < __range) + { + _Up __threshold = -__range % __range; + while (__low < __threshold) + { + __product = _Wp(__g()) * _Wp(__range); + __low = _Up(__product); + } + } + return __product >> _Up_traits::__digits; + } + }; + + template + template + typename uniform_int_distribution<_IntType>::result_type + uniform_int_distribution<_IntType>:: + operator()(_UniformRandomBitGenerator& __urng, + const param_type& __param) + { + typedef typename _UniformRandomBitGenerator::result_type _Gresult_type; + typedef typename make_unsigned::type __utype; + typedef typename common_type<_Gresult_type, __utype>::type __uctype; + + constexpr __uctype __urngmin = _UniformRandomBitGenerator::min(); + constexpr __uctype __urngmax = _UniformRandomBitGenerator::max(); + static_assert( __urngmin < __urngmax, + "Uniform random bit generator must define min() < max()"); + constexpr __uctype __urngrange = __urngmax - __urngmin; + + const __uctype __urange + = __uctype(__param.b()) - __uctype(__param.a()); + + __uctype __ret; + if (__urngrange > __urange) + { + + + const __uctype __uerange = __urange + 1; + + + + if constexpr (__urngrange == 18446744073709551615UL) + { + + + long unsigned int __u64erange = __uerange; + __ret = __extension__ _S_nd(__urng, + __u64erange); + } + else + + if constexpr (__urngrange == 4294967295U) + { + + + unsigned int __u32erange = __uerange; + __ret = _S_nd(__urng, __u32erange); + } + else + + { + + const __uctype __scaling = __urngrange / __uerange; + const __uctype __past = __uerange * __scaling; + do + __ret = __uctype(__urng()) - __urngmin; + while (__ret >= __past); + __ret /= __scaling; + } + } + else if (__urngrange < __urange) + { +# 359 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 + __uctype __tmp; + do + { + const __uctype __uerngrange = __urngrange + 1; + __tmp = (__uerngrange * operator() + (__urng, param_type(0, __urange / __uerngrange))); + __ret = __tmp + (__uctype(__urng()) - __urngmin); + } + while (__ret > __urange || __ret < __tmp); + } + else + __ret = __uctype(__urng()) - __urngmin; + + return __ret + __param.a(); + } + + + template + template + void + uniform_int_distribution<_IntType>:: + __generate_impl(_ForwardIterator __f, _ForwardIterator __t, + _UniformRandomBitGenerator& __urng, + const param_type& __param) + { + + typedef typename _UniformRandomBitGenerator::result_type _Gresult_type; + typedef typename make_unsigned::type __utype; + typedef typename common_type<_Gresult_type, __utype>::type __uctype; + + static_assert( __urng.min() < __urng.max(), + "Uniform random bit generator must define min() < max()"); + + constexpr __uctype __urngmin = __urng.min(); + constexpr __uctype __urngmax = __urng.max(); + constexpr __uctype __urngrange = __urngmax - __urngmin; + const __uctype __urange + = __uctype(__param.b()) - __uctype(__param.a()); + + __uctype __ret; + + if (__urngrange > __urange) + { + if (__detail::_Power_of_2(__urngrange + 1) + && __detail::_Power_of_2(__urange + 1)) + { + while (__f != __t) + { + __ret = __uctype(__urng()) - __urngmin; + *__f++ = (__ret & __urange) + __param.a(); + } + } + else + { + + const __uctype __uerange = __urange + 1; + const __uctype __scaling = __urngrange / __uerange; + const __uctype __past = __uerange * __scaling; + while (__f != __t) + { + do + __ret = __uctype(__urng()) - __urngmin; + while (__ret >= __past); + *__f++ = __ret / __scaling + __param.a(); + } + } + } + else if (__urngrange < __urange) + { +# 444 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 + __uctype __tmp; + while (__f != __t) + { + do + { + constexpr __uctype __uerngrange = __urngrange + 1; + __tmp = (__uerngrange * operator() + (__urng, param_type(0, __urange / __uerngrange))); + __ret = __tmp + (__uctype(__urng()) - __urngmin); + } + while (__ret > __urange || __ret < __tmp); + *__f++ = __ret; + } + } + else + while (__f != __t) + *__f++ = __uctype(__urng()) - __urngmin + __param.a(); + } + + + + +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 2 3 + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 +# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 59 "/usr/include/stdlib.h" 3 4 +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 159 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") + + + __attribute__ ((__nonnull__ (1))); +extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); +# 278 "/usr/include/stdlib.h" 3 4 +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 298 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 316 "/usr/include/stdlib.h" 3 4 +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 340 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + + + + + +extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") + + + + __attribute__ ((__nonnull__ (1, 4))); +extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +# 415 "/usr/include/stdlib.h" 3 4 +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 436 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 457 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 480 "/usr/include/stdlib.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) int + atoi (const char *__nptr) noexcept (true) +{ + return (int) strtol (__nptr, (char **) __null, 10); +} +extern __inline __attribute__ ((__gnu_inline__)) long int + atol (const char *__nptr) noexcept (true) +{ + return strtol (__nptr, (char **) __null, 10); +} + + +__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int + atoll (const char *__nptr) noexcept (true) +{ + return strtoll (__nptr, (char **) __null, 10); +} +# 505 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 27 "/usr/include/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; +# 103 "/usr/include/sys/types.h" 3 4 +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; +# 134 "/usr/include/sys/types.h" 3 4 +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 145 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + + + + +typedef __uint8_t u_int8_t; +typedef __uint16_t u_int16_t; +typedef __uint32_t u_int32_t; +typedef __uint64_t u_int64_t; + + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 176 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + + + return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8))); + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + + + return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); + +} +# 69 "/usr/include/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + + + return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56)); + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 + + + + + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 +# 49 "/usr/include/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/sys/select.h" 3 4 +} +# 180 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; +# 230 "/usr/include/sys/types.h" 3 4 +} +# 515 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern __uint32_t arc4random (void) + noexcept (true) ; + + +extern void arc4random_buf (void *__buf, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) + noexcept (true) ; + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) ; + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + + ; + + +extern void *reallocarray (void *__ptr, size_t __nmemb, s \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/__cpp_text_pipeline.cpp-cd270745.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/__cpp_text_pipeline.cpp-cd270745.cpp.tmp new file mode 100644 index 0000000..3a96fde --- /dev/null +++ b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/__cpp_text_pipeline.cpp-cd270745.cpp.tmp @@ -0,0 +1,37918 @@ +# 1 "src/renderer/text_pipeline.cpp" +# 1 "" 1 +# 1 "" 3 +# 433 "" 3 +# 1 "" 1 +# 1 "" 2 +# 1 "src/renderer/text_pipeline.cpp" 2 +# 14 "src/renderer/text_pipeline.cpp" +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 +# 31 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__)); + terminate(); + } +#pragma GCC visibility pop +} +# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 3 +# 1 "/usr/include/features.h" 1 3 4 +# 394 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 395 "/usr/include/features.h" 2 3 4 +# 481 "/usr/include/features.h" 3 4 +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 482 "/usr/include/features.h" 2 3 4 +# 503 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 576 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 577 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 578 "/usr/include/sys/cdefs.h" 2 3 4 +# 504 "/usr/include/features.h" 2 3 4 +# 527 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 528 "/usr/include/features.h" 2 3 4 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3 +# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 2 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 1 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 + template + class allocator; + + template<> + class allocator; + + + + + template + struct uses_allocator; + + template + struct allocator_traits; + + + + + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 + template + struct char_traits; + + template<> struct char_traits; + + template<> struct char_traits; + + + + + + + template<> struct char_traits; + template<> struct char_traits; + + +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_string; + +} + + + typedef basic_string string; + + + typedef basic_string wstring; +# 89 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 + typedef basic_string u16string; + + + typedef basic_string u32string; + + + + + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 27 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/include/bits/floatn.h" 1 3 4 +# 119 "/usr/include/bits/floatn.h" 3 4 +# 1 "/usr/include/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/bits/floatn-common.h" 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 25 "/usr/include/bits/floatn-common.h" 2 3 4 +# 214 "/usr/include/bits/floatn-common.h" 3 4 +typedef float _Float32; +# 251 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float64; +# 268 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float32x; +# 285 "/usr/include/bits/floatn-common.h" 3 4 +typedef long double _Float64x; +# 120 "/usr/include/bits/floatn.h" 2 3 4 +# 31 "/usr/include/wchar.h" 2 3 4 + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 36 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 +# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 39 "/usr/include/wchar.h" 2 3 4 + + + + +typedef __gnuc_va_list va_list; + + + + + + + +# 1 "/usr/include/bits/wchar.h" 1 3 4 +# 52 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 +# 20 "/usr/include/bits/types/wint_t.h" 3 4 +typedef unsigned int wint_t; +# 53 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 + + + +# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 +# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 +typedef struct +{ + int __count; + union + { + unsigned int __wch; + char __wchb[4]; + } __value; +} __mbstate_t; +# 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4 + +typedef __mbstate_t mbstate_t; +# 54 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 + + + +struct _IO_FILE; +typedef struct _IO_FILE __FILE; +# 55 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/include/bits/types/FILE.h" 1 3 4 + + + +struct _IO_FILE; + + +typedef struct _IO_FILE FILE; +# 58 "/usr/include/wchar.h" 2 3 4 + + +# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 61 "/usr/include/wchar.h" 2 3 4 +# 90 "/usr/include/wchar.h" 3 4 +extern "C" { + + + +struct tm; + + + +extern wchar_t *wcscpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern wchar_t *wcsncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern size_t wcslcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern size_t wcslcat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern wchar_t *wcscat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern wchar_t *wcsncat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + +extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, + size_t __n) noexcept (true); + + + +extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + +extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + + + +extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + + +extern size_t wcsxfrm (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + + + + + +extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + + + + +extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + +extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) + __attribute__ ((__malloc__)) ; +# 189 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); +# 199 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + +extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) + noexcept (true) __attribute__ ((__pure__)); + + +extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 226 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 237 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + +extern wchar_t *wcstok (wchar_t *__restrict __s, + const wchar_t *__restrict __delim, + wchar_t **__restrict __ptr) noexcept (true); + + +extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); +# 258 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)); +# 278 "/usr/include/wchar.h" 3 4 +extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + + +extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + +extern wchar_t *wmemcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + +extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true); + + +extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); + + + + +extern wchar_t *wmempcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) + noexcept (true); + + + + + +extern wint_t btowc (int __c) noexcept (true); + + + +extern int wctob (wint_t __c) noexcept (true); + + + +extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); + + + +extern size_t mbrtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n, + mbstate_t *__restrict __p) noexcept (true); + + +extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, + mbstate_t *__restrict __ps) noexcept (true); + + +extern size_t __mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); +extern size_t mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + + +extern wint_t __btowc_alias (int __c) __asm ("btowc"); +extern __inline __attribute__ ((__gnu_inline__)) wint_t + btowc (int __c) noexcept (true) +{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' + ? (wint_t) __c : __btowc_alias (__c)); } + +extern int __wctob_alias (wint_t __c) __asm ("wctob"); +extern __inline __attribute__ ((__gnu_inline__)) int + wctob (wint_t __wc) noexcept (true) +{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' + ? (int) __wc : __wctob_alias (__wc)); } + +extern __inline __attribute__ ((__gnu_inline__)) size_t + mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) + +{ return (__ps != __null + ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } + + + + +extern size_t mbsrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + +extern size_t mbsnrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsnrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + +extern int wcwidth (wchar_t __c) noexcept (true); + + + +extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); + + + + + +extern double wcstod (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern float wcstof (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +extern long double wcstold (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 422 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 437 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 455 "/usr/include/wchar.h" 3 4 +extern long int wcstol (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) noexcept (true); + + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + + +extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); +# 561 "/usr/include/wchar.h" 3 4 +extern long int wcstol_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base, + locale_t __loc) noexcept (true); + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true); + + + + + +extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); + + + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); + + + + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); + + + + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); +# 630 "/usr/include/wchar.h" 3 4 +extern double wcstod_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern float wcstof_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern long double wcstold_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 649 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 667 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 689 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcpcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) noexcept (true); + + + +extern wchar_t *wcpncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true); +# 718 "/usr/include/wchar.h" 3 4 +extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern int fwide (__FILE *__fp, int __mode) noexcept (true); + + + + + + +extern int fwprintf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wprintf (const wchar_t *__restrict __format, ...) + ; + +extern int swprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, ...) + noexcept (true) ; + + + + + +extern int vfwprintf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwprintf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + +extern int vswprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; + + + + + + +extern int fwscanf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wscanf (const wchar_t *__restrict __format, ...) + ; + +extern int swscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, ...) + noexcept (true) ; +# 795 "/usr/include/wchar.h" 3 4 +extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") + + + ; +extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") + + ; +extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") + + + ; +# 851 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwscanf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + +extern int vswscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; +# 875 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") + + + ; +extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") + + ; +extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") + + + ; +# 935 "/usr/include/wchar.h" 3 4 +extern wint_t fgetwc (__FILE *__stream); +extern wint_t getwc (__FILE *__stream); + + + + + +extern wint_t getwchar (void); + + + + + + +extern wint_t fputwc (wchar_t __wc, __FILE *__stream); +extern wint_t putwc (wchar_t __wc, __FILE *__stream); + + + + + +extern wint_t putwchar (wchar_t __wc); + + + + + + + +extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + +extern int fputws (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern wint_t ungetwc (wint_t __wc, __FILE *__stream); +# 990 "/usr/include/wchar.h" 3 4 +extern wint_t getwc_unlocked (__FILE *__stream); +extern wint_t getwchar_unlocked (void); + + + + + + + +extern wint_t fgetwc_unlocked (__FILE *__stream); + + + + + + + +extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); +# 1016 "/usr/include/wchar.h" 3 4 +extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); +extern wint_t putwchar_unlocked (wchar_t __wc); +# 1026 "/usr/include/wchar.h" 3 4 +extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + + + +extern int fputws_unlocked (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp) noexcept (true); + + + + +extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); +# 1073 "/usr/include/wchar.h" 3 4 +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 2 3 +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +namespace std +{ + using ::mbstate_t; +} +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::wint_t; + + using ::btowc; + using ::fgetwc; + using ::fgetws; + using ::fputwc; + using ::fputws; + using ::fwide; + using ::fwprintf; + using ::fwscanf; + using ::getwc; + using ::getwchar; + using ::mbrlen; + using ::mbrtowc; + using ::mbsinit; + using ::mbsrtowcs; + using ::putwc; + using ::putwchar; + + using ::swprintf; + + using ::swscanf; + using ::ungetwc; + using ::vfwprintf; + + using ::vfwscanf; + + + using ::vswprintf; + + + using ::vswscanf; + + using ::vwprintf; + + using ::vwscanf; + + using ::wcrtomb; + using ::wcscat; + using ::wcscmp; + using ::wcscoll; + using ::wcscpy; + using ::wcscspn; + using ::wcsftime; + using ::wcslen; + using ::wcsncat; + using ::wcsncmp; + using ::wcsncpy; + using ::wcsrtombs; + using ::wcsspn; + using ::wcstod; + + using ::wcstof; + + using ::wcstok; + using ::wcstol; + using ::wcstoul; + using ::wcsxfrm; + using ::wctob; + using ::wmemcmp; + using ::wmemcpy; + using ::wmemmove; + using ::wmemset; + using ::wprintf; + using ::wscanf; + using ::wcschr; + using ::wcspbrk; + using ::wcsrchr; + using ::wcsstr; + using ::wmemchr; + + + inline wchar_t* + wcschr(wchar_t* __p, wchar_t __c) + { return wcschr(const_cast(__p), __c); } + + inline wchar_t* + wcspbrk(wchar_t* __s1, const wchar_t* __s2) + { return wcspbrk(const_cast(__s1), __s2); } + + inline wchar_t* + wcsrchr(wchar_t* __p, wchar_t __c) + { return wcsrchr(const_cast(__p), __c); } + + inline wchar_t* + wcsstr(wchar_t* __s1, const wchar_t* __s2) + { return wcsstr(const_cast(__s1), __s2); } + + inline wchar_t* + wmemchr(wchar_t* __p, wchar_t __c, size_t __n) + { return wmemchr(const_cast(__p), __c, __n); } + + + +} +} + + + + + + + +namespace __gnu_cxx +{ + + + + + + using ::wcstold; +# 260 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 + using ::wcstoll; + using ::wcstoull; + +} + +namespace std +{ + using ::__gnu_cxx::wcstold; + using ::__gnu_cxx::wcstoll; + using ::__gnu_cxx::wcstoull; +} +# 280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +namespace std +{ + + using std::wcstof; + + + using std::vfwscanf; + + + using std::vswscanf; + + + using std::vwscanf; + + + + using std::wcstold; + using std::wcstoll; + using std::wcstoull; + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + typedef long int streamoff; + + + + + + typedef ptrdiff_t streamsize; +# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + template + class fpos + { + private: + streamoff _M_off; + _StateT _M_state; + + public: + + + + + fpos() + : _M_off(0), _M_state() { } +# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + fpos(streamoff __off) + : _M_off(__off), _M_state() { } + + + fpos(const fpos&) = default; + fpos& operator=(const fpos&) = default; + ~fpos() = default; + + + + operator streamoff() const { return _M_off; } + + + void + state(_StateT __st) + { _M_state = __st; } + + + _StateT + state() const + { return _M_state; } + + + + + + fpos& + operator+=(streamoff __off) + { + _M_off += __off; + return *this; + } + + + + + + fpos& + operator-=(streamoff __off) + { + _M_off -= __off; + return *this; + } + + + + + + + + fpos + operator+(streamoff __off) const + { + fpos __pos(*this); + __pos += __off; + return __pos; + } + + + + + + + + fpos + operator-(streamoff __off) const + { + fpos __pos(*this); + __pos -= __off; + return __pos; + } + + + + + + + streamoff + operator-(const fpos& __other) const + { return _M_off - __other._M_off; } + }; + + + + + + + template + inline bool + operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) == streamoff(__rhs); } + + template + inline bool + operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) + { return streamoff(__lhs) != streamoff(__rhs); } + + + + + + typedef fpos streampos; + + typedef fpos wstreampos; +# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 + typedef fpos u16streampos; + + typedef fpos u32streampos; + + + +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 76 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 + class ios_base; + + template > + class basic_ios; + + template > + class basic_streambuf; + + template > + class basic_istream; + + template > + class basic_ostream; + + template > + class basic_iostream; + + +namespace __cxx11 { + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringbuf; + + template, + typename _Alloc = allocator<_CharT> > + class basic_istringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_ostringstream; + + template, + typename _Alloc = allocator<_CharT> > + class basic_stringstream; + +} + + template > + class basic_filebuf; + + template > + class basic_ifstream; + + template > + class basic_ofstream; + + template > + class basic_fstream; + + template > + class istreambuf_iterator; + + template > + class ostreambuf_iterator; + + + + typedef basic_ios ios; + + + typedef basic_streambuf streambuf; + + + typedef basic_istream istream; + + + typedef basic_ostream ostream; + + + typedef basic_iostream iostream; + + + typedef basic_stringbuf stringbuf; + + + typedef basic_istringstream istringstream; + + + typedef basic_ostringstream ostringstream; + + + typedef basic_stringstream stringstream; + + + typedef basic_filebuf filebuf; + + + typedef basic_ifstream ifstream; + + + typedef basic_ofstream ofstream; + + + typedef basic_fstream fstream; + + + + typedef basic_ios wios; + + + typedef basic_streambuf wstreambuf; + + + typedef basic_istream wistream; + + + typedef basic_ostream wostream; + + + typedef basic_iostream wiostream; + + + typedef basic_stringbuf wstringbuf; + + + typedef basic_istringstream wistringstream; + + + typedef basic_ostringstream wostringstream; + + + typedef basic_stringstream wstringstream; + + + typedef basic_filebuf wfilebuf; + + + typedef basic_ifstream wifstream; + + + typedef basic_ofstream wofstream; + + + typedef basic_fstream wfstream; +# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 + class exception + { + public: + exception() noexcept { } + virtual ~exception() noexcept; + + exception(const exception&) = default; + exception& operator=(const exception&) = default; + exception(exception&&) = default; + exception& operator=(exception&&) = default; + + + + + virtual const char* + what() const noexcept; + }; + + + +} + +} +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + class bad_exception : public exception + { + public: + bad_exception() noexcept { } + + + + virtual ~bad_exception() noexcept; + + + virtual const char* + what() const noexcept; + }; + + + typedef void (*terminate_handler) (); + + + terminate_handler set_terminate(terminate_handler) noexcept; + + + + terminate_handler get_terminate() noexcept; + + + + + void terminate() noexcept __attribute__ ((__noreturn__)); + + + + typedef void (*__attribute__ ((__deprecated__)) unexpected_handler) (); + + + + + + __attribute__ ((__deprecated__)) + unexpected_handler set_unexpected(unexpected_handler) noexcept; + + + + + + + + __attribute__ ((__deprecated__)) + unexpected_handler get_unexpected() noexcept; + + + + + + + + __attribute__ ((__deprecated__)) + void unexpected() __attribute__ ((__noreturn__)); +# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + __attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "' instead"))) + bool uncaught_exception() noexcept __attribute__ ((__pure__)); + + + + + + + + int uncaught_exceptions() noexcept __attribute__ ((__pure__)); + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 + void __verbose_terminate_handler(); + + +} + +} + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 + +#pragma GCC visibility push(default) + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 +# 35 "/usr/lib/clang/16/include/stddef.h" 3 +typedef long int ptrdiff_t; +# 109 "/usr/lib/clang/16/include/stddef.h" 3 +# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 +# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 +typedef struct { + long long __clang_max_align_nonce1 + __attribute__((__aligned__(__alignof__(long long)))); + long double __clang_max_align_nonce2 + __attribute__((__aligned__(__alignof__(long double)))); +} max_align_t; +# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 2 3 +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 +namespace std +{ + class type_info; +} + +namespace __cxxabiv1 +{ + struct __cxa_refcounted_exception; + + extern "C" + { + + void* + __cxa_allocate_exception(size_t) noexcept; + + void + __cxa_free_exception(void*) noexcept; + + + __cxa_refcounted_exception* + __cxa_init_primary_exception(void *__object, std::type_info *__tinfo, + void ( *__dest) (void *)) + noexcept; + + } +} + + + +#pragma GCC visibility pop +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hash_bytes.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 2 3 + + +#pragma GCC visibility push(default) + + + + + +extern "C++" { + +namespace __cxxabiv1 +{ + class __class_type_info; +} +# 84 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 +namespace std +{ + + + + + + + class type_info + { + public: + + + + + virtual ~type_info(); + + + + const char* name() const noexcept + { return __name[0] == '*' ? __name + 1 : __name; } + + + + bool before(const type_info& __arg) const noexcept; + + + bool operator==(const type_info& __arg) const noexcept; + + + 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&) = delete; + type_info(const type_info&) = delete; +# 167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + }; + + + inline bool + type_info::before(const type_info& __arg) const noexcept + { + + + + + if (__name[0] != '*' || __arg.__name[0] != '*') + return __builtin_strcmp (__name, __arg.__name) < 0; +# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + return __name < __arg.__name; + } + + + + inline bool + type_info::operator==(const type_info& __arg) const noexcept + { + if (std::__is_constant_evaluated()) + return this == &__arg; + + if (__name == __arg.__name) + return true; + + + + + + + return __name[0] != '*' && __builtin_strcmp (__name, __arg.name()) == 0; + + + + } +# 220 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 + class bad_cast : public exception + { + public: + bad_cast() noexcept { } + + + + virtual ~bad_cast() noexcept; + + + virtual const char* what() const noexcept; + }; + + + + + + class bad_typeid : public exception + { + public: + bad_typeid () noexcept { } + + + + virtual ~bad_typeid() noexcept; + + + virtual const char* what() const noexcept; + }; +} + +} + +#pragma GCC visibility pop +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 + + + + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace std +{ + + + + + + + class bad_alloc : public exception + { + public: + bad_alloc() throw() { } + + + bad_alloc(const bad_alloc&) = default; + bad_alloc& operator=(const bad_alloc&) = default; + + + + + virtual ~bad_alloc() throw(); + + + virtual const char* what() const throw(); + }; + + + class bad_array_new_length : public bad_alloc + { + public: + bad_array_new_length() throw() { } + + + + virtual ~bad_array_new_length() throw(); + + + virtual const char* what() const throw(); + }; + + + + enum class align_val_t: size_t {}; + + + struct nothrow_t + { + + explicit nothrow_t() = default; + + }; + + extern const nothrow_t nothrow; + + + + typedef void (*new_handler)(); + + + + new_handler set_new_handler(new_handler) throw(); + + + + new_handler get_new_handler() noexcept; + +} +# 126 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +[[__nodiscard__]] void* operator new(std::size_t) + __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t) + __attribute__((__externally_visible__)); +void operator delete(void*) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*) noexcept + __attribute__((__externally_visible__)); + + + + + + +[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); + +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete(void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete[](void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete[](void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept +{ return __p; } +[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept +{ return __p; } + + +inline void operator delete (void*, void*) noexcept { } +inline void operator delete[](void*, void*) noexcept { } + +} + + +namespace std +{ + + + + template + [[nodiscard]] constexpr _Tp* + launder(_Tp* __p) noexcept + { return __builtin_launder(__p); } + + + + + template + void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; + template + void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; + + void launder(void*) = delete; + void launder(const void*) = delete; + void launder(volatile void*) = delete; + void launder(const volatile void*) = delete; + + + + + + + +} +# 236 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +#pragma GCC visibility pop +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } + + }; + + + + + + + + using true_type = integral_constant; + + + using false_type = integral_constant; + + + + template + using __bool_constant = integral_constant; + + + + + + + template + using bool_constant = integral_constant; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + template + struct is_reference + : public false_type + { }; + + template + struct is_reference<_Tp&> + : public true_type + { }; + + template + struct is_reference<_Tp&&> + : public true_type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long +# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long +# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __is_nothrow_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + template + struct is_same + + : public integral_constant + + + + { }; +# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; +# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_reference + { using type = _Tp; }; + + template + struct remove_reference<_Tp&> + { using type = _Tp; }; + + template + struct remove_reference<_Tp&&> + { using type = _Tp; }; + + + + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { 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; }; +# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; +# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __type; + }; + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; +# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template::value> + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + + template using void_t = void; +# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + + + bool _Dangle = false + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + +template + inline constexpr bool is_array_v = false; +template + inline constexpr bool is_array_v<_Tp[]> = true; +template + inline constexpr bool is_array_v<_Tp[_Num]> = true; + +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; +template + inline constexpr bool is_member_object_pointer_v = + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v = + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); +template + inline constexpr bool is_function_v = is_function<_Tp>::value; +template + inline constexpr bool is_reference_v = false; +template + inline constexpr bool is_reference_v<_Tp&> = true; +template + inline constexpr bool is_reference_v<_Tp&&> = true; +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; +template + inline constexpr bool is_object_v = is_object<_Tp>::value; +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +} +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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]); + } + + + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 + + + + + + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + class type_info; + + + + + + + namespace __exception_ptr + { + class exception_ptr; + } + + using __exception_ptr::exception_ptr; +# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + exception_ptr current_exception() noexcept; + + template + exception_ptr make_exception_ptr(_Ex) noexcept; + + + void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); + + namespace __exception_ptr + { + using std::rethrow_exception; +# 97 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + class exception_ptr + { + void* _M_exception_object; + + explicit exception_ptr(void* __e) noexcept; + + void _M_addref() noexcept; + void _M_release() noexcept; + + void *_M_get() const noexcept __attribute__ ((__pure__)); + + friend exception_ptr std::current_exception() noexcept; + friend void std::rethrow_exception(exception_ptr); + template + friend exception_ptr std::make_exception_ptr(_Ex) noexcept; + + public: + exception_ptr() noexcept; + + exception_ptr(const exception_ptr&) noexcept; + + + exception_ptr(nullptr_t) noexcept + : _M_exception_object(nullptr) + { } + + exception_ptr(exception_ptr&& __o) noexcept + : _M_exception_object(__o._M_exception_object) + { __o._M_exception_object = nullptr; } +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +# 162 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + explicit operator bool() const noexcept + { return _M_exception_object; } + + + + + + + + friend bool + operator==(const exception_ptr& __x, const exception_ptr& __y) + noexcept + { return __x._M_exception_object == __y._M_exception_object; } + + friend bool + operator!=(const exception_ptr& __x, const exception_ptr& __y) + noexcept + { return __x._M_exception_object != __y._M_exception_object; } + + + const class std::type_info* + __cxa_exception_type() const noexcept + __attribute__ ((__pure__)); + }; + + + inline + exception_ptr::exception_ptr() noexcept + : _M_exception_object(0) + { } + + + inline + exception_ptr::exception_ptr(const exception_ptr& __other) + noexcept + : _M_exception_object(__other._M_exception_object) + { + if (_M_exception_object) + _M_addref(); + } + + + inline + exception_ptr::~exception_ptr() noexcept + { + if (_M_exception_object) + _M_release(); + } + + + inline exception_ptr& + exception_ptr::operator=(const exception_ptr& __other) noexcept + { + exception_ptr(__other).swap(*this); + return *this; + } + + + inline void + exception_ptr::swap(exception_ptr &__other) noexcept + { + void *__tmp = _M_exception_object; + _M_exception_object = __other._M_exception_object; + __other._M_exception_object = __tmp; + } + + + inline void + swap(exception_ptr& __lhs, exception_ptr& __rhs) + { __lhs.swap(__rhs); } + + + template + + inline void + __dest_thunk(void* __x) + { static_cast<_Ex*>(__x)->~_Ex(); } + + + } + + using __exception_ptr::swap; + + + + template + exception_ptr + make_exception_ptr(_Ex __ex) noexcept + { + + using _Ex2 = typename decay<_Ex>::type; + void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); + (void) __cxxabiv1::__cxa_init_primary_exception( + __e, const_cast(&typeid(_Ex)), + __exception_ptr::__dest_thunk<_Ex2>); + try + { + ::new (__e) _Ex2(__ex); + return exception_ptr(__e); + } + catch(...) + { + __cxxabiv1::__cxa_free_exception(__e); + return current_exception(); + } +# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 + } +# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 +} + +} +# 165 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + class nested_exception + { + exception_ptr _M_ptr; + + public: + + nested_exception() noexcept : _M_ptr(current_exception()) { } + + nested_exception(const nested_exception&) noexcept = 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)) + { } + }; +# 145 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + 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"); + + + if constexpr (is_class_v<_Up>) + if constexpr (!is_final_v<_Up>) + if constexpr (!is_base_of_v) + throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; + throw std::forward<_Tp>(__t); + + + + + + } +# 203 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + template + + + + inline void + rethrow_if_nested(const _Ex& __ex) + { + const _Ex* __ptr = __builtin_addressof(__ex); +# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 + if constexpr (!is_polymorphic_v<_Ex>) + return; + else if constexpr (is_base_of_v + && !is_convertible_v<_Ex*, nested_exception*>) + return; + + + + + else if (auto __ne_ptr = dynamic_cast(__ptr)) + __ne_ptr->rethrow_nested(); + + } + + +} + +} +# 166 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 + + + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 2 3 +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + +#pragma GCC diagnostic push + + +#pragma GCC diagnostic ignored "-Warray-bounds" +# 83 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 + template + struct _Char_types + { + typedef unsigned long int_type; + + typedef std::streampos pos_type; + typedef std::streamoff off_type; + typedef std::mbstate_t state_type; + + }; +# 110 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 + template + struct char_traits + { + typedef _CharT char_type; + typedef typename _Char_types<_CharT>::int_type int_type; + + typedef typename _Char_types<_CharT>::pos_type pos_type; + typedef typename _Char_types<_CharT>::off_type off_type; + typedef typename _Char_types<_CharT>::state_type state_type; + + + + + + static constexpr void + assign(char_type& __c1, const char_type& __c2) + { + + + + + + __c1 = __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) + { return __c1 < __c2; } + + static constexpr int + compare(const char_type* __s1, const char_type* __s2, std::size_t __n); + + static constexpr std::size_t + length(const char_type* __s); + + static constexpr const char_type* + find(const char_type* __s, std::size_t __n, const char_type& __a); + + static char_type* + move(char_type* __s1, const char_type* __s2, std::size_t __n); + + static char_type* + copy(char_type* __s1, const char_type* __s2, std::size_t __n); + + static char_type* + assign(char_type* __s, std::size_t __n, char_type __a); + + static constexpr char_type + to_char_type(const int_type& __c) + { return static_cast(__c); } + + static constexpr int_type + to_int_type(const char_type& __c) + { return static_cast(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) + { return __c1 == __c2; } + + + static constexpr int_type + eof() + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) + { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } + + }; + + template + constexpr int + char_traits<_CharT>:: + compare(const char_type* __s1, const char_type* __s2, std::size_t __n) + { + for (std::size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + template + constexpr std::size_t + char_traits<_CharT>:: + length(const char_type* __p) + { + std::size_t __i = 0; + while (!eq(__p[__i], char_type())) + ++__i; + return __i; + } + + template + constexpr const typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + find(const char_type* __s, std::size_t __n, const char_type& __a) + { + for (std::size_t __i = 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + template + + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + move(char_type* __s1, const char_type* __s2, std::size_t __n) + { + if (__n == 0) + return __s1; +# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 + __builtin_memmove(__s1, __s2, __n * sizeof(char_type)); + return __s1; + } + + template + + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + copy(char_type* __s1, const char_type* __s2, std::size_t __n) + { + if (__n == 0) + return __s1; +# 276 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 + __builtin_memcpy(__s1, __s2, __n * sizeof(char_type)); + return __s1; + } + + template + + typename char_traits<_CharT>::char_type* + char_traits<_CharT>:: + assign(char_type* __s, std::size_t __n, char_type __a) + { +# 295 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 + if constexpr (sizeof(_CharT) == 1 && __is_trivial(_CharT)) + { + if (__n) + { + unsigned char __c; + __builtin_memcpy(&__c, __builtin_addressof(__a), 1); + __builtin_memset(__s, __c, __n); + } + } + else + { + for (std::size_t __i = 0; __i < __n; ++__i) + __s[__i] = __a; + } + return __s; + } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 + template + struct char_traits : public __gnu_cxx::char_traits<_CharT> + { }; + + + + template<> + struct char_traits + { + typedef char char_type; + typedef int int_type; + + typedef streampos pos_type; + typedef streamoff off_type; + typedef mbstate_t state_type; + + + + + + static constexpr void + assign(char_type& __c1, const char_type& __c2) noexcept + { + + + + + + __c1 = __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { + + return (static_cast(__c1) + < static_cast(__c2)); + } + + static constexpr int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return 0; + + if (std::__is_constant_evaluated()) + { + for (size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + return __builtin_memcmp(__s1, __s2, __n); + } + + static constexpr size_t + length(const char_type* __s) + { + + if (std::__is_constant_evaluated()) + return __gnu_cxx::char_traits::length(__s); + + return __builtin_strlen(__s); + } + + static constexpr const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + if (__n == 0) + return 0; + + if (std::__is_constant_evaluated()) + return __gnu_cxx::char_traits::find(__s, __n, __a); + + return static_cast(__builtin_memchr(__s, __a, __n)); + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + + + + + return static_cast(__builtin_memmove(__s1, __s2, __n)); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + + + + + return static_cast(__builtin_memcpy(__s1, __s2, __n)); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + if (__n == 0) + return __s; + + + + + return static_cast(__builtin_memset(__s, __a, __n)); + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return static_cast(__c); } + + + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return static_cast(static_cast(__c)); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + + static constexpr int_type + eof() noexcept + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return (__c == eof()) ? 0 : __c; } + + }; + + + + + template<> + struct char_traits + { + typedef wchar_t char_type; + typedef wint_t int_type; + + typedef streamoff off_type; + typedef wstreampos pos_type; + typedef mbstate_t state_type; + + + + + + static constexpr void + assign(char_type& __c1, const char_type& __c2) noexcept + { + + + + + + __c1 = __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 < __c2; } + + static constexpr int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return 0; + + if (std::__is_constant_evaluated()) + return __gnu_cxx::char_traits::compare(__s1, __s2, __n); + + return wmemcmp(__s1, __s2, __n); + } + + static constexpr size_t + length(const char_type* __s) + { + + if (std::__is_constant_evaluated()) + return __gnu_cxx::char_traits::length(__s); + + return wcslen(__s); + } + + static constexpr const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + if (__n == 0) + return 0; + + if (std::__is_constant_evaluated()) + return __gnu_cxx::char_traits::find(__s, __n, __a); + + return wmemchr(__s, __a, __n); + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + + + + + return wmemmove(__s1, __s2, __n); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + + + + + return wmemcpy(__s1, __s2, __n); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + if (__n == 0) + return __s; + + + + + return wmemset(__s, __a, __n); + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return char_type(__c); } + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return int_type(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + + static constexpr int_type + eof() noexcept + { return static_cast((0xffffffffu)); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return eq_int_type(__c, eof()) ? 0 : __c; } + + }; +# 751 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 +} + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template<> + struct char_traits + { + typedef char16_t char_type; + + typedef unsigned short int_type; + + + + + + + typedef streamoff off_type; + typedef u16streampos pos_type; + typedef mbstate_t state_type; + + + + + + static constexpr void + assign(char_type& __c1, const char_type& __c2) noexcept + { + + + + + + __c1 = __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 < __c2; } + + static constexpr int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + for (size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + static constexpr size_t + length(const char_type* __s) + { + size_t __i = 0; + while (!eq(__s[__i], char_type())) + ++__i; + return __i; + } + + static constexpr const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + for (size_t __i = 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + + + + + return (static_cast + (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + + + + + return (static_cast + (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + for (size_t __i = 0; __i < __n; ++__i) + assign(__s[__i], __a); + return __s; + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return char_type(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return __c == eof() ? int_type(0xfffd) : int_type(__c); } + + static constexpr int_type + eof() noexcept + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return eq_int_type(__c, eof()) ? 0 : __c; } + + + + + + }; + + template<> + struct char_traits + { + typedef char32_t char_type; + + typedef unsigned int int_type; + + + + + + + typedef streamoff off_type; + typedef u32streampos pos_type; + typedef mbstate_t state_type; + + + + + + static constexpr void + assign(char_type& __c1, const char_type& __c2) noexcept + { + + + + + + __c1 = __c2; + } + + static constexpr bool + eq(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 == __c2; } + + static constexpr bool + lt(const char_type& __c1, const char_type& __c2) noexcept + { return __c1 < __c2; } + + static constexpr int + compare(const char_type* __s1, const char_type* __s2, size_t __n) + { + for (size_t __i = 0; __i < __n; ++__i) + if (lt(__s1[__i], __s2[__i])) + return -1; + else if (lt(__s2[__i], __s1[__i])) + return 1; + return 0; + } + + static constexpr size_t + length(const char_type* __s) + { + size_t __i = 0; + while (!eq(__s[__i], char_type())) + ++__i; + return __i; + } + + static constexpr const char_type* + find(const char_type* __s, size_t __n, const char_type& __a) + { + for (size_t __i = 0; __i < __n; ++__i) + if (eq(__s[__i], __a)) + return __s + __i; + return 0; + } + + static char_type* + move(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + + + + + return (static_cast + (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + copy(char_type* __s1, const char_type* __s2, size_t __n) + { + if (__n == 0) + return __s1; + + + + + return (static_cast + (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); + } + + static char_type* + assign(char_type* __s, size_t __n, char_type __a) + { + for (size_t __i = 0; __i < __n; ++__i) + assign(__s[__i], __a); + return __s; + } + + static constexpr char_type + to_char_type(const int_type& __c) noexcept + { return char_type(__c); } + + static constexpr int_type + to_int_type(const char_type& __c) noexcept + { return int_type(__c); } + + static constexpr bool + eq_int_type(const int_type& __c1, const int_type& __c2) noexcept + { return __c1 == __c2; } + + + static constexpr int_type + eof() noexcept + { return static_cast(-1); } + + static constexpr int_type + not_eof(const int_type& __c) noexcept + { return eq_int_type(__c, eof()) ? 0 : __c; } + + }; +# 1032 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 +#pragma GCC diagnostic pop + + +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/clocale" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/clocale" 3 + + +# 1 "/usr/include/locale.h" 1 3 4 +# 28 "/usr/include/locale.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 29 "/usr/include/locale.h" 2 3 4 +# 1 "/usr/include/bits/locale.h" 1 3 4 +# 30 "/usr/include/locale.h" 2 3 4 + +extern "C" { +# 51 "/usr/include/locale.h" 3 4 +struct lconv +{ + + + char *decimal_point; + char *thousands_sep; + + + + + + char *grouping; + + + + + + char *int_curr_symbol; + char *currency_symbol; + char *mon_decimal_point; + char *mon_thousands_sep; + char *mon_grouping; + char *positive_sign; + char *negative_sign; + char int_frac_digits; + char frac_digits; + + char p_cs_precedes; + + char p_sep_by_space; + + char n_cs_precedes; + + char n_sep_by_space; + + + + + + + char p_sign_posn; + char n_sign_posn; + + + char int_p_cs_precedes; + + char int_p_sep_by_space; + + char int_n_cs_precedes; + + char int_n_sep_by_space; + + + + + + + char int_p_sign_posn; + char int_n_sign_posn; +# 118 "/usr/include/locale.h" 3 4 +}; + + + +extern char *setlocale (int __category, const char *__locale) noexcept (true); + + +extern struct lconv *localeconv (void) noexcept (true); +# 141 "/usr/include/locale.h" 3 4 +extern locale_t newlocale (int __category_mask, const char *__locale, + locale_t __base) noexcept (true); +# 176 "/usr/include/locale.h" 3 4 +extern locale_t duplocale (locale_t __dataset) noexcept (true); + + + +extern void freelocale (locale_t __dataset) noexcept (true); + + + + + + +extern locale_t uselocale (locale_t __dataset) noexcept (true); + + + + + + + +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/clocale" 2 3 + + + + + + + + +namespace std +{ + using ::lconv; + using ::setlocale; + using ::localeconv; +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3 + + + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + extern "C" __typeof(uselocale) __uselocale; + + +} + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + typedef __locale_t __c_locale; +# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 3 + inline int + __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)), + char* __out, + const int __size __attribute__ ((__unused__)), + const char* __fmt, ...) + { + + __c_locale __old = __gnu_cxx::__uselocale(__cloc); +# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 3 + __builtin_va_list __args; + __builtin_va_start(__args, __fmt); + + + const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args); + + + + + __builtin_va_end(__args); + + + __gnu_cxx::__uselocale(__old); + + + + + + + + return __ret; + } + + + + + + + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 3 + + +# 1 "/usr/include/ctype.h" 1 3 4 +# 26 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 27 "/usr/include/ctype.h" 2 3 4 + +extern "C" { +# 39 "/usr/include/ctype.h" 3 4 +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 35 "/usr/include/bits/endian.h" 3 4 +# 1 "/usr/include/bits/endianness.h" 1 3 4 +# 36 "/usr/include/bits/endian.h" 2 3 4 +# 40 "/usr/include/ctype.h" 2 3 4 + + + + + + +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 251 "/usr/include/ctype.h" 3 4 +extern int isalnum_l (int, locale_t) noexcept (true); +extern int isalpha_l (int, locale_t) noexcept (true); +extern int iscntrl_l (int, locale_t) noexcept (true); +extern int isdigit_l (int, locale_t) noexcept (true); +extern int islower_l (int, locale_t) noexcept (true); +extern int isgraph_l (int, locale_t) noexcept (true); +extern int isprint_l (int, locale_t) noexcept (true); +extern int ispunct_l (int, locale_t) noexcept (true); +extern int isspace_l (int, locale_t) noexcept (true); +extern int isupper_l (int, locale_t) noexcept (true); +extern int isxdigit_l (int, locale_t) noexcept (true); + +extern int isblank_l (int, locale_t) noexcept (true); + + + +extern int __tolower_l (int __c, locale_t __l) noexcept (true); +extern int tolower_l (int __c, locale_t __l) noexcept (true); + + +extern int __toupper_l (int __c, locale_t __l) noexcept (true); +extern int toupper_l (int __c, locale_t __l) noexcept (true); +# 327 "/usr/include/ctype.h" 3 4 +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 2 3 +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 3 +namespace std +{ + using ::isalnum; + using ::isalpha; + using ::iscntrl; + using ::isdigit; + using ::isgraph; + using ::islower; + using ::isprint; + using ::ispunct; + using ::isspace; + using ::isupper; + using ::isxdigit; + using ::tolower; + using ::toupper; +} + + + + + + + +namespace std +{ + using ::isblank; +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 3 + class locale; + + template + bool + has_facet(const locale&) throw(); + + template + const _Facet& + use_facet(const locale&); + + + template + bool + isspace(_CharT, const locale&); + + template + bool + isprint(_CharT, const locale&); + + template + bool + iscntrl(_CharT, const locale&); + + template + bool + isupper(_CharT, const locale&); + + template + bool + islower(_CharT, const locale&); + + template + bool + isalpha(_CharT, const locale&); + + template + bool + isdigit(_CharT, const locale&); + + template + bool + ispunct(_CharT, const locale&); + + template + bool + isxdigit(_CharT, const locale&); + + template + bool + isalnum(_CharT, const locale&); + + template + bool + isgraph(_CharT, const locale&); + + + template + bool + isblank(_CharT, const locale&); + + + template + _CharT + toupper(_CharT, const locale&); + + template + _CharT + tolower(_CharT, const locale&); + + + struct ctype_base; + template + class ctype; + template<> class ctype; + + template<> class ctype; + + template + class ctype_byname; + + + class codecvt_base; + template + class codecvt; + template<> class codecvt; + + template<> class codecvt; + + + template<> class codecvt; + template<> class codecvt; + + + + + + template + class codecvt_byname; + + + + template > + class num_get; + template > + class num_put; + +namespace __cxx11 { + template class numpunct; + template class numpunct_byname; +} + +namespace __cxx11 { + + template + class collate; + template + class collate_byname; +} + + + class time_base; +namespace __cxx11 { + template > + class time_get; + template > + class time_get_byname; +} + template > + class time_put; + template > + class time_put_byname; + + + class money_base; +namespace __cxx11 { + template > + class money_get; + template > + class money_put; +} +namespace __cxx11 { + template + class moneypunct; + template + class moneypunct_byname; +} + + + struct messages_base; +namespace __cxx11 { + template + class messages; + template + class messages_byname; +} + + +} +# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 1 3 +# 30 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 +#pragma GCC visibility push(default) +# 148 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +# 1 "/usr/include/pthread.h" 1 3 4 +# 22 "/usr/include/pthread.h" 3 4 +# 1 "/usr/include/sched.h" 1 3 4 +# 29 "/usr/include/sched.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 30 "/usr/include/sched.h" 2 3 4 + +# 1 "/usr/include/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 32 "/usr/include/sched.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 +}; +# 33 "/usr/include/sched.h" 2 3 4 + + + + + +typedef __pid_t pid_t; + + + + +# 1 "/usr/include/bits/sched.h" 1 3 4 +# 80 "/usr/include/bits/sched.h" 3 4 +# 1 "/usr/include/bits/types/struct_sched_param.h" 1 3 4 +# 23 "/usr/include/bits/types/struct_sched_param.h" 3 4 +struct sched_param +{ + int sched_priority; +}; +# 81 "/usr/include/bits/sched.h" 2 3 4 + +extern "C" { + + + +extern int clone (int (*__fn) (void *__arg), void *__child_stack, + int __flags, void *__arg, ...) noexcept (true); + + +extern int unshare (int __flags) noexcept (true); + + +extern int sched_getcpu (void) noexcept (true); + + +extern int getcpu (unsigned int *, unsigned int *) noexcept (true); + + +extern int setns (int __fd, int __nstype) noexcept (true); + + +} +# 44 "/usr/include/sched.h" 2 3 4 +# 1 "/usr/include/bits/cpu-set.h" 1 3 4 +# 32 "/usr/include/bits/cpu-set.h" 3 4 +typedef unsigned long int __cpu_mask; + + + + + + +typedef struct +{ + __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; +} cpu_set_t; +# 115 "/usr/include/bits/cpu-set.h" 3 4 +extern "C" { + +extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) + noexcept (true); +extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) ; +extern void __sched_cpufree (cpu_set_t *__set) noexcept (true); + +} +# 45 "/usr/include/sched.h" 2 3 4 + + + + + + +extern "C" { + + +extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) + noexcept (true); + + +extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true); + + +extern int sched_setscheduler (__pid_t __pid, int __policy, + const struct sched_param *__param) noexcept (true); + + +extern int sched_getscheduler (__pid_t __pid) noexcept (true); + + +extern int sched_yield (void) noexcept (true); + + +extern int sched_get_priority_max (int __algorithm) noexcept (true); + + +extern int sched_get_priority_min (int __algorithm) noexcept (true); + + + +extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true); +# 130 "/usr/include/sched.h" 3 4 +extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, + const cpu_set_t *__cpuset) noexcept (true); + + +extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, + cpu_set_t *__cpuset) noexcept (true); + + +} +# 23 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/time.h" 1 3 4 +# 29 "/usr/include/time.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 30 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/time.h" 1 3 4 +# 73 "/usr/include/bits/time.h" 3 4 +# 1 "/usr/include/bits/timex.h" 1 3 4 +# 22 "/usr/include/bits/timex.h" 3 4 +# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 23 "/usr/include/bits/timex.h" 2 3 4 + + + +struct timex +{ +# 58 "/usr/include/bits/timex.h" 3 4 + unsigned int modes; + __syscall_slong_t offset; + __syscall_slong_t freq; + __syscall_slong_t maxerror; + __syscall_slong_t esterror; + int status; + __syscall_slong_t constant; + __syscall_slong_t precision; + __syscall_slong_t tolerance; + struct timeval time; + __syscall_slong_t tick; + __syscall_slong_t ppsfreq; + __syscall_slong_t jitter; + int shift; + __syscall_slong_t stabil; + __syscall_slong_t jitcnt; + __syscall_slong_t calcnt; + __syscall_slong_t errcnt; + __syscall_slong_t stbcnt; + + int tai; + + + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; int :32; + int :32; int :32; int :32; + +}; +# 74 "/usr/include/bits/time.h" 2 3 4 + +extern "C" { + + +extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); +# 90 "/usr/include/bits/time.h" 3 4 +} +# 34 "/usr/include/time.h" 2 3 4 + + + +# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 38 "/usr/include/time.h" 2 3 4 + +# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 + + + + + + +struct tm +{ + int tm_sec; + int tm_min; + int tm_hour; + int tm_mday; + int tm_mon; + int tm_year; + int tm_wday; + int tm_yday; + int tm_isdst; + + + long int tm_gmtoff; + const char *tm_zone; + + + + +}; +# 40 "/usr/include/time.h" 2 3 4 + + + + + + +# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 47 "/usr/include/time.h" 2 3 4 +# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 48 "/usr/include/time.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 + + + + + + + +struct itimerspec + { + struct timespec it_interval; + struct timespec it_value; + }; +# 49 "/usr/include/time.h" 2 3 4 +struct sigevent; +# 68 "/usr/include/time.h" 3 4 +extern "C" { + + + +extern clock_t clock (void) noexcept (true); + + + +extern time_t time (time_t *__timer) noexcept (true); + + +extern double difftime (time_t __time1, time_t __time0) + noexcept (true) __attribute__ ((__const__)); + + +extern time_t mktime (struct tm *__tp) noexcept (true); +# 100 "/usr/include/time.h" 3 4 +extern size_t strftime (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp) + noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); + + + + +extern char *strptime (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp) + noexcept (true); + + + + + + +extern size_t strftime_l (char *__restrict __s, size_t __maxsize, + const char *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); + + + +extern char *strptime_l (const char *__restrict __s, + const char *__restrict __fmt, struct tm *__tp, + locale_t __loc) noexcept (true); + + + + + + +extern struct tm *gmtime (const time_t *__timer) noexcept (true); + + + +extern struct tm *localtime (const time_t *__timer) noexcept (true); +# 155 "/usr/include/time.h" 3 4 +extern struct tm *gmtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); + + + +extern struct tm *localtime_r (const time_t *__restrict __timer, + struct tm *__restrict __tp) noexcept (true); +# 180 "/usr/include/time.h" 3 4 +extern char *asctime (const struct tm *__tp) noexcept (true); + + + +extern char *ctime (const time_t *__timer) noexcept (true); +# 198 "/usr/include/time.h" 3 4 +extern char *asctime_r (const struct tm *__restrict __tp, + char *__restrict __buf) noexcept (true); + + + +extern char *ctime_r (const time_t *__restrict __timer, + char *__restrict __buf) noexcept (true); +# 218 "/usr/include/time.h" 3 4 +extern char *__tzname[2]; +extern int __daylight; +extern long int __timezone; + + + + +extern char *tzname[2]; + + + +extern void tzset (void) noexcept (true); + + + +extern int daylight; +extern long int timezone; +# 247 "/usr/include/time.h" 3 4 +extern time_t timegm (struct tm *__tp) noexcept (true); +# 264 "/usr/include/time.h" 3 4 +extern time_t timelocal (struct tm *__tp) noexcept (true); + + + + + + + +extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); +# 282 "/usr/include/time.h" 3 4 +extern int nanosleep (const struct timespec *__requested_time, + struct timespec *__remaining); + + +extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); + + +extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 324 "/usr/include/time.h" 3 4 +extern int clock_nanosleep (clockid_t __clock_id, int __flags, + const struct timespec *__req, + struct timespec *__rem); +# 339 "/usr/include/time.h" 3 4 +extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); + + + + +extern int timer_create (clockid_t __clock_id, + struct sigevent *__restrict __evp, + timer_t *__restrict __timerid) noexcept (true); + + +extern int timer_delete (timer_t __timerid) noexcept (true); + + + +extern int timer_settime (timer_t __timerid, int __flags, + const struct itimerspec *__restrict __value, + struct itimerspec *__restrict __ovalue) noexcept (true); + + +extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) + noexcept (true); +# 377 "/usr/include/time.h" 3 4 +extern int timer_getoverrun (timer_t __timerid) noexcept (true); + + + + + + +extern int timespec_get (struct timespec *__ts, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 400 "/usr/include/time.h" 3 4 +extern int timespec_getres (struct timespec *__ts, int __base) + noexcept (true); +# 426 "/usr/include/time.h" 3 4 +extern int getdate_err; +# 435 "/usr/include/time.h" 3 4 +extern struct tm *getdate (const char *__string); +# 449 "/usr/include/time.h" 3 4 +extern int getdate_r (const char *__restrict __string, + struct tm *__restrict __resbufp); + + +} +# 24 "/usr/include/pthread.h" 2 3 4 + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 27 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/setjmp.h" 1 3 4 +# 26 "/usr/include/bits/setjmp.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 27 "/usr/include/bits/setjmp.h" 2 3 4 + + + + +typedef long int __jmp_buf[8]; +# 28 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 29 "/usr/include/pthread.h" 2 3 4 + +# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 31 "/usr/include/pthread.h" 2 3 4 +# 1 "/usr/include/bits/types/struct___jmp_buf_tag.h" 1 3 4 +# 26 "/usr/include/bits/types/struct___jmp_buf_tag.h" 3 4 +struct __jmp_buf_tag + { + + + + + __jmp_buf __jmpbuf; + int __mask_was_saved; + __sigset_t __saved_mask; + }; +# 32 "/usr/include/pthread.h" 2 3 4 + +# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 +# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 +extern "C" { +extern long int __sysconf (int __name) noexcept (true); +} +# 34 "/usr/include/pthread.h" 2 3 4 + + + +enum +{ + PTHREAD_CREATE_JOINABLE, + + PTHREAD_CREATE_DETACHED + +}; + + + +enum +{ + PTHREAD_MUTEX_TIMED_NP, + PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_ADAPTIVE_NP + + , + PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, + PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, + PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, + PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL + + + + , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP + +}; + + + + +enum +{ + PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, + PTHREAD_MUTEX_ROBUST, + PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST +}; + + + + + +enum +{ + PTHREAD_PRIO_NONE, + PTHREAD_PRIO_INHERIT, + PTHREAD_PRIO_PROTECT +}; +# 104 "/usr/include/pthread.h" 3 4 +enum +{ + PTHREAD_RWLOCK_PREFER_READER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NP, + PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, + PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP +}; +# 124 "/usr/include/pthread.h" 3 4 +enum +{ + PTHREAD_INHERIT_SCHED, + + PTHREAD_EXPLICIT_SCHED + +}; + + + +enum +{ + PTHREAD_SCOPE_SYSTEM, + + PTHREAD_SCOPE_PROCESS + +}; + + + +enum +{ + PTHREAD_PROCESS_PRIVATE, + + PTHREAD_PROCESS_SHARED + +}; +# 159 "/usr/include/pthread.h" 3 4 +struct _pthread_cleanup_buffer +{ + void (*__routine) (void *); + void *__arg; + int __canceltype; + struct _pthread_cleanup_buffer *__prev; +}; + + +enum +{ + PTHREAD_CANCEL_ENABLE, + + PTHREAD_CANCEL_DISABLE + +}; +enum +{ + PTHREAD_CANCEL_DEFERRED, + + PTHREAD_CANCEL_ASYNCHRONOUS + +}; +# 197 "/usr/include/pthread.h" 3 4 +extern "C" { + + + + +extern int pthread_create (pthread_t *__restrict __newthread, + const pthread_attr_t *__restrict __attr, + void *(*__start_routine) (void *), + void *__restrict __arg) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + + + +extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); + + + + + + + +extern int pthread_join (pthread_t __th, void **__thread_return); + + + + +extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) noexcept (true); +# 233 "/usr/include/pthread.h" 3 4 +extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, + const struct timespec *__abstime); +# 243 "/usr/include/pthread.h" 3 4 +extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return, + clockid_t __clockid, + const struct timespec *__abstime); +# 269 "/usr/include/pthread.h" 3 4 +extern int pthread_detach (pthread_t __th) noexcept (true); + + + +extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__)); + + +extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) + noexcept (true) __attribute__ ((__const__)); + + + + + + + +extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_destroy (pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, + int *__detachstate) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, + int __detachstate) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, + size_t *__guardsize) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setguardsize (pthread_attr_t *__attr, + size_t __guardsize) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, + struct sched_param *__restrict __param) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, + const struct sched_param *__restrict + __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict + __attr, int *__restrict __policy) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict + __attr, int *__restrict __inherit) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, + int __inherit) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, + int *__restrict __scope) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict + __attr, void **__restrict __stackaddr) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); + + + + + +extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, + void *__stackaddr) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); + + +extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict + __attr, size_t *__restrict __stacksize) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int pthread_attr_setstacksize (pthread_attr_t *__attr, + size_t __stacksize) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, + void **__restrict __stackaddr, + size_t *__restrict __stacksize) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))); + + + + +extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, + size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, + size_t __cpusetsize, + const cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, + size_t __cpusetsize, + cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + +extern int pthread_getattr_default_np (pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr, + const __sigset_t *sigmask); + + + + +extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr, + __sigset_t *sigmask); + + + + + + + +extern int pthread_setattr_default_np (const pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + + + + +extern int pthread_setschedparam (pthread_t __target_thread, int __policy, + const struct sched_param *__param) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + +extern int pthread_getschedparam (pthread_t __target_thread, + int *__restrict __policy, + struct sched_param *__restrict __param) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + +extern int pthread_setschedprio (pthread_t __target_thread, int __prio) + noexcept (true); + + + + +extern int pthread_getname_np (pthread_t __target_thread, char *__buf, + size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int pthread_setname_np (pthread_t __target_thread, const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + + +extern int pthread_getconcurrency (void) noexcept (true); + + +extern int pthread_setconcurrency (int __level) noexcept (true); + + + +extern int pthread_yield (void) noexcept (true); + +extern int pthread_yield (void) noexcept (true) __asm__ ("" "sched_yield") + __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead"))); +# 489 "/usr/include/pthread.h" 3 4 +extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, + const cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + +extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, + cpu_set_t *__cpuset) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 509 "/usr/include/pthread.h" 3 4 +extern int pthread_once (pthread_once_t *__once_control, + void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); +# 521 "/usr/include/pthread.h" 3 4 +extern int pthread_setcancelstate (int __state, int *__oldstate); + + + +extern int pthread_setcanceltype (int __type, int *__oldtype); + + +extern int pthread_cancel (pthread_t __th); + + + + +extern void pthread_testcancel (void); + + + + +struct __cancel_jmp_buf_tag +{ + __jmp_buf __cancel_jmp_buf; + int __mask_was_saved; +}; + +typedef struct +{ + struct __cancel_jmp_buf_tag __cancel_jmp_buf[1]; + void *__pad[4]; +} __pthread_unwind_buf_t __attribute__ ((__aligned__)); +# 557 "/usr/include/pthread.h" 3 4 +struct __pthread_cleanup_frame +{ + void (*__cancel_routine) (void *); + void *__cancel_arg; + int __do_it; + int __cancel_type; +}; + + + + +class __pthread_cleanup_class +{ + void (*__cancel_routine) (void *); + void *__cancel_arg; + int __do_it; + int __cancel_type; + + public: + __pthread_cleanup_class (void (*__fct) (void *), void *__arg) + : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } + ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } + void __setdoit (int __newval) { __do_it = __newval; } + void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, + &__cancel_type); } + void __restore () const { pthread_setcanceltype (__cancel_type, 0); } +}; +# 773 "/usr/include/pthread.h" 3 4 +extern int __sigsetjmp (struct __jmp_buf_tag __env[1], + int __savemask) noexcept (true); + + + + + + +extern int pthread_mutex_init (pthread_mutex_t *__mutex, + const pthread_mutexattr_t *__mutexattr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_lock (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 817 "/usr/include/pthread.h" 3 4 +extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex, + clockid_t __clockid, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 835 "/usr/include/pthread.h" 3 4 +extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutex_getprioceiling (const pthread_mutex_t * + __restrict __mutex, + int *__restrict __prioceiling) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, + int __prioceiling, + int *__restrict __old_ceiling) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + + +extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutex_consistent_np (pthread_mutex_t *) noexcept (true) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nonnull__ (1))) + + __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent"))); +# 874 "/usr/include/pthread.h" 3 4 +extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, + int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict + __attr, int *__restrict __kind) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __protocol) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, + int __protocol) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * + __restrict __attr, + int *__restrict __prioceiling) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, + int __prioceiling) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, + int *__robustness) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) noexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nonnull__ (1))) + + + __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust"))); + + + + + + + +extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, + int __robustness) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) noexcept (true) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nonnull__ (1))) + + + __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust"))); +# 967 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, + const pthread_rwlockattr_t *__restrict + __attr) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 1004 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock, + clockid_t __clockid, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 1023 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +# 1051 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock, + clockid_t __clockid, + const struct timespec *__restrict + __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 1071 "/usr/include/pthread.h" 3 4 +extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, + int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * + __restrict __attr, + int *__restrict __pref) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, + int __pref) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern int pthread_cond_init (pthread_cond_t *__restrict __cond, + const pthread_condattr_t *__restrict __cond_attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_destroy (pthread_cond_t *__cond) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_signal (pthread_cond_t *__cond) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_cond_broadcast (pthread_cond_t *__cond) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex) + __attribute__ ((__nonnull__ (1, 2))); +# 1145 "/usr/include/pthread.h" 3 4 +extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex, + const struct timespec *__restrict __abstime) + __attribute__ ((__nonnull__ (1, 2, 3))); +# 1171 "/usr/include/pthread.h" 3 4 +extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond, + pthread_mutex_t *__restrict __mutex, + __clockid_t __clock_id, + const struct timespec *__restrict __abstime) + __attribute__ ((__nonnull__ (1, 2, 4))); +# 1194 "/usr/include/pthread.h" 3 4 +extern int pthread_condattr_init (pthread_condattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_condattr_destroy (pthread_condattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_condattr_getpshared (const pthread_condattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, + int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_condattr_getclock (const pthread_condattr_t * + __restrict __attr, + __clockid_t *__restrict __clock_id) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_condattr_setclock (pthread_condattr_t *__attr, + __clockid_t __clock_id) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1230 "/usr/include/pthread.h" 3 4 +extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_destroy (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_lock (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_trylock (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_spin_unlock (pthread_spinlock_t *__lock) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, + const pthread_barrierattr_t *__restrict + __attr, unsigned int __count) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrier_wait (pthread_barrier_t *__barrier) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * + __restrict __attr, + int *__restrict __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, + int __pshared) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1297 "/usr/include/pthread.h" 3 4 +extern int pthread_key_create (pthread_key_t *__key, + void (*__destr_function) (void *)) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int pthread_key_delete (pthread_key_t __key) noexcept (true); + + +extern void *pthread_getspecific (pthread_key_t __key) noexcept (true); + + +extern int pthread_setspecific (pthread_key_t __key, + const void *__pointer) + noexcept (true) ; + + + + +extern int pthread_getcpuclockid (pthread_t __thread_id, + __clockid_t *__clock_id) + noexcept (true) __attribute__ ((__nonnull__ (2))); +# 1332 "/usr/include/pthread.h" 3 4 +extern int pthread_atfork (void (*__prepare) (void), + void (*__parent) (void), + void (*__child) (void)) noexcept (true); + + + + +extern __inline __attribute__ ((__gnu_inline__)) int + pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true) +{ + return __thread1 == __thread2; +} + + +} +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +typedef pthread_t __gthread_t; +typedef pthread_key_t __gthread_key_t; +typedef pthread_once_t __gthread_once_t; +typedef pthread_mutex_t __gthread_mutex_t; +typedef pthread_mutex_t __gthread_recursive_mutex_t; +typedef pthread_cond_t __gthread_cond_t; +typedef struct timespec __gthread_time_t; +# 299 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_active_p (void) +{ + return 1; +} +# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), + void *__args) +{ + return pthread_create (__threadid, __null, __func, __args); +} + +static inline int +__gthread_join (__gthread_t __threadid, void **__value_ptr) +{ + return pthread_join (__threadid, __value_ptr); +} + +static inline int +__gthread_detach (__gthread_t __threadid) +{ + return pthread_detach (__threadid); +} + +static inline int +__gthread_equal (__gthread_t __t1, __gthread_t __t2) +{ + return pthread_equal (__t1, __t2); +} + +static inline __gthread_t +__gthread_self (void) +{ + return pthread_self (); +} + +static inline int +__gthread_yield (void) +{ + return sched_yield (); +} + +static inline int +__gthread_once (__gthread_once_t *__once, void (*__func) (void)) +{ + if (__gthread_active_p ()) + return pthread_once (__once, __func); + else + return -1; +} + +static inline int +__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) +{ + return pthread_key_create (__key, __dtor); +} + +static inline int +__gthread_key_delete (__gthread_key_t __key) +{ + return pthread_key_delete (__key); +} + +static inline void * +__gthread_getspecific (__gthread_key_t __key) +{ + return pthread_getspecific (__key); +} + +static inline int +__gthread_setspecific (__gthread_key_t __key, const void *__ptr) +{ + return pthread_setspecific (__key, __ptr); +} + +static inline void +__gthread_mutex_init_function (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + pthread_mutex_init (__mutex, __null); +} + +static inline int +__gthread_mutex_destroy (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_destroy (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_lock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_lock (__mutex); + else + return 0; +} + +static inline int +__gthread_mutex_trylock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_trylock (__mutex); + else + return 0; +} + + +static inline int +__gthread_mutex_timedlock (__gthread_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + if (__gthread_active_p ()) + return pthread_mutex_timedlock (__mutex, __abs_timeout); + else + return 0; +} + + +static inline int +__gthread_mutex_unlock (__gthread_mutex_t *__mutex) +{ + if (__gthread_active_p ()) + return pthread_mutex_unlock (__mutex); + else + return 0; +} +# 808 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_lock (__mutex); +} + +static inline int +__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_trylock (__mutex); +} + + +static inline int +__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + return __gthread_mutex_timedlock (__mutex, __abs_timeout); +} + + +static inline int +__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_unlock (__mutex); +} + +static inline int +__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) +{ + return __gthread_mutex_destroy (__mutex); +} +# 850 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 +static inline int +__gthread_cond_broadcast (__gthread_cond_t *__cond) +{ + return pthread_cond_broadcast (__cond); +} + +static inline int +__gthread_cond_signal (__gthread_cond_t *__cond) +{ + return pthread_cond_signal (__cond); +} + +static inline int +__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) +{ + return pthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, + const __gthread_time_t *__abs_timeout) +{ + return pthread_cond_timedwait (__cond, __mutex, __abs_timeout); +} + +static inline int +__gthread_cond_wait_recursive (__gthread_cond_t *__cond, + __gthread_recursive_mutex_t *__mutex) +{ + return __gthread_cond_wait (__cond, __mutex); +} + +static inline int +__gthread_cond_destroy (__gthread_cond_t* __cond) +{ + return pthread_cond_destroy (__cond); +} +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 2 3 + + +#pragma GCC visibility pop +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3 +# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 3 +typedef int _Atomic_word; +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 + +# 1 "/usr/include/sys/single_threaded.h" 1 3 4 +# 24 "/usr/include/sys/single_threaded.h" 3 4 +extern "C" { + + + + +extern char __libc_single_threaded; + +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + __attribute__((__always_inline__)) + inline bool + __is_single_threaded() noexcept + { + + + + return ::__libc_single_threaded; + + + + } + + + + + + + inline _Atomic_word + __attribute__((__always_inline__)) + __exchange_and_add(volatile _Atomic_word* __mem, int __val) + { return __atomic_fetch_add(__mem, __val, 4); } + + inline void + __attribute__((__always_inline__)) + __atomic_add(volatile _Atomic_word* __mem, int __val) + { __atomic_fetch_add(__mem, __val, 4); } +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 + inline _Atomic_word + __attribute__((__always_inline__)) + __exchange_and_add_single(_Atomic_word* __mem, int __val) + { + _Atomic_word __result = *__mem; + *__mem += __val; + return __result; + } + + inline void + __attribute__((__always_inline__)) + __atomic_add_single(_Atomic_word* __mem, int __val) + { *__mem += __val; } + + inline _Atomic_word + __attribute__ ((__always_inline__)) + __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) + { + if (__is_single_threaded()) + return __exchange_and_add_single(__mem, __val); + else + return __exchange_and_add(__mem, __val); + } + + inline void + __attribute__ ((__always_inline__)) + __atomic_add_dispatch(_Atomic_word* __mem, int __val) + { + if (__is_single_threaded()) + __atomic_add_single(__mem, __val); + else + __atomic_add(__mem, __val); + } + + +} +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 3 + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 1 3 +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); +# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +} +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + template + class __new_allocator + { + public: + typedef _Tp value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + + template + struct rebind + { typedef __new_allocator<_Tp1> other; }; + + + + + + typedef std::true_type propagate_on_container_move_assignment; + + + __attribute__((__always_inline__)) + + __new_allocator() noexcept { } + + __attribute__((__always_inline__)) + + __new_allocator(const __new_allocator&) noexcept { } + + template + __attribute__((__always_inline__)) + + __new_allocator(const __new_allocator<_Tp1>&) noexcept { } + + + ~__new_allocator() noexcept { } + + pointer + address(reference __x) const noexcept + { return std::__addressof(__x); } + + const_pointer + address(const_reference __x) const noexcept + { return std::__addressof(__x); } +# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + [[__nodiscard__]] _Tp* + allocate(size_type __n, const void* = static_cast(0)) + { + + + + static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); + + + if (__builtin_expect(__n > this->_M_max_size(), false)) + { + + + if (__n > (std::size_t(-1) / sizeof(_Tp))) + std::__throw_bad_array_new_length(); + std::__throw_bad_alloc(); + } + + + if (alignof(_Tp) > 16UL) + { + std::align_val_t __al = std::align_val_t(alignof(_Tp)); + return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp), + __al)); + } + + return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp))); + } + + + void + deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) + { + + + + + + + + if (alignof(_Tp) > 16UL) + { + __builtin_operator_delete((__p), + std::align_val_t(alignof(_Tp))); + return; + } + + __builtin_operator_delete((__p)); + } + + + + + + + __attribute__((__always_inline__)) + size_type + max_size() const noexcept + { return _M_max_size(); } + + + template + __attribute__((__always_inline__)) + void + construct(_Up* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + __attribute__((__always_inline__)) + void + destroy(_Up* __p) + noexcept(std::is_nothrow_destructible<_Up>::value) + { __p->~_Up(); } +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + template + friend __attribute__((__always_inline__)) bool + operator==(const __new_allocator&, const __new_allocator<_Up>&) + noexcept + { return true; } + + + template + friend __attribute__((__always_inline__)) bool + operator!=(const __new_allocator&, const __new_allocator<_Up>&) + noexcept + { return false; } + + + private: + __attribute__((__always_inline__)) + constexpr size_type + _M_max_size() const noexcept + { + + return std::size_t(9223372036854775807L) / sizeof(_Tp); + + + + } + }; + + +} +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3 + + +namespace std +{ +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 + template + using __allocator_base = __new_allocator<_Tp>; +} +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + template<> + class allocator + { + public: + typedef void value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + + + typedef void* pointer; + typedef const void* const_pointer; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + using propagate_on_container_move_assignment = true_type; + + using is_always_equal + + = true_type; +# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + }; +# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + template + class allocator : public __allocator_base<_Tp> + { + public: + typedef _Tp value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + + + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + using propagate_on_container_move_assignment = true_type; + + using is_always_equal + + = true_type; + + + + + __attribute__((__always_inline__)) + + allocator() noexcept { } + + __attribute__((__always_inline__)) + + allocator(const allocator& __a) noexcept + : __allocator_base<_Tp>(__a) { } + + + + allocator& operator=(const allocator&) = default; + + + template + __attribute__((__always_inline__)) + + allocator(const allocator<_Tp1>&) noexcept { } + + __attribute__((__always_inline__)) + + + + ~allocator() noexcept { } +# 214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + friend __attribute__((__always_inline__)) + bool + operator==(const allocator&, const allocator&) noexcept + { return true; } + + + friend __attribute__((__always_inline__)) + bool + operator!=(const allocator&, const allocator&) noexcept + { return false; } + + + + }; + + + + + + + template + __attribute__((__always_inline__)) + inline bool + operator==(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return true; } + + + template + __attribute__((__always_inline__)) + inline bool + operator!=(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return false; } + + + + + + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + + + + + + + extern template class allocator; + extern template class allocator; + + + + + + +} +# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; + }; +# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream_insert.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream_insert.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_forced.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_forced.h" 3 + +#pragma GCC visibility push(default) + + +namespace __cxxabiv1 +{ + + + + + + + + class __forced_unwind + { + virtual ~__forced_unwind() throw(); + + + virtual void __pure_dummy() = 0; + }; +} + + +#pragma GCC visibility pop +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream_insert.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + inline void + __ostream_write(basic_ostream<_CharT, _Traits>& __out, + const _CharT* __s, streamsize __n) + { + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const streamsize __put = __out.rdbuf()->sputn(__s, __n); + if (__put != __n) + __out.setstate(__ios_base::badbit); + } + + template + inline void + __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n) + { + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + const _CharT __c = __out.fill(); + for (; __n > 0; --__n) + { + const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c); + if (_Traits::eq_int_type(__put, _Traits::eof())) + { + __out.setstate(__ios_base::badbit); + break; + } + } + } + + template + basic_ostream<_CharT, _Traits>& + __ostream_insert(basic_ostream<_CharT, _Traits>& __out, + const _CharT* __s, streamsize __n) + { + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef typename __ostream_type::ios_base __ios_base; + + typename __ostream_type::sentry __cerb(__out); + if (__cerb) + { + try + { + const streamsize __w = __out.width(); + if (__w > __n) + { + const bool __left = ((__out.flags() + & __ios_base::adjustfield) + == __ios_base::left); + if (!__left) + __ostream_fill(__out, __w - __n); + if (__out.good()) + __ostream_write(__out, __s, __n); + if (__left && __out.good()) + __ostream_fill(__out, __w - __n); + } + else + __ostream_write(__out, __s, __n); + __out.width(0); + } + catch(__cxxabiv1::__forced_unwind&) + { + __out._M_setstate(__ios_base::badbit); + throw; + } + catch(...) + { __out._M_setstate(__ios_base::badbit); } + } + return __out; + } + + + + + extern template ostream& __ostream_insert(ostream&, const char*, streamsize); + + + extern template wostream& __ostream_insert(wostream&, const wchar_t*, + streamsize); + + + + + + +} +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iterator_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 +} +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 +# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 +# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + namespace __detail + { +# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + } +# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } +# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + typename iterator_traits<_InputIterator>::value_type::first_type>; + + template + using __iter_val_t + = typename iterator_traits<_InputIterator>::value_type::second_type; + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct unary_function + { + + typedef _Arg argument_type; + + + typedef _Result result_type; + } __attribute__ ((__deprecated__)); + + + + + + template + struct binary_function + { + + typedef _Arg1 first_argument_type; + + + typedef _Arg2 second_argument_type; + + + typedef _Result result_type; + } __attribute__ ((__deprecated__)); +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + struct __is_transparent; + + template + struct plus; + + template + struct minus; + + template + struct multiplies; + + template + struct divides; + + template + struct modulus; + + template + struct negate; + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct plus : public binary_function<_Tp, _Tp, _Tp> + { + + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x + __y; } + }; + + + template + struct minus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x - __y; } + }; + + + template + struct multiplies : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x * __y; } + }; + + + template + struct divides : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x / __y; } + }; + + + template + struct modulus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x % __y; } + }; + + + template + struct negate : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return -__x; } + }; +#pragma GCC diagnostic pop + + + + + + template<> + struct plus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct minus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct multiplies + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct divides + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct modulus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct negate + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(-std::forward<_Tp>(__t))) + -> decltype(-std::forward<_Tp>(__t)) + { return -std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; +# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct equal_to; + + template + struct not_equal_to; + + template + struct greater; + + template + struct less; + + template + struct greater_equal; + + template + struct less_equal; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x == __y; } + }; + + + template + struct not_equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x != __y; } + }; + + + template + struct greater : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x > __y; } + }; + + + template + struct less : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x < __y; } + }; + + + template + struct greater_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x >= __y; } + }; + + + template + struct less_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x <= __y; } + }; + + + template + struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x > __y; + + return (long unsigned int)__x > (long unsigned int)__y; + } + }; + + + template + struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x < __y; + + return (long unsigned int)__x < (long unsigned int)__y; + } + }; + + + template + struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x >= __y; + + return (long unsigned int)__x >= (long unsigned int)__y; + } + }; + + + template + struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x <= __y; + + return (long unsigned int)__x <= (long unsigned int)__y; + } + }; +#pragma GCC diagnostic pop + + + + template<> + struct equal_to + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct not_equal_to + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct greater + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return greater>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return greater{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct less + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return less>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return less{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct greater_equal + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return greater_equal>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return greater_equal{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct less_equal + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return less_equal>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return less_equal{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; +# 781 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct logical_and; + + template + struct logical_or; + + template + struct logical_not; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct logical_and : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x && __y; } + }; + + + template + struct logical_or : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x || __y; } + }; + + + template + struct logical_not : public unary_function<_Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x) const + { return !__x; } + }; +#pragma GCC diagnostic pop + + + + template<> + struct logical_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(!std::forward<_Tp>(__t))) + -> decltype(!std::forward<_Tp>(__t)) + { return !std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; + + + + + template + struct bit_and; + + template + struct bit_or; + + template + struct bit_xor; + + template + struct bit_not; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + template + struct bit_and : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x & __y; } + }; + + template + struct bit_or : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x | __y; } + }; + + template + struct bit_xor : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x ^ __y; } + }; + + template + struct bit_not : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return ~__x; } + }; +#pragma GCC diagnostic pop + + + template <> + struct bit_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_xor + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(~std::forward<_Tp>(__t))) + -> decltype(~std::forward<_Tp>(__t)) + { return ~std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class [[__deprecated__]] unary_negate + : public unary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + unary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::argument_type& __x) const + { return !_M_pred(__x); } + }; + + + template + __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) + constexpr + inline unary_negate<_Predicate> + not1(const _Predicate& __pred) + { return unary_negate<_Predicate>(__pred); } + + + template + class [[__deprecated__]] binary_negate + : public binary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + binary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::first_argument_type& __x, + const typename _Predicate::second_argument_type& __y) const + { return !_M_pred(__x, __y); } + }; + + + template + __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) + constexpr + inline binary_negate<_Predicate> + not2(const _Predicate& __pred) + { return binary_negate<_Predicate>(__pred); } +# 1104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class pointer_to_unary_function : public unary_function<_Arg, _Result> + { + protected: + _Result (*_M_ptr)(_Arg); + + public: + pointer_to_unary_function() { } + + explicit + pointer_to_unary_function(_Result (*__x)(_Arg)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg __x) const + { return _M_ptr(__x); } + } __attribute__ ((__deprecated__)); + + + template + __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) + inline pointer_to_unary_function<_Arg, _Result> + ptr_fun(_Result (*__x)(_Arg)) + { return pointer_to_unary_function<_Arg, _Result>(__x); } + + + template + class pointer_to_binary_function + : public binary_function<_Arg1, _Arg2, _Result> + { + protected: + _Result (*_M_ptr)(_Arg1, _Arg2); + + public: + pointer_to_binary_function() { } + + explicit + pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg1 __x, _Arg2 __y) const + { return _M_ptr(__x, __y); } + } __attribute__ ((__deprecated__)); + + + template + __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) + inline pointer_to_binary_function<_Arg1, _Arg2, _Result> + ptr_fun(_Result (*__x)(_Arg1, _Arg2)) + { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } + + + template + struct _Identity + : public unary_function<_Tp, _Tp> + { + _Tp& + operator()(_Tp& __x) const + { return __x; } + + const _Tp& + operator()(const _Tp& __x) const + { return __x; } + }; + + + template struct _Identity : _Identity<_Tp> { }; + + template + struct _Select1st + : public unary_function<_Pair, typename _Pair::first_type> + { + typename _Pair::first_type& + operator()(_Pair& __x) const + { return __x.first; } + + const typename _Pair::first_type& + operator()(const _Pair& __x) const + { return __x.first; } + + + template + typename _Pair2::first_type& + operator()(_Pair2& __x) const + { return __x.first; } + + template + const typename _Pair2::first_type& + operator()(const _Pair2& __x) const + { return __x.first; } + + }; + + template + struct _Select2nd + : public unary_function<_Pair, typename _Pair::second_type> + { + typename _Pair::second_type& + operator()(_Pair& __x) const + { return __x.second; } + + const typename _Pair::second_type& + operator()(const _Pair& __x) const + { return __x.second; } + }; +# 1231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class mem_fun_t : public unary_function<_Tp*, _Ret> + { + public: + explicit + mem_fun_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun_t : public unary_function + { + public: + explicit + const_mem_fun_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + mem_fun_ref_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> + { + public: + explicit + mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun1_t : public binary_function + { + public: + explicit + const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + } __attribute__ ((__deprecated__)); + + + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)()) + { return mem_fun_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)() const) + { return const_mem_fun_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)()) + { return mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)() const) + { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } +#pragma GCC diagnostic pop + + + + + template> + struct __has_is_transparent + { }; + + template + struct __has_is_transparent<_Func, _SfinaeType, + __void_t> + { typedef void type; }; + + template + using __has_is_transparent_t + = typename __has_is_transparent<_Func, _SfinaeType>::type; + + + +} + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 1 3 +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 + template + class binder1st + : public unary_function + { + protected: + _Operation op; + typename _Operation::first_argument_type value; + + public: + binder1st(const _Operation& __x, + const typename _Operation::first_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + + + + typename _Operation::result_type + operator()(typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); + + + template + __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) + inline binder1st<_Operation> + bind1st(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::first_argument_type _Arg1_type; + return binder1st<_Operation>(__fn, _Arg1_type(__x)); + } + + + template + class binder2nd + : public unary_function + { + protected: + _Operation op; + typename _Operation::second_argument_type value; + + public: + binder2nd(const _Operation& __x, + const typename _Operation::second_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + + + + typename _Operation::result_type + operator()(typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); + + + template + __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) + inline binder2nd<_Operation> + bind2nd(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::second_argument_type _Arg2_type; + return binder2nd<_Operation>(__fn, _Arg2_type(__x)); + } + + + +} + +#pragma GCC diagnostic pop +# 1439 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 2 3 +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; + + + + + + + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 +} +# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { + + template + using _IdxTuple = _Index_tuple<_Indices...>; + + + using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; + + + + + }; + + + + + + + template + struct integer_sequence + { + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + = __make_integer_seq; + + + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + + + + template + struct _Nth_type + { }; + + template + struct _Nth_type<0, _Tp0, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Rest...> + { using type = _Tp1; }; + + template + struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp2; }; + + template + + + + struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> + : _Nth_type<_Np - 3, _Rest...> + { }; + + + template + struct _Nth_type<0, _Tp0, _Tp1, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp1; }; + + + + + + + +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + class tuple; + + template + struct _Index_tuple; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; + + + + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } +# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } +# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +} +# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__res - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } +# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + } +# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { +# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template + + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +} +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 + template::type> + constexpr _Up&& + __invfwd(typename remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Up&&>(__t); } + + template + constexpr _Res + __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) + { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } + + template + constexpr _Res + __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } + + template + constexpr _Res + __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + { + return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); + } + + template + constexpr _Res + __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) + { return __invfwd<_Tp>(__t).*__f; } + + template + constexpr _Res + __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) + { return (*std::forward<_Tp>(__t)).*__f; } + + + template + constexpr typename __invoke_result<_Callable, _Args...>::type + __invoke(_Callable&& __fn, _Args&&... __args) + noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) + { + using __result = __invoke_result<_Callable, _Args...>; + using __type = typename __result::type; + using __tag = typename __result::__invoke_type; + return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + } + + + + template + constexpr enable_if_t, _Res> + __invoke_r(_Callable&& __fn, _Args&&... __args) + noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) + { + using __result = __invoke_result<_Callable, _Args...>; + using __type = typename __result::type; + using __tag = typename __result::__invoke_type; + if constexpr (is_void_v<_Res>) + std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + else + return std::__invoke_impl<__type>(__tag{}, + std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + } +# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 + template + struct _Maybe_unary_or_binary_function { }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1> + : std::unary_function<_T1, _Res> { }; + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> + : std::binary_function<_T1, _T2, _Res> { }; + +#pragma GCC diagnostic pop + + template + struct _Mem_fn_traits; + + template + struct _Mem_fn_traits_base + { + using __result_type = _Res; + using __maybe_type + = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; + using __arity = integral_constant; + }; +# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; + + +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; + + + + + + + template> + struct _Maybe_get_result_type + { }; + + template + struct _Maybe_get_result_type<_Functor, + __void_t> + { typedef typename _Functor::result_type result_type; }; + + + + + + template + struct _Weak_result_type_impl + : _Maybe_get_result_type<_Functor> + { }; + + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct + _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)> + { typedef _Res result_type; }; + + + template::value> + struct _Weak_result_type_memfun + : _Weak_result_type_impl<_Functor> + { }; + + + template + struct _Weak_result_type_memfun<_MemFunPtr, true> + { + using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; + }; + + + template + struct _Weak_result_type_memfun<_Func _Class::*, false> + { }; + + + + + + template + struct _Weak_result_type + : _Weak_result_type_memfun::type> + { }; + + + + template> + struct _Refwrap_base_arg1 + { }; + + + template + struct _Refwrap_base_arg1<_Tp, + __void_t> + { + typedef typename _Tp::argument_type argument_type; + }; + + + template> + struct _Refwrap_base_arg2 + { }; + + + template + struct _Refwrap_base_arg2<_Tp, + __void_t> + { + typedef typename _Tp::first_argument_type first_argument_type; + typedef typename _Tp::second_argument_type second_argument_type; + }; + + + + + + + + template + struct _Reference_wrapper_base + : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> + { }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) volatile> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const volatile> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> + : binary_function<_T1, _T2, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)> + : binary_function<_T1, _T2, _Res> + { }; + + template::value> + struct _Reference_wrapper_base_memfun + : _Reference_wrapper_base<_Tp> + { }; + + template + struct _Reference_wrapper_base_memfun<_MemFunPtr, true> + : _Mem_fn_traits<_MemFunPtr>::__maybe_type + { + using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; + }; +#pragma GCC diagnostic pop + + + + + + + + + template + class reference_wrapper + + + + : public _Reference_wrapper_base_memfun::type> + + { + _Tp* _M_data; + + + static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } + + static void _S_fun(_Tp&&) = delete; + + template> + using __not_same + = typename enable_if::value>::type; + + public: + typedef _Tp type; + + + + + template, typename + = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> + + reference_wrapper(_Up&& __uref) + noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) + : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) + { } + + reference_wrapper(const reference_wrapper&) = default; + + reference_wrapper& + operator=(const reference_wrapper&) = default; + + + operator _Tp&() const noexcept + { return this->get(); } + + + _Tp& + get() const noexcept + { return *_M_data; } + + template + + typename __invoke_result<_Tp&, _Args...>::type + operator()(_Args&&... __args) const + noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value) + { + + + + + return std::__invoke(get(), std::forward<_Args>(__args)...); + } + }; + + + template + reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; + + + + + + template + + inline reference_wrapper<_Tp> + ref(_Tp& __t) noexcept + { return reference_wrapper<_Tp>(__t); } + + + template + + inline reference_wrapper + cref(const _Tp& __t) noexcept + { return reference_wrapper(__t); } + + template + void ref(const _Tp&&) = delete; + + template + void cref(const _Tp&&) = delete; + + + template + + inline reference_wrapper<_Tp> + ref(reference_wrapper<_Tp> __t) noexcept + { return __t; } + + + template + + inline reference_wrapper + cref(reference_wrapper<_Tp> __t) noexcept + { return { __t.get() }; } + + + + +} +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(_Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(const _Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(_Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(const _Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr _Tp* + begin(_Tp (&__arr)[_Nm]) noexcept + { return __arr; } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr _Tp* + end(_Tp (&__arr)[_Nm]) noexcept + { return __arr + _Nm; } + + + + template class valarray; + + template _Tp* begin(valarray<_Tp>&) noexcept; + template const _Tp* begin(const valarray<_Tp>&) noexcept; + template _Tp* end(valarray<_Tp>&) noexcept; + template const _Tp* end(const valarray<_Tp>&) noexcept; + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + constexpr auto + cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) + -> decltype(std::begin(__cont)) + { return std::begin(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + constexpr auto + cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) + -> decltype(std::end(__cont)) + { return std::end(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rbegin(_Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(_Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(const _Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Tp*> + rbegin(_Tp (&__arr)[_Nm]) noexcept + { return reverse_iterator<_Tp*>(__arr + _Nm); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Tp*> + rend(_Tp (&__arr)[_Nm]) noexcept + { return reverse_iterator<_Tp*>(__arr); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator + rbegin(initializer_list<_Tp> __il) noexcept + { return reverse_iterator(__il.end()); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator + rend(initializer_list<_Tp> __il) noexcept + { return reverse_iterator(__il.begin()); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) + { return std::rbegin(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + crend(const _Container& __cont) -> decltype(std::rend(__cont)) + { return std::rend(__cont); } +# 261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + size(const _Container& __cont) noexcept(noexcept(__cont.size())) + -> decltype(__cont.size()) + { return __cont.size(); } + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr size_t + size(const _Tp (&)[_Nm]) noexcept + { return _Nm; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) + -> decltype(__cont.empty()) + { return __cont.empty(); } + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr bool + empty(const _Tp (&)[_Nm]) noexcept + { return false; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr bool + empty(initializer_list<_Tp> __il) noexcept + { return __il.size() == 0;} + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + data(_Container& __cont) noexcept(noexcept(__cont.data())) + -> decltype(__cont.data()) + { return __cont.data(); } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + data(const _Container& __cont) noexcept(noexcept(__cont.data())) + -> decltype(__cont.data()) + { return __cont.data(); } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr _Tp* + data(_Tp (&__array)[_Nm]) noexcept + { return __array; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr const _Tp* + data(initializer_list<_Tp> __il) noexcept + { return __il.begin(); } +# 371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 +} +# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 1 3 +# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + inline void + destroy_at(_Tp* __location) + { + if constexpr (201703L > 201703L && is_array_v<_Tp>) + { + for (auto& __x : *__location) + std::destroy_at(std::__addressof(__x)); + } + else + __location->~_Tp(); + } +# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + template + + inline void + _Construct(_Tp* __p, _Args&&... __args) + { +# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + } +# 132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + template + inline void + _Construct_novalue(_T1* __p) + { ::new((void*)__p) _T1; } + + template + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last); + + + + + template + constexpr inline void + _Destroy(_Tp* __pointer) + { + + + + __pointer->~_Tp(); + + } + + template + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator __first, _ForwardIterator __last) + { + for (; __first != __last; ++__first) + std::_Destroy(std::__addressof(*__first)); + } + }; + + template<> + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator, _ForwardIterator) { } + }; + + + + + + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: + __destroy(__first, __last); + } + + template + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + for (; __count > 0; (void)++__first, --__count) + std::_Destroy(std::__addressof(*__first)); + return __first; + } + }; + + template<> + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + std::advance(__first, __count); + return __first; + } + }; + + + + + + + template + inline _ForwardIterator + _Destroy_n(_ForwardIterator __first, _Size __count) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: + __destroy_n(__first, __count); + } + + + template + inline void + destroy(_ForwardIterator __first, _ForwardIterator __last) + { + std::_Destroy(__first, __last); + } + + template + inline _ForwardIterator + destroy_n(_ForwardIterator __first, _Size __count) + { + return std::_Destroy_n(__first, __count); + } + + + +} +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 2 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + struct __allocator_traits_base + { + template + struct __rebind : __replace_first_arg<_Tp, _Up> + { + static_assert(is_same< + typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, + _Tp>::value, + "allocator_traits::rebind_alloc must be A"); + }; + + template + struct __rebind<_Tp, _Up, + __void_t::other>> + { + using type = typename _Tp::template rebind<_Up>::other; + + static_assert(is_same< + typename _Tp::template rebind::other, + _Tp>::value, + "allocator_traits::rebind_alloc must be A"); + }; + + protected: + template + using __pointer = typename _Tp::pointer; + template + using __c_pointer = typename _Tp::const_pointer; + template + using __v_pointer = typename _Tp::void_pointer; + template + using __cv_pointer = typename _Tp::const_void_pointer; + template + using __pocca = typename _Tp::propagate_on_container_copy_assignment; + template + using __pocma = typename _Tp::propagate_on_container_move_assignment; + template + using __pocs = typename _Tp::propagate_on_container_swap; + template + using __equal = __type_identity; + }; + + template + using __alloc_rebind + = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; +# 104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct allocator_traits : __allocator_traits_base + { + + typedef _Alloc allocator_type; + + typedef typename _Alloc::value_type value_type; + + + + + + + using pointer = __detected_or_t; + + private: + + template class _Func, typename _Tp, typename = void> + struct _Ptr + { + using type = typename pointer_traits::template rebind<_Tp>; + }; + + template class _Func, typename _Tp> + struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> + { + using type = _Func<_Alloc>; + }; + + + template + struct _Diff + { using type = typename pointer_traits<_PtrT>::difference_type; }; + + template + struct _Diff<_A2, _PtrT, __void_t> + { using type = typename _A2::difference_type; }; + + + template + struct _Size : make_unsigned<_DiffT> { }; + + template + struct _Size<_A2, _DiffT, __void_t> + { using type = typename _A2::size_type; }; + + public: + + + + + + + using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; + + + + + + + + using void_pointer = typename _Ptr<__v_pointer, void>::type; + + + + + + + + using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; + + + + + + + + using difference_type = typename _Diff<_Alloc, pointer>::type; + + + + + + + + using size_type = typename _Size<_Alloc, difference_type>::type; + + + + + + + + using propagate_on_container_copy_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_move_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_swap + = __detected_or_t; + + + + + + + + using is_always_equal + = typename __detected_or_t, __equal, _Alloc>::type; + + template + using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; + template + using rebind_traits = allocator_traits>; + + private: + template + static constexpr auto + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) + -> decltype(__a.allocate(__n, __hint)) + { return __a.allocate(__n, __hint); } + + template + static constexpr pointer + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) + { return __a.allocate(__n); } + + template + struct __construct_helper + { + template()->construct( + std::declval<_Tp*>(), std::declval<_Args>()...))> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc>(0)); + }; + + template + using __has_construct + = typename __construct_helper<_Tp, _Args...>::type; + + template + static constexpr _Require<__has_construct<_Tp, _Args...>> + _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) + { __a.construct(__p, std::forward<_Args>(__args)...); } + + template + static constexpr + _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, + is_constructible<_Tp, _Args...>>> + _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) + { + + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + + + + } + + template + static constexpr auto + _S_destroy(_Alloc2& __a, _Tp* __p, int) + noexcept(noexcept(__a.destroy(__p))) + -> decltype(__a.destroy(__p)) + { __a.destroy(__p); } + + template + static constexpr void + _S_destroy(_Alloc2&, _Tp* __p, ...) + noexcept(std::is_nothrow_destructible<_Tp>::value) + { std::_Destroy(__p); } + + template + static constexpr auto + _S_max_size(_Alloc2& __a, int) + -> decltype(__a.max_size()) + { return __a.max_size(); } + + template + static constexpr size_type + _S_max_size(_Alloc2&, ...) + { + + + return __gnu_cxx::__numeric_traits::__max + / sizeof(value_type); + } + + template + static constexpr auto + _S_select(_Alloc2& __a, int) + -> decltype(__a.select_on_container_copy_construction()) + { return __a.select_on_container_copy_construction(); } + + template + static constexpr _Alloc2 + _S_select(_Alloc2& __a, ...) + { return __a; } + + public: +# 331 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n) + { return __a.allocate(__n); } +# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) + { return _S_allocate(__a, __n, __hint, 0); } +# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static void + deallocate(_Alloc& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 373 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + static auto + construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(_S_construct(__a, __p, + std::forward<_Args>(__args)...))) + -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) + { _S_construct(__a, __p, std::forward<_Args>(__args)...); } +# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + static void + destroy(_Alloc& __a, _Tp* __p) + noexcept(noexcept(_S_destroy(__a, __p, 0))) + { _S_destroy(__a, __p, 0); } +# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static size_type + max_size(const _Alloc& __a) noexcept + { return _S_max_size(__a, 0); } +# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static _Alloc + select_on_container_copy_construction(const _Alloc& __rhs) + { return _S_select(__rhs, 0); } + }; +# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct allocator_traits> + { + + using allocator_type = allocator<_Tp>; + + + using value_type = _Tp; + + + using pointer = _Tp*; + + + using const_pointer = const _Tp*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + using propagate_on_container_copy_assignment = false_type; + + + using propagate_on_container_move_assignment = true_type; + + + using propagate_on_container_swap = false_type; + + + using is_always_equal = true_type; + + template + using rebind_alloc = allocator<_Up>; + + template + using rebind_traits = allocator_traits>; +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) + { + + return __a.allocate(__n, __hint); + + + + } +# 513 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__gnu__::__always_inline__]] + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, + _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { + + __a.construct(__p, std::forward<_Args>(__args)...); + + + + } +# 550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { + + __a.destroy(__p); + + + + } + + + + + + + [[__gnu__::__always_inline__]] + static size_type + max_size(const allocator_type& __a __attribute__((__unused__))) noexcept + { + + return __a.max_size(); + + + + } + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; + + + template<> + struct allocator_traits> + { + + using allocator_type = allocator; + + + using value_type = void; + + + using pointer = void*; + + + using const_pointer = const void*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + using propagate_on_container_copy_assignment = false_type; + + + using propagate_on_container_move_assignment = true_type; + + + using propagate_on_container_swap = false_type; + + + using is_always_equal = true_type; + + template + using rebind_alloc = allocator<_Up>; + + template + using rebind_traits = allocator_traits>; + + + static void* + allocate(allocator_type&, size_type, const void* = nullptr) = delete; + + + static void + deallocate(allocator_type&, void*, size_type) = delete; +# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type&, _Up* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { std::_Construct(__p, std::forward<_Args>(__args)...); } +# 669 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + destroy(allocator_type&, _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { std::_Destroy(__p); } + + + static size_type + max_size(const allocator_type&) = delete; + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; +# 707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_copy(_Alloc& __one, const _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocca = + typename __traits::propagate_on_container_copy_assignment::type; + + if constexpr (__pocca::value) + __one = __two; + + + + } + + template + [[__gnu__::__always_inline__]] + constexpr _Alloc + __alloc_on_copy(const _Alloc& __a) + { + typedef allocator_traits<_Alloc> __traits; + return __traits::select_on_container_copy_construction(__a); + } +# 744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_move(_Alloc& __one, _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocma + = typename __traits::propagate_on_container_move_assignment::type; + + if constexpr (__pocma::value) + __one = std::move(__two); + + + + } +# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_swap(_Alloc& __one, _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocs = typename __traits::propagate_on_container_swap::type; + + if constexpr (__pocs::value) + { + using std::swap; + swap(__one, __two); + } + + + + } + + template, + typename = void> + struct __is_alloc_insertable_impl + : false_type + { }; + + template + struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, + __void_t::construct( + std::declval<_Alloc&>(), std::declval<_ValueT*>(), + std::declval<_Tp>()))>> + : true_type + { }; + + + + + template + struct __is_copy_insertable + : __is_alloc_insertable_impl<_Alloc, + typename _Alloc::value_type const&>::type + { }; + + + + template + struct __is_copy_insertable> + : is_copy_constructible<_Tp> + { }; + + + + + + template + struct __is_move_insertable + : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type + { }; + + + + template + struct __is_move_insertable> + : is_move_constructible<_Tp> + { }; + + + + template + struct __is_allocator : false_type { }; + + template + struct __is_allocator<_Alloc, + __void_t().allocate(size_t{}))>> + : true_type { }; + + template + using _RequireAllocator + = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; + + template + using _RequireNotAllocator + = typename enable_if::value, _Alloc>::type; +# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct __alloc_swap + { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; + + template + struct __alloc_swap<_Alloc, false> + { + static void + _S_do_it(_Alloc& __one, _Alloc& __two) noexcept + { + + if (__one != __two) + swap(__one, __two); + } + }; + + + template, + is_nothrow_move_constructible>::value> + struct __shrink_to_fit_aux + { static bool _S_do_it(_Tp&) noexcept { return false; } }; + + template + struct __shrink_to_fit_aux<_Tp, true> + { + + static bool + _S_do_it(_Tp& __c) noexcept + { + + try + { + _Tp(__make_move_if_noexcept_iterator(__c.begin()), + __make_move_if_noexcept_iterator(__c.end()), + __c.get_allocator()).swap(__c); + return true; + } + catch(...) + { return false; } + + + + } + }; +# 925 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + _Allocator& __alloc) + { + for (; __first != __last; ++__first) + + + + allocator_traits<_Allocator>::destroy(__alloc, + std::__addressof(*__first)); + + } + + + template + __attribute__((__always_inline__)) + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + allocator<_Tp>&) + { + std::_Destroy(__first, __last); + } + + + + +} +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + + + +template + struct __alloc_traits + + : std::allocator_traits<_Alloc> + + { + typedef _Alloc allocator_type; + + typedef std::allocator_traits<_Alloc> _Base_type; + typedef typename _Base_type::value_type value_type; + typedef typename _Base_type::pointer pointer; + typedef typename _Base_type::const_pointer const_pointer; + typedef typename _Base_type::size_type size_type; + typedef typename _Base_type::difference_type difference_type; + + typedef value_type& reference; + typedef const value_type& const_reference; + using _Base_type::allocate; + using _Base_type::deallocate; + using _Base_type::construct; + using _Base_type::destroy; + using _Base_type::max_size; + + private: + template + using __is_custom_pointer + = std::__and_, + std::__not_>>; + + public: + + template + [[__gnu__::__always_inline__]] + static constexpr + std::__enable_if_t<__is_custom_pointer<_Ptr>::value> + construct(_Alloc& __a, _Ptr __p, _Args&&... __args) + noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), + std::forward<_Args>(__args)...))) + { + _Base_type::construct(__a, std::__to_address(__p), + std::forward<_Args>(__args)...); + } + + + template + [[__gnu__::__always_inline__]] + static constexpr + std::__enable_if_t<__is_custom_pointer<_Ptr>::value> + destroy(_Alloc& __a, _Ptr __p) + noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) + { _Base_type::destroy(__a, std::__to_address(__p)); } + + [[__gnu__::__always_inline__]] + static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) + { return _Base_type::select_on_container_copy_construction(__a); } + + [[__gnu__::__always_inline__]] + static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) + { std::__alloc_on_swap(__a, __b); } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_copy_assign() + { return _Base_type::propagate_on_container_copy_assignment::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_move_assign() + { return _Base_type::propagate_on_container_move_assignment::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_swap() + { return _Base_type::propagate_on_container_swap::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_always_equal() + { return _Base_type::is_always_equal::value; } + + __attribute__((__always_inline__)) + static constexpr bool _S_nothrow_move() + { return _S_propagate_on_move_assign() || _S_always_equal(); } + + template + struct rebind + { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; +# 180 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 + }; + + +} +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 2 3 + + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template + struct __hash_base + { + typedef _Result result_type [[__deprecated__]]; + typedef _Arg argument_type [[__deprecated__]]; + }; + + + template + struct hash; + + template + struct __poison_hash + { + static constexpr bool __enable_hash_call = false; + private: + + __poison_hash(__poison_hash&&); + ~__poison_hash(); + }; + + template + struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> + { + static constexpr bool __enable_hash_call = true; + }; + + + template::value> + struct __hash_enum + { + private: + + __hash_enum(__hash_enum&&); + ~__hash_enum(); + }; + + + template + struct __hash_enum<_Tp, true> : public __hash_base + { + size_t + operator()(_Tp __val) const noexcept + { + using __type = typename underlying_type<_Tp>::type; + return hash<__type>{}(static_cast<__type>(__val)); + } + }; + + + + template + struct hash : __hash_enum<_Tp> + { }; + + + template + struct hash<_Tp*> : public __hash_base + { + size_t + operator()(_Tp* __p) const noexcept + { return reinterpret_cast(__p); } + }; +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; + + + + + + + + template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; +# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + struct _Hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(0xc70f6907UL)) + { return _Hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + + struct _Fnv_hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(2166136261UL)) + { return _Fnv_hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(float __val) const noexcept + { + + return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(double __val) const noexcept + { + + return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash + : public __hash_base + { + __attribute__ ((__pure__)) size_t + operator()(long double __val) const noexcept; + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(nullptr_t) const noexcept + { return 0; } + }; +# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template + struct __is_fast_hash : public std::true_type + { }; + + template<> + struct __is_fast_hash> : public std::false_type + { }; + + +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 2 3 +# 56 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 69 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 + constexpr size_t + __sv_check(size_t __size, size_t __pos, const char* __s) + { + if (__pos > __size) + __throw_out_of_range_fmt(("%s: __pos (which is %zu) > __size " "(which is %zu)"), __s, __pos, __size); + + return __pos; + } + + + + constexpr size_t + __sv_limit(size_t __size, size_t __pos, size_t __off) noexcept + { + const bool __testoff = __off < __size - __pos; + return __testoff ? __off : __size - __pos; + } +# 105 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 + template> + class basic_string_view + { + static_assert(!is_array_v<_CharT>); + static_assert(is_trivial_v<_CharT> && is_standard_layout_v<_CharT>); + static_assert(is_same_v<_CharT, typename _Traits::char_type>); + + public: + + + using traits_type = _Traits; + using value_type = _CharT; + using pointer = value_type*; + using const_pointer = const value_type*; + using reference = value_type&; + using const_reference = const value_type&; + using const_iterator = const value_type*; + using iterator = const_iterator; + using const_reverse_iterator = std::reverse_iterator; + using reverse_iterator = const_reverse_iterator; + using size_type = size_t; + using difference_type = ptrdiff_t; + static constexpr size_type npos = size_type(-1); + + + + constexpr + basic_string_view() noexcept + : _M_len{0}, _M_str{nullptr} + { } + + constexpr basic_string_view(const basic_string_view&) noexcept = default; + + [[__gnu__::__nonnull__]] + constexpr + basic_string_view(const _CharT* __str) noexcept + : _M_len{traits_type::length(__str)}, + _M_str{__str} + { } + + constexpr + basic_string_view(const _CharT* __str, size_type __len) noexcept + : _M_len{__len}, _M_str{__str} + { } +# 182 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 + constexpr basic_string_view& + operator=(const basic_string_view&) noexcept = default; + + + + [[nodiscard]] + constexpr const_iterator + begin() const noexcept + { return this->_M_str; } + + [[nodiscard]] + constexpr const_iterator + end() const noexcept + { return this->_M_str + this->_M_len; } + + [[nodiscard]] + constexpr const_iterator + cbegin() const noexcept + { return this->_M_str; } + + [[nodiscard]] + constexpr const_iterator + cend() const noexcept + { return this->_M_str + this->_M_len; } + + [[nodiscard]] + constexpr const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(this->end()); } + + [[nodiscard]] + constexpr const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(this->begin()); } + + [[nodiscard]] + constexpr const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(this->end()); } + + [[nodiscard]] + constexpr const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(this->begin()); } + + + + [[nodiscard]] + constexpr size_type + size() const noexcept + { return this->_M_len; } + + [[nodiscard]] + constexpr size_type + length() const noexcept + { return _M_len; } + + [[nodiscard]] + constexpr size_type + max_size() const noexcept + { + return (npos - sizeof(size_type) - sizeof(void*)) + / sizeof(value_type) / 4; + } + + [[nodiscard]] + constexpr bool + empty() const noexcept + { return this->_M_len == 0; } + + + + [[nodiscard]] + constexpr const_reference + operator[](size_type __pos) const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__pos < this->_M_len)) __builtin_unreachable(); } while (false); + return *(this->_M_str + __pos); + } + + [[nodiscard]] + constexpr const_reference + at(size_type __pos) const + { + if (__pos >= _M_len) + __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)"), __pos, this->size()); + + + return *(this->_M_str + __pos); + } + + [[nodiscard]] + constexpr const_reference + front() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(this->_M_len > 0)) __builtin_unreachable(); } while (false); + return *this->_M_str; + } + + [[nodiscard]] + constexpr const_reference + back() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(this->_M_len > 0)) __builtin_unreachable(); } while (false); + return *(this->_M_str + this->_M_len - 1); + } + + [[nodiscard]] + constexpr const_pointer + data() const noexcept + { return this->_M_str; } + + + + constexpr void + remove_prefix(size_type __n) noexcept + { + do { if (std::__is_constant_evaluated() && !bool(this->_M_len >= __n)) __builtin_unreachable(); } while (false); + this->_M_str += __n; + this->_M_len -= __n; + } + + constexpr void + remove_suffix(size_type __n) noexcept + { this->_M_len -= __n; } + + constexpr void + swap(basic_string_view& __sv) noexcept + { + auto __tmp = *this; + *this = __sv; + __sv = __tmp; + } + + + + + size_type + copy(_CharT* __str, size_type __n, size_type __pos = 0) const + { + ; + __pos = std::__sv_check(size(), __pos, "basic_string_view::copy"); + const size_type __rlen = std::min(__n, _M_len - __pos); + + + traits_type::copy(__str, data() + __pos, __rlen); + return __rlen; + } + + [[nodiscard]] + constexpr basic_string_view + substr(size_type __pos = 0, size_type __n = npos) const noexcept(false) + { + __pos = std::__sv_check(size(), __pos, "basic_string_view::substr"); + const size_type __rlen = std::min(__n, _M_len - __pos); + return basic_string_view{_M_str + __pos, __rlen}; + } + + [[nodiscard]] + constexpr int + compare(basic_string_view __str) const noexcept + { + const size_type __rlen = std::min(this->_M_len, __str._M_len); + int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen); + if (__ret == 0) + __ret = _S_compare(this->_M_len, __str._M_len); + return __ret; + } + + [[nodiscard]] + constexpr int + compare(size_type __pos1, size_type __n1, basic_string_view __str) const + { return this->substr(__pos1, __n1).compare(__str); } + + [[nodiscard]] + constexpr int + compare(size_type __pos1, size_type __n1, + basic_string_view __str, size_type __pos2, size_type __n2) const + { + return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); + } + + [[nodiscard, __gnu__::__nonnull__]] + constexpr int + compare(const _CharT* __str) const noexcept + { return this->compare(basic_string_view{__str}); } + + [[nodiscard, __gnu__::__nonnull__]] + constexpr int + compare(size_type __pos1, size_type __n1, const _CharT* __str) const + { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); } + + [[nodiscard]] + constexpr int + compare(size_type __pos1, size_type __n1, + const _CharT* __str, size_type __n2) const noexcept(false) + { + return this->substr(__pos1, __n1) + .compare(basic_string_view(__str, __n2)); + } +# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 + [[nodiscard]] + constexpr size_type + find(basic_string_view __str, size_type __pos = 0) const noexcept + { return this->find(__str._M_str, __pos, __str._M_len); } + + [[nodiscard]] + constexpr size_type + find(_CharT __c, size_type __pos = 0) const noexcept; + + [[nodiscard]] + constexpr size_type + find(const _CharT* __str, size_type __pos, size_type __n) const noexcept; + + [[nodiscard, __gnu__::__nonnull__]] + constexpr size_type + find(const _CharT* __str, size_type __pos = 0) const noexcept + { return this->find(__str, __pos, traits_type::length(__str)); } + + [[nodiscard]] + constexpr size_type + rfind(basic_string_view __str, size_type __pos = npos) const noexcept + { return this->rfind(__str._M_str, __pos, __str._M_len); } + + [[nodiscard]] + constexpr size_type + rfind(_CharT __c, size_type __pos = npos) const noexcept; + + [[nodiscard]] + constexpr size_type + rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept; + + [[nodiscard, __gnu__::__nonnull__]] + constexpr size_type + rfind(const _CharT* __str, size_type __pos = npos) const noexcept + { return this->rfind(__str, __pos, traits_type::length(__str)); } + + [[nodiscard]] + constexpr size_type + find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept + { return this->find_first_of(__str._M_str, __pos, __str._M_len); } + + [[nodiscard]] + constexpr size_type + find_first_of(_CharT __c, size_type __pos = 0) const noexcept + { return this->find(__c, __pos); } + + [[nodiscard]] + constexpr size_type + find_first_of(const _CharT* __str, size_type __pos, + size_type __n) const noexcept; + + [[nodiscard, __gnu__::__nonnull__]] + constexpr size_type + find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept + { return this->find_first_of(__str, __pos, traits_type::length(__str)); } + + [[nodiscard]] + constexpr size_type + find_last_of(basic_string_view __str, + size_type __pos = npos) const noexcept + { return this->find_last_of(__str._M_str, __pos, __str._M_len); } + + [[nodiscard]] + constexpr size_type + find_last_of(_CharT __c, size_type __pos=npos) const noexcept + { return this->rfind(__c, __pos); } + + [[nodiscard]] + constexpr size_type + find_last_of(const _CharT* __str, size_type __pos, + size_type __n) const noexcept; + + [[nodiscard, __gnu__::__nonnull__]] + constexpr size_type + find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept + { return this->find_last_of(__str, __pos, traits_type::length(__str)); } + + [[nodiscard]] + constexpr size_type + find_first_not_of(basic_string_view __str, + size_type __pos = 0) const noexcept + { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); } + + [[nodiscard]] + constexpr size_type + find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept; + + [[nodiscard]] + constexpr size_type + find_first_not_of(const _CharT* __str, + size_type __pos, size_type __n) const noexcept; + + [[nodiscard, __gnu__::__nonnull__]] + constexpr size_type + find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept + { + return this->find_first_not_of(__str, __pos, + traits_type::length(__str)); + } + + [[nodiscard]] + constexpr size_type + find_last_not_of(basic_string_view __str, + size_type __pos = npos) const noexcept + { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); } + + [[nodiscard]] + constexpr size_type + find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept; + + [[nodiscard]] + constexpr size_type + find_last_not_of(const _CharT* __str, + size_type __pos, size_type __n) const noexcept; + + [[nodiscard, __gnu__::__nonnull__]] + constexpr size_type + find_last_not_of(const _CharT* __str, + size_type __pos = npos) const noexcept + { + return this->find_last_not_of(__str, __pos, + traits_type::length(__str)); + } + + private: + + static constexpr int + _S_compare(size_type __n1, size_type __n2) noexcept + { + using __limits = __gnu_cxx::__int_traits; + const difference_type __diff = __n1 - __n2; + if (__diff > __limits::__max) + return __limits::__max; + if (__diff < __limits::__min) + return __limits::__min; + return static_cast(__diff); + } + + size_t _M_len; + const _CharT* _M_str; + }; +# 605 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 + template + [[nodiscard]] + constexpr bool + operator==(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.size() == __y.size() && __x.compare(__y) == 0; } + + template + [[nodiscard]] + constexpr bool + operator==(basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return __x.size() == __y.size() && __x.compare(__y) == 0; } +# 638 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 + template + [[nodiscard]] + constexpr bool + operator==(__type_identity_t> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.size() == __y.size() && __x.compare(__y) == 0; } + + template + [[nodiscard]] + constexpr bool + operator!=(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return !(__x == __y); } + + template + [[nodiscard]] + constexpr bool + operator!=(basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return !(__x == __y); } + + template + [[nodiscard]] + constexpr bool + operator!=(__type_identity_t> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return !(__x == __y); } + + template + [[nodiscard]] + constexpr bool + operator< (basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) < 0; } + + template + [[nodiscard]] + constexpr bool + operator< (basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return __x.compare(__y) < 0; } + + template + [[nodiscard]] + constexpr bool + operator< (__type_identity_t> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) < 0; } + + template + [[nodiscard]] + constexpr bool + operator> (basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) > 0; } + + template + [[nodiscard]] + constexpr bool + operator> (basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return __x.compare(__y) > 0; } + + template + [[nodiscard]] + constexpr bool + operator> (__type_identity_t> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) > 0; } + + template + [[nodiscard]] + constexpr bool + operator<=(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) <= 0; } + + template + [[nodiscard]] + constexpr bool + operator<=(basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return __x.compare(__y) <= 0; } + + template + [[nodiscard]] + constexpr bool + operator<=(__type_identity_t> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) <= 0; } + + template + [[nodiscard]] + constexpr bool + operator>=(basic_string_view<_CharT, _Traits> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) >= 0; } + + template + [[nodiscard]] + constexpr bool + operator>=(basic_string_view<_CharT, _Traits> __x, + __type_identity_t> __y) + noexcept + { return __x.compare(__y) >= 0; } + + template + [[nodiscard]] + constexpr bool + operator>=(__type_identity_t> __x, + basic_string_view<_CharT, _Traits> __y) noexcept + { return __x.compare(__y) >= 0; } + + + + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + basic_string_view<_CharT,_Traits> __str) + { return __ostream_insert(__os, __str.data(), __str.size()); } + + + + + using string_view = basic_string_view; + using wstring_view = basic_string_view; + + + + using u16string_view = basic_string_view; + using u32string_view = basic_string_view; + + + + template + struct hash; + + template<> + struct hash + : public __hash_base + { + [[nodiscard]] + size_t + operator()(const string_view& __str) const noexcept + { return std::_Hash_impl::hash(__str.data(), __str.length()); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + + template<> + struct hash + : public __hash_base + { + [[nodiscard]] + size_t + operator()(const wstring_view& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(wchar_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; +# 825 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 + template<> + struct hash + : public __hash_base + { + [[nodiscard]] + size_t + operator()(const u16string_view& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(char16_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + + template<> + struct hash + : public __hash_base + { + [[nodiscard]] + size_t + operator()(const u32string_view& __s) const noexcept + { return std::_Hash_impl::hash(__s.data(), + __s.length() * sizeof(char32_t)); } + }; + + template<> + struct __is_fast_hash> : std::false_type + { }; + + inline namespace literals + { + inline namespace string_view_literals + { +#pragma GCC diagnostic push + + inline constexpr basic_string_view + operator""sv(const char* __str, size_t __len) noexcept + { return basic_string_view{__str, __len}; } + + inline constexpr basic_string_view + operator""sv(const wchar_t* __str, size_t __len) noexcept + { return basic_string_view{__str, __len}; } + + + + + + + + inline constexpr basic_string_view + operator""sv(const char16_t* __str, size_t __len) noexcept + { return basic_string_view{__str, __len}; } + + inline constexpr basic_string_view + operator""sv(const char32_t* __str, size_t __len) noexcept + { return basic_string_view{__str, __len}; } + +#pragma GCC diagnostic pop + } + } +# 902 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 +} + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/string_view.tcc" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/string_view.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find(const _CharT* __str, size_type __pos, size_type __n) const noexcept + { + ; + + if (__n == 0) + return __pos <= _M_len ? __pos : npos; + if (__pos >= _M_len) + return npos; + + const _CharT __elem0 = __str[0]; + const _CharT* __first = _M_str + __pos; + const _CharT* const __last = _M_str + _M_len; + size_type __len = _M_len - __pos; + + while (__len >= __n) + { + + __first = traits_type::find(__first, __len - __n + 1, __elem0); + if (!__first) + return npos; + + + + if (traits_type::compare(__first, __str, __n) == 0) + return __first - _M_str; + __len = __last - ++__first; + } + return npos; + } + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find(_CharT __c, size_type __pos) const noexcept + { + size_type __ret = npos; + if (__pos < this->_M_len) + { + const size_type __n = this->_M_len - __pos; + const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c); + if (__p) + __ret = __p - this->_M_str; + } + return __ret; + } + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept + { + ; + + if (__n <= this->_M_len) + { + __pos = std::min(size_type(this->_M_len - __n), __pos); + do + { + if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0) + return __pos; + } + while (__pos-- > 0); + } + return npos; + } + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + rfind(_CharT __c, size_type __pos) const noexcept + { + size_type __size = this->_M_len; + if (__size > 0) + { + if (--__size > __pos) + __size = __pos; + for (++__size; __size-- > 0; ) + if (traits_type::eq(this->_M_str[__size], __c)) + return __size; + } + return npos; + } + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_first_of(const _CharT* __str, size_type __pos, + size_type __n) const noexcept + { + ; + for (; __n && __pos < this->_M_len; ++__pos) + { + const _CharT* __p = traits_type::find(__str, __n, + this->_M_str[__pos]); + if (__p) + return __pos; + } + return npos; + } + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_last_of(const _CharT* __str, size_type __pos, + size_type __n) const noexcept + { + ; + size_type __size = this->size(); + if (__size && __n) + { + if (--__size > __pos) + __size = __pos; + do + { + if (traits_type::find(__str, __n, this->_M_str[__size])) + return __size; + } + while (__size-- != 0); + } + return npos; + } + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_first_not_of(const _CharT* __str, size_type __pos, + size_type __n) const noexcept + { + ; + for (; __pos < this->_M_len; ++__pos) + if (!traits_type::find(__str, __n, this->_M_str[__pos])) + return __pos; + return npos; + } + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_first_not_of(_CharT __c, size_type __pos) const noexcept + { + for (; __pos < this->_M_len; ++__pos) + if (!traits_type::eq(this->_M_str[__pos], __c)) + return __pos; + return npos; + } + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_last_not_of(const _CharT* __str, size_type __pos, + size_type __n) const noexcept + { + ; + size_type __size = this->_M_len; + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::find(__str, __n, this->_M_str[__size])) + return __size; + } + while (__size--); + } + return npos; + } + + template + constexpr typename basic_string_view<_CharT, _Traits>::size_type + basic_string_view<_CharT, _Traits>:: + find_last_not_of(_CharT __c, size_type __pos) const noexcept + { + size_type __size = this->_M_len; + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::eq(this->_M_str[__size], __c)) + return __size; + } + while (__size--); + } + return npos; + } + + +} +# 905 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 2 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace __cxx11 { +# 86 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + class basic_string + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_CharT>::other _Char_alloc_type; + + typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits; + + + public: + typedef _Traits traits_type; + typedef typename _Traits::char_type value_type; + typedef _Char_alloc_type allocator_type; + typedef typename _Alloc_traits::size_type size_type; + typedef typename _Alloc_traits::difference_type difference_type; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + typedef typename _Alloc_traits::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef __gnu_cxx::__normal_iterator iterator; + typedef __gnu_cxx::__normal_iterator + const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + + + static const size_type npos = static_cast(-1); + + protected: + + + + + typedef const_iterator __const_iterator; + + + private: + static pointer + _S_allocate(_Char_alloc_type& __a, size_type __n) + { + pointer __p = _Alloc_traits::allocate(__a, __n); +# 136 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + return __p; + } + + + + typedef basic_string_view<_CharT, _Traits> __sv_type; + + template + using _If_sv = enable_if_t< + __and_, + __not_>, + __not_>>::value, + _Res>; + + + + static __sv_type + _S_to_string_view(__sv_type __svt) noexcept + { return __svt; } + + + + + + struct __sv_wrapper + { + explicit + __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { } + + __sv_type _M_sv; + }; +# 175 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + explicit + basic_string(__sv_wrapper __svw, const _Alloc& __a) + : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { } + + + + struct _Alloc_hider : allocator_type + { + + + + + + _Alloc_hider(pointer __dat, const _Alloc& __a) + : allocator_type(__a), _M_p(__dat) { } + + + _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc()) + : allocator_type(std::move(__a)), _M_p(__dat) { } + + + pointer _M_p; + }; + + _Alloc_hider _M_dataplus; + size_type _M_string_length; + + enum { _S_local_capacity = 15 / sizeof(_CharT) }; + + union + { + _CharT _M_local_buf[_S_local_capacity + 1]; + size_type _M_allocated_capacity; + }; + + + void + _M_data(pointer __p) + { _M_dataplus._M_p = __p; } + + + void + _M_length(size_type __length) + { _M_string_length = __length; } + + + pointer + _M_data() const + { return _M_dataplus._M_p; } + + + pointer + _M_local_data() + { + + return std::pointer_traits::pointer_to(*_M_local_buf); + + + + } + + + const_pointer + _M_local_data() const + { + + return std::pointer_traits::pointer_to(*_M_local_buf); + + + + } + + + void + _M_capacity(size_type __capacity) + { _M_allocated_capacity = __capacity; } + + + void + _M_set_length(size_type __n) + { + _M_length(__n); + traits_type::assign(_M_data()[__n], _CharT()); + } + + + bool + _M_is_local() const + { + if (_M_data() == _M_local_data()) + { + if (_M_string_length > _S_local_capacity) + __builtin_unreachable(); + return true; + } + return false; + } + + + + pointer + _M_create(size_type&, size_type); + + + void + _M_dispose() + { + if (!_M_is_local()) + _M_destroy(_M_allocated_capacity); + } + + + void + _M_destroy(size_type __size) throw() + { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); } +# 316 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + void + _M_construct(_InIterator __beg, _InIterator __end, + std::input_iterator_tag); + + + + template + + void + _M_construct(_FwdIterator __beg, _FwdIterator __end, + std::forward_iterator_tag); + + + void + _M_construct(size_type __req, _CharT __c); + + + allocator_type& + _M_get_allocator() + { return _M_dataplus; } + + + const allocator_type& + _M_get_allocator() const + { return _M_dataplus; } + + + __attribute__((__always_inline__)) + constexpr + pointer + _M_use_local_data() noexcept + { + + + + + + return _M_local_data(); + } + + private: +# 375 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + size_type + _M_check(size_type __pos, const char* __s) const + { + if (__pos > this->size()) + __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"), + + __s, __pos, this->size()); + return __pos; + } + + + void + _M_check_length(size_type __n1, size_type __n2, const char* __s) const + { + if (this->max_size() - (this->size() - __n1) < __n2) + __throw_length_error((__s)); + } + + + + + size_type + _M_limit(size_type __pos, size_type __off) const noexcept + { + const bool __testoff = __off < this->size() - __pos; + return __testoff ? __off : this->size() - __pos; + } + + + bool + _M_disjunct(const _CharT* __s) const noexcept + { + return (less()(__s, _M_data()) + || less()(_M_data() + this->size(), __s)); + } + + + + + static void + _S_copy(_CharT* __d, const _CharT* __s, size_type __n) + { + if (__n == 1) + traits_type::assign(*__d, *__s); + else + traits_type::copy(__d, __s, __n); + } + + + static void + _S_move(_CharT* __d, const _CharT* __s, size_type __n) + { + if (__n == 1) + traits_type::assign(*__d, *__s); + else + traits_type::move(__d, __s, __n); + } + + + static void + _S_assign(_CharT* __d, size_type __n, _CharT __c) + { + if (__n == 1) + traits_type::assign(*__d, __c); + else + traits_type::assign(__d, __n, __c); + } + + + + template + + static void + _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) + { + for (; __k1 != __k2; ++__k1, (void)++__p) + traits_type::assign(*__p, *__k1); + } + + + static void + _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept + { _S_copy_chars(__p, __k1.base(), __k2.base()); } + + + static void + _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) + noexcept + { _S_copy_chars(__p, __k1.base(), __k2.base()); } + + + static void + _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept + { _S_copy(__p, __k1, __k2 - __k1); } + + + static void + _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) + noexcept + { _S_copy(__p, __k1, __k2 - __k1); } + + + static int + _S_compare(size_type __n1, size_type __n2) noexcept + { + const difference_type __d = difference_type(__n1 - __n2); + + if (__d > __gnu_cxx::__numeric_traits::__max) + return __gnu_cxx::__numeric_traits::__max; + else if (__d < __gnu_cxx::__numeric_traits::__min) + return __gnu_cxx::__numeric_traits::__min; + else + return int(__d); + } + + + void + _M_assign(const basic_string&); + + + void + _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, + size_type __len2); + + + void + _M_erase(size_type __pos, size_type __n); + + public: +# 512 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string() + noexcept(is_nothrow_default_constructible<_Alloc>::value) + : _M_dataplus(_M_local_data()) + { + _M_use_local_data(); + _M_set_length(0); + } + + + + + + explicit + basic_string(const _Alloc& __a) noexcept + : _M_dataplus(_M_local_data(), __a) + { + _M_use_local_data(); + _M_set_length(0); + } + + + + + + + basic_string(const basic_string& __str) + : _M_dataplus(_M_local_data(), + _Alloc_traits::_S_select_on_copy(__str._M_get_allocator())) + { + _M_construct(__str._M_data(), __str._M_data() + __str.length(), + std::forward_iterator_tag()); + } +# 554 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string(const basic_string& __str, size_type __pos, + const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { + const _CharT* __start = __str._M_data() + + __str._M_check(__pos, "basic_string::basic_string"); + _M_construct(__start, __start + __str._M_limit(__pos, npos), + std::forward_iterator_tag()); + } +# 571 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string(const basic_string& __str, size_type __pos, + size_type __n) + : _M_dataplus(_M_local_data()) + { + const _CharT* __start = __str._M_data() + + __str._M_check(__pos, "basic_string::basic_string"); + _M_construct(__start, __start + __str._M_limit(__pos, __n), + std::forward_iterator_tag()); + } +# 589 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string(const basic_string& __str, size_type __pos, + size_type __n, const _Alloc& __a) + : _M_dataplus(_M_local_data(), __a) + { + const _CharT* __start + = __str._M_data() + __str._M_check(__pos, "string::string"); + _M_construct(__start, __start + __str._M_limit(__pos, __n), + std::forward_iterator_tag()); + } +# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string(const _CharT* __s, size_type __n, + const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { + + if (__s == 0 && __n > 0) + std::__throw_logic_error(("basic_string: " "construction from null is not valid")); + + _M_construct(__s, __s + __n, std::forward_iterator_tag()); + } +# 628 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template> + + + basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { + + if (__s == 0) + std::__throw_logic_error(("basic_string: " "construction from null is not valid")); + + const _CharT* __end = __s + traits_type::length(__s); + _M_construct(__s, __end, forward_iterator_tag()); + } +# 651 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template> + + + basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__n, __c); } +# 667 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string(basic_string&& __str) noexcept + : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator())) + { + if (__str._M_is_local()) + { + traits_type::copy(_M_local_buf, __str._M_local_buf, + __str.length() + 1); + } + else + { + _M_data(__str._M_data()); + _M_capacity(__str._M_allocated_capacity); + } + + + + + _M_length(__str.length()); + __str._M_data(__str._M_local_data()); + __str._M_set_length(0); + } + + + + + + + + basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__l.begin(), __l.end(), std::forward_iterator_tag()); } + + + basic_string(const basic_string& __str, const _Alloc& __a) + : _M_dataplus(_M_local_data(), __a) + { _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); } + + + basic_string(basic_string&& __str, const _Alloc& __a) + noexcept(_Alloc_traits::_S_always_equal()) + : _M_dataplus(_M_local_data(), __a) + { + if (__str._M_is_local()) + { + traits_type::copy(_M_local_buf, __str._M_local_buf, + __str.length() + 1); + _M_length(__str.length()); + __str._M_set_length(0); + } + else if (_Alloc_traits::_S_always_equal() + || __str.get_allocator() == __a) + { + _M_data(__str._M_data()); + _M_length(__str.length()); + _M_capacity(__str._M_allocated_capacity); + __str._M_data(__str._M_local_buf); + __str._M_set_length(0); + } + else + _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); + } +# 742 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template> + + + + + basic_string(_InputIterator __beg, _InputIterator __end, + const _Alloc& __a = _Alloc()) + : _M_dataplus(_M_local_data(), __a), _M_string_length(0) + { + + _M_construct(__beg, __end, std::__iterator_category(__beg)); + + + + + } +# 768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template>> + + basic_string(const _Tp& __t, size_type __pos, size_type __n, + const _Alloc& __a = _Alloc()) + : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { } + + + + + + + template> + + explicit + basic_string(const _Tp& __t, const _Alloc& __a = _Alloc()) + : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { } + + + + + + + ~basic_string() + { _M_dispose(); } + + + + + + + basic_string& + operator=(const basic_string& __str) + { + return this->assign(__str); + } + + + + + + + basic_string& + operator=(const _CharT* __s) + { return this->assign(__s); } +# 822 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + operator=(_CharT __c) + { + this->assign(1, __c); + return *this; + } +# 840 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + operator=(basic_string&& __str) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + const bool __equal_allocs = _Alloc_traits::_S_always_equal() + || _M_get_allocator() == __str._M_get_allocator(); + if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign() + && !__equal_allocs) + { + + _M_destroy(_M_allocated_capacity); + _M_data(_M_local_data()); + _M_set_length(0); + } + + std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator()); + + if (__str._M_is_local()) + { + + + + if (__builtin_expect(std::__addressof(__str) != this, true)) + { + if (__str.size()) + this->_S_copy(_M_data(), __str._M_data(), __str.size()); + _M_set_length(__str.size()); + } + } + else if (_Alloc_traits::_S_propagate_on_move_assign() || __equal_allocs) + { + + pointer __data = nullptr; + size_type __capacity; + if (!_M_is_local()) + { + if (__equal_allocs) + { + + __data = _M_data(); + __capacity = _M_allocated_capacity; + } + else + _M_destroy(_M_allocated_capacity); + } + + _M_data(__str._M_data()); + _M_length(__str.length()); + _M_capacity(__str._M_allocated_capacity); + if (__data) + { + __str._M_data(__data); + __str._M_capacity(__capacity); + } + else + __str._M_data(__str._M_local_buf); + } + else + assign(__str); + __str.clear(); + return *this; + } + + + + + + + basic_string& + operator=(initializer_list<_CharT> __l) + { + this->assign(__l.begin(), __l.size()); + return *this; + } + + + + + + + + template + + _If_sv<_Tp, basic_string&> + operator=(const _Tp& __svt) + { return this->assign(__svt); } + + + + + + + operator __sv_type() const noexcept + { return __sv_type(data(), size()); } + + + + + + + + [[__nodiscard__]] + iterator + begin() noexcept + { return iterator(_M_data()); } + + + + + + [[__nodiscard__]] + const_iterator + begin() const noexcept + { return const_iterator(_M_data()); } + + + + + + [[__nodiscard__]] + iterator + end() noexcept + { return iterator(_M_data() + this->size()); } + + + + + + [[__nodiscard__]] + const_iterator + end() const noexcept + { return const_iterator(_M_data() + this->size()); } + + + + + + + [[__nodiscard__]] + reverse_iterator + rbegin() noexcept + { return reverse_iterator(this->end()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(this->end()); } + + + + + + + [[__nodiscard__]] + reverse_iterator + rend() noexcept + { return reverse_iterator(this->begin()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(this->begin()); } + + + + + + + [[__nodiscard__]] + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_data()); } + + + + + + [[__nodiscard__]] + const_iterator + cend() const noexcept + { return const_iterator(this->_M_data() + this->size()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(this->end()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(this->begin()); } + + + public: + + + + [[__nodiscard__]] + size_type + size() const noexcept + { return _M_string_length; } + + + + [[__nodiscard__]] + size_type + length() const noexcept + { return _M_string_length; } + + + [[__nodiscard__]] + size_type + max_size() const noexcept + { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; } +# 1086 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + void + resize(size_type __n, _CharT __c); +# 1100 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + void + resize(size_type __n) + { this->resize(__n, _CharT()); } + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + void + shrink_to_fit() noexcept + { reserve(); } +#pragma GCC diagnostic pop +# 1155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + capacity() const noexcept + { + return _M_is_local() ? size_type(_S_local_capacity) + : _M_allocated_capacity; + } +# 1181 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + void + reserve(size_type __res_arg); +# 1191 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + void + reserve(); + + + + + + void + clear() noexcept + { _M_set_length(0); } + + + + + + [[__nodiscard__]] + bool + empty() const noexcept + { return this->size() == 0; } +# 1222 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + const_reference + operator[] (size_type __pos) const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(__pos <= size())) __builtin_unreachable(); } while (false); + return _M_data()[__pos]; + } +# 1240 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + reference + operator[](size_type __pos) + { + + + do { if (std::__is_constant_evaluated() && !bool(__pos <= size())) __builtin_unreachable(); } while (false); + + ; + return _M_data()[__pos]; + } +# 1262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + const_reference + at(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"), + + + __n, this->size()); + return _M_data()[__n]; + } +# 1284 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + reference + at(size_type __n) + { + if (__n >= size()) + __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"), + + + __n, this->size()); + return _M_data()[__n]; + } + + + + + + + [[__nodiscard__]] + reference + front() noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); + return operator[](0); + } + + + + + + [[__nodiscard__]] + const_reference + front() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); + return operator[](0); + } + + + + + + [[__nodiscard__]] + reference + back() noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); + return operator[](this->size() - 1); + } + + + + + + [[__nodiscard__]] + const_reference + back() const noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); + return operator[](this->size() - 1); + } +# 1353 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + operator+=(const basic_string& __str) + { return this->append(__str); } + + + + + + + + basic_string& + operator+=(const _CharT* __s) + { return this->append(__s); } + + + + + + + + basic_string& + operator+=(_CharT __c) + { + this->push_back(__c); + return *this; + } +# 1387 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + operator+=(initializer_list<_CharT> __l) + { return this->append(__l.begin(), __l.size()); } +# 1398 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + operator+=(const _Tp& __svt) + { return this->append(__svt); } +# 1411 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + append(const basic_string& __str) + { return this->append(__str._M_data(), __str.size()); } +# 1429 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + append(const basic_string& __str, size_type __pos, size_type __n = npos) + { return this->append(__str._M_data() + + __str._M_check(__pos, "basic_string::append"), + __str._M_limit(__pos, __n)); } +# 1442 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + append(const _CharT* __s, size_type __n) + { + ; + _M_check_length(size_type(0), __n, "basic_string::append"); + return _M_append(__s, __n); + } + + + + + + + + basic_string& + append(const _CharT* __s) + { + ; + const size_type __n = traits_type::length(__s); + _M_check_length(size_type(0), __n, "basic_string::append"); + return _M_append(__s, __n); + } +# 1474 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + append(size_type __n, _CharT __c) + { return _M_replace_aux(this->size(), size_type(0), __n, __c); } +# 1485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + append(initializer_list<_CharT> __l) + { return this->append(__l.begin(), __l.size()); } +# 1499 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template> + + + + + basic_string& + append(_InputIterator __first, _InputIterator __last) + { return this->replace(end(), end(), __first, __last); } + + + + + + + + template + + _If_sv<_Tp, basic_string&> + append(const _Tp& __svt) + { + __sv_type __sv = __svt; + return this->append(__sv.data(), __sv.size()); + } +# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + append(const _Tp& __svt, size_type __pos, size_type __n = npos) + { + __sv_type __sv = __svt; + return _M_append(__sv.data() + + std::__sv_check(__sv.size(), __pos, "basic_string::append"), + std::__sv_limit(__sv.size(), __pos, __n)); + } + + + + + + + + void + push_back(_CharT __c) + { + const size_type __size = this->size(); + if (__size + 1 > this->capacity()) + this->_M_mutate(__size, size_type(0), 0, size_type(1)); + traits_type::assign(this->_M_data()[__size], __c); + this->_M_set_length(__size + 1); + } + + + + + + + + basic_string& + assign(const basic_string& __str) + { + + if (_Alloc_traits::_S_propagate_on_copy_assign()) + { + if (!_Alloc_traits::_S_always_equal() && !_M_is_local() + && _M_get_allocator() != __str._M_get_allocator()) + { + + + if (__str.size() <= _S_local_capacity) + { + _M_destroy(_M_allocated_capacity); + _M_data(_M_use_local_data()); + _M_set_length(0); + } + else + { + const auto __len = __str.size(); + auto __alloc = __str._M_get_allocator(); + + auto __ptr = _S_allocate(__alloc, __len + 1); + _M_destroy(_M_allocated_capacity); + _M_data(__ptr); + _M_capacity(__len); + _M_set_length(__len); + } + } + std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator()); + } + + this->_M_assign(__str); + return *this; + } +# 1610 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + assign(basic_string&& __str) + noexcept(_Alloc_traits::_S_nothrow_move()) + { + + + return *this = std::move(__str); + } +# 1634 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + assign(const basic_string& __str, size_type __pos, size_type __n = npos) + { return _M_replace(size_type(0), this->size(), __str._M_data() + + __str._M_check(__pos, "basic_string::assign"), + __str._M_limit(__pos, __n)); } +# 1651 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + assign(const _CharT* __s, size_type __n) + { + ; + return _M_replace(size_type(0), this->size(), __s, __n); + } +# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + assign(const _CharT* __s) + { + ; + return _M_replace(size_type(0), this->size(), __s, + traits_type::length(__s)); + } +# 1686 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + assign(size_type __n, _CharT __c) + { return _M_replace_aux(size_type(0), this->size(), __n, __c); } +# 1699 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template> + + + + + basic_string& + assign(_InputIterator __first, _InputIterator __last) + { return this->replace(begin(), end(), __first, __last); } +# 1716 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + assign(initializer_list<_CharT> __l) + { return this->assign(__l.begin(), __l.size()); } +# 1727 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + assign(const _Tp& __svt) + { + __sv_type __sv = __svt; + return this->assign(__sv.data(), __sv.size()); + } +# 1743 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + assign(const _Tp& __svt, size_type __pos, size_type __n = npos) + { + __sv_type __sv = __svt; + return _M_replace(size_type(0), this->size(), + __sv.data() + + std::__sv_check(__sv.size(), __pos, "basic_string::assign"), + std::__sv_limit(__sv.size(), __pos, __n)); + } +# 1773 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + iterator + insert(const_iterator __p, size_type __n, _CharT __c) + { + ; + const size_type __pos = __p - begin(); + this->replace(__p, __p, __n, __c); + return iterator(this->_M_data() + __pos); + } +# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template> + + iterator + insert(const_iterator __p, _InputIterator __beg, _InputIterator __end) + { + ; + const size_type __pos = __p - begin(); + this->replace(__p, __p, __beg, __end); + return iterator(this->_M_data() + __pos); + } +# 1853 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + iterator + insert(const_iterator __p, initializer_list<_CharT> __l) + { return this->insert(__p, __l.begin(), __l.end()); } +# 1881 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos1, const basic_string& __str) + { return this->replace(__pos1, size_type(0), + __str._M_data(), __str.size()); } +# 1905 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos1, const basic_string& __str, + size_type __pos2, size_type __n = npos) + { return this->replace(__pos1, size_type(0), __str._M_data() + + __str._M_check(__pos2, "basic_string::insert"), + __str._M_limit(__pos2, __n)); } +# 1929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos, const _CharT* __s, size_type __n) + { return this->replace(__pos, size_type(0), __s, __n); } +# 1949 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos, const _CharT* __s) + { + ; + return this->replace(__pos, size_type(0), __s, + traits_type::length(__s)); + } +# 1974 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + insert(size_type __pos, size_type __n, _CharT __c) + { return _M_replace_aux(_M_check(__pos, "basic_string::insert"), + size_type(0), __n, __c); } +# 1993 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + iterator + insert(__const_iterator __p, _CharT __c) + { + ; + const size_type __pos = __p - begin(); + _M_replace_aux(__pos, size_type(0), size_type(1), __c); + return iterator(_M_data() + __pos); + } +# 2009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + insert(size_type __pos, const _Tp& __svt) + { + __sv_type __sv = __svt; + return this->insert(__pos, __sv.data(), __sv.size()); + } +# 2026 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + insert(size_type __pos1, const _Tp& __svt, + size_type __pos2, size_type __n = npos) + { + __sv_type __sv = __svt; + return this->replace(__pos1, size_type(0), + __sv.data() + + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"), + std::__sv_limit(__sv.size(), __pos2, __n)); + } +# 2056 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + erase(size_type __pos = 0, size_type __n = npos) + { + _M_check(__pos, "basic_string::erase"); + if (__n == npos) + this->_M_set_length(__pos); + else if (__n != 0) + this->_M_erase(__pos, _M_limit(__pos, __n)); + return *this; + } +# 2076 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + iterator + erase(__const_iterator __position) + { + + ; + const size_type __pos = __position - begin(); + this->_M_erase(__pos, size_type(1)); + return iterator(_M_data() + __pos); + } +# 2096 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + iterator + erase(__const_iterator __first, __const_iterator __last) + { + + ; + const size_type __pos = __first - begin(); + if (__last == end()) + this->_M_set_length(__pos); + else + this->_M_erase(__pos, __last - __first); + return iterator(this->_M_data() + __pos); + } +# 2116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + void + pop_back() noexcept + { + do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); + _M_erase(size() - 1, 1); + } +# 2142 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos, size_type __n, const basic_string& __str) + { return this->replace(__pos, __n, __str._M_data(), __str.size()); } +# 2165 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2 = npos) + { return this->replace(__pos1, __n1, __str._M_data() + + __str._M_check(__pos2, "basic_string::replace"), + __str._M_limit(__pos2, __n2)); } +# 2191 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) + { + ; + return _M_replace(_M_check(__pos, "basic_string::replace"), + _M_limit(__pos, __n1), __s, __n2); + } +# 2217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos, size_type __n1, const _CharT* __s) + { + ; + return this->replace(__pos, __n1, __s, traits_type::length(__s)); + } +# 2242 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) + { return _M_replace_aux(_M_check(__pos, "basic_string::replace"), + _M_limit(__pos, __n1), __n2, __c); } +# 2261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const basic_string& __str) + { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } +# 2282 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const _CharT* __s, size_type __n) + { + + ; + return this->replace(__i1 - begin(), __i2 - __i1, __s, __n); + } +# 2305 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s) + { + ; + return this->replace(__i1, __i2, __s, traits_type::length(__s)); + } +# 2327 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, size_type __n, + _CharT __c) + { + + ; + return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c); + } +# 2352 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template> + + basic_string& + replace(const_iterator __i1, const_iterator __i2, + _InputIterator __k1, _InputIterator __k2) + { + + ; + ; + return this->_M_replace_dispatch(__i1, __i2, __k1, __k2, + std::__false_type()); + } +# 2386 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + _CharT* __k1, _CharT* __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1, __k2 - __k1); + } + + + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const _CharT* __k1, const _CharT* __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1, __k2 - __k1); + } + + + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + iterator __k1, iterator __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1.base(), __k2 - __k1); + } + + + basic_string& + replace(__const_iterator __i1, __const_iterator __i2, + const_iterator __k1, const_iterator __k2) + { + + ; + ; + return this->replace(__i1 - begin(), __i2 - __i1, + __k1.base(), __k2 - __k1); + } +# 2449 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + basic_string& replace(const_iterator __i1, const_iterator __i2, + initializer_list<_CharT> __l) + { return this->replace(__i1, __i2, __l.begin(), __l.size()); } +# 2462 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + replace(size_type __pos, size_type __n, const _Tp& __svt) + { + __sv_type __sv = __svt; + return this->replace(__pos, __n, __sv.data(), __sv.size()); + } +# 2480 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + replace(size_type __pos1, size_type __n1, const _Tp& __svt, + size_type __pos2, size_type __n2 = npos) + { + __sv_type __sv = __svt; + return this->replace(__pos1, __n1, + __sv.data() + + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"), + std::__sv_limit(__sv.size(), __pos2, __n2)); + } +# 2502 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + _If_sv<_Tp, basic_string&> + replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt) + { + __sv_type __sv = __svt; + return this->replace(__i1 - begin(), __i2 - __i1, __sv); + } + + + private: + template + + basic_string& + _M_replace_dispatch(const_iterator __i1, const_iterator __i2, + _Integer __n, _Integer __val, __true_type) + { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); } + + template + + basic_string& + _M_replace_dispatch(const_iterator __i1, const_iterator __i2, + _InputIterator __k1, _InputIterator __k2, + __false_type); + + + basic_string& + _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, + _CharT __c); + + __attribute__((__noinline__, __noclone__, __cold__)) void + _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s, + const size_type __len2, const size_type __how_much); + + + basic_string& + _M_replace(size_type __pos, size_type __len1, const _CharT* __s, + const size_type __len2); + + + basic_string& + _M_append(const _CharT* __s, size_type __n); + + public: +# 2560 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + size_type + copy(_CharT* __s, size_type __n, size_type __pos = 0) const; +# 2571 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + void + swap(basic_string& __s) noexcept; +# 2581 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + const _CharT* + c_str() const noexcept + { return _M_data(); } +# 2594 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + const _CharT* + data() const noexcept + { return _M_data(); } +# 2606 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + _CharT* + data() noexcept + { return _M_data(); } + + + + + + [[__nodiscard__]] + allocator_type + get_allocator() const noexcept + { return _M_get_allocator(); } +# 2632 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find(const _CharT* __s, size_type __pos, size_type __n) const + noexcept; +# 2647 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find(const basic_string& __str, size_type __pos = 0) const + noexcept + { return this->find(__str.data(), __pos, __str.size()); } +# 2660 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find(const _Tp& __svt, size_type __pos = 0) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv = __svt; + return this->find(__sv.data(), __pos, __sv.size()); + } +# 2681 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find(const _CharT* __s, size_type __pos = 0) const noexcept + { + ; + return this->find(__s, __pos, traits_type::length(__s)); + } +# 2699 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find(_CharT __c, size_type __pos = 0) const noexcept; +# 2713 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + rfind(const basic_string& __str, size_type __pos = npos) const + noexcept + { return this->rfind(__str.data(), __pos, __str.size()); } +# 2726 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + rfind(const _Tp& __svt, size_type __pos = npos) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv = __svt; + return this->rfind(__sv.data(), __pos, __sv.size()); + } +# 2749 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + rfind(const _CharT* __s, size_type __pos, size_type __n) const + noexcept; +# 2764 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + rfind(const _CharT* __s, size_type __pos = npos) const + { + ; + return this->rfind(__s, __pos, traits_type::length(__s)); + } +# 2782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + rfind(_CharT __c, size_type __pos = npos) const noexcept; +# 2797 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_of(const basic_string& __str, size_type __pos = 0) const + noexcept + { return this->find_first_of(__str.data(), __pos, __str.size()); } +# 2811 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find_first_of(const _Tp& __svt, size_type __pos = 0) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv = __svt; + return this->find_first_of(__sv.data(), __pos, __sv.size()); + } +# 2834 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_of(const _CharT* __s, size_type __pos, size_type __n) const + noexcept; +# 2849 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_of(const _CharT* __s, size_type __pos = 0) const + noexcept + { + ; + return this->find_first_of(__s, __pos, traits_type::length(__s)); + } +# 2870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_of(_CharT __c, size_type __pos = 0) const noexcept + { return this->find(__c, __pos); } +# 2886 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_of(const basic_string& __str, size_type __pos = npos) const + noexcept + { return this->find_last_of(__str.data(), __pos, __str.size()); } +# 2900 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find_last_of(const _Tp& __svt, size_type __pos = npos) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv = __svt; + return this->find_last_of(__sv.data(), __pos, __sv.size()); + } +# 2923 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_of(const _CharT* __s, size_type __pos, size_type __n) const + noexcept; +# 2938 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_of(const _CharT* __s, size_type __pos = npos) const + noexcept + { + ; + return this->find_last_of(__s, __pos, traits_type::length(__s)); + } +# 2959 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_of(_CharT __c, size_type __pos = npos) const noexcept + { return this->rfind(__c, __pos); } +# 2974 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_not_of(const basic_string& __str, size_type __pos = 0) const + noexcept + { return this->find_first_not_of(__str.data(), __pos, __str.size()); } +# 2988 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find_first_not_of(const _Tp& __svt, size_type __pos = 0) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv = __svt; + return this->find_first_not_of(__sv.data(), __pos, __sv.size()); + } +# 3011 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_not_of(const _CharT* __s, size_type __pos, + size_type __n) const noexcept; +# 3026 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_not_of(const _CharT* __s, size_type __pos = 0) const + noexcept + { + ; + return this->find_first_not_of(__s, __pos, traits_type::length(__s)); + } +# 3045 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_first_not_of(_CharT __c, size_type __pos = 0) const + noexcept; +# 3061 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_not_of(const basic_string& __str, size_type __pos = npos) const + noexcept + { return this->find_last_not_of(__str.data(), __pos, __str.size()); } +# 3075 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, size_type> + find_last_not_of(const _Tp& __svt, size_type __pos = npos) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv = __svt; + return this->find_last_not_of(__sv.data(), __pos, __sv.size()); + } +# 3098 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_not_of(const _CharT* __s, size_type __pos, + size_type __n) const noexcept; +# 3113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_not_of(const _CharT* __s, size_type __pos = npos) const + noexcept + { + ; + return this->find_last_not_of(__s, __pos, traits_type::length(__s)); + } +# 3132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + size_type + find_last_not_of(_CharT __c, size_type __pos = npos) const + noexcept; +# 3149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + basic_string + substr(size_type __pos = 0, size_type __n = npos) const + { return basic_string(*this, + _M_check(__pos, "basic_string::substr"), __n); } +# 3169 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(const basic_string& __str) const + { + const size_type __size = this->size(); + const size_type __osize = __str.size(); + const size_type __len = std::min(__size, __osize); + + int __r = traits_type::compare(_M_data(), __str.data(), __len); + if (!__r) + __r = _S_compare(__size, __osize); + return __r; + } + + + + + + + + template + [[__nodiscard__]] + _If_sv<_Tp, int> + compare(const _Tp& __svt) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv = __svt; + const size_type __size = this->size(); + const size_type __osize = __sv.size(); + const size_type __len = std::min(__size, __osize); + + int __r = traits_type::compare(_M_data(), __sv.data(), __len); + if (!__r) + __r = _S_compare(__size, __osize); + return __r; + } +# 3214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, int> + compare(size_type __pos, size_type __n, const _Tp& __svt) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv = __svt; + return __sv_type(*this).substr(__pos, __n).compare(__sv); + } +# 3234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + _If_sv<_Tp, int> + compare(size_type __pos1, size_type __n1, const _Tp& __svt, + size_type __pos2, size_type __n2 = npos) const + noexcept(is_same<_Tp, __sv_type>::value) + { + __sv_type __sv = __svt; + return __sv_type(*this) + .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); + } +# 3266 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(size_type __pos, size_type __n, const basic_string& __str) const + { + _M_check(__pos, "basic_string::compare"); + __n = _M_limit(__pos, __n); + const size_type __osize = __str.size(); + const size_type __len = std::min(__n, __osize); + int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); + if (!__r) + __r = _S_compare(__n, __osize); + return __r; + } +# 3303 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(size_type __pos1, size_type __n1, const basic_string& __str, + size_type __pos2, size_type __n2 = npos) const + { + _M_check(__pos1, "basic_string::compare"); + __str._M_check(__pos2, "basic_string::compare"); + __n1 = _M_limit(__pos1, __n1); + __n2 = __str._M_limit(__pos2, __n2); + const size_type __len = std::min(__n1, __n2); + int __r = traits_type::compare(_M_data() + __pos1, + __str.data() + __pos2, __len); + if (!__r) + __r = _S_compare(__n1, __n2); + return __r; + } +# 3334 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(const _CharT* __s) const noexcept + { + ; + const size_type __size = this->size(); + const size_type __osize = traits_type::length(__s); + const size_type __len = std::min(__size, __osize); + int __r = traits_type::compare(_M_data(), __s, __len); + if (!__r) + __r = _S_compare(__size, __osize); + return __r; + } +# 3369 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(size_type __pos, size_type __n1, const _CharT* __s) const + { + ; + _M_check(__pos, "basic_string::compare"); + __n1 = _M_limit(__pos, __n1); + const size_type __osize = traits_type::length(__s); + const size_type __len = std::min(__n1, __osize); + int __r = traits_type::compare(_M_data() + __pos, __s, __len); + if (!__r) + __r = _S_compare(__n1, __osize); + return __r; + } +# 3408 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + [[__nodiscard__]] + int + compare(size_type __pos, size_type __n1, const _CharT* __s, + size_type __n2) const + { + ; + _M_check(__pos, "basic_string::compare"); + __n1 = _M_limit(__pos, __n1); + const size_type __len = std::min(__n1, __n2); + int __r = traits_type::compare(_M_data() + __pos, __s, __len); + if (!__r) + __r = _S_compare(__n1, __n2); + return __r; + } +# 3473 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template friend class basic_stringbuf; + }; +} + +} + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + +namespace __cxx11 { + template::value_type, + typename _Allocator = allocator<_CharT>, + typename = _RequireInputIter<_InputIterator>, + typename = _RequireAllocator<_Allocator>> + basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator()) + -> basic_string<_CharT, char_traits<_CharT>, _Allocator>; + + + + template, + typename = _RequireAllocator<_Allocator>> + basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator()) + -> basic_string<_CharT, _Traits, _Allocator>; + + template, + typename = _RequireAllocator<_Allocator>> + basic_string(basic_string_view<_CharT, _Traits>, + typename basic_string<_CharT, _Traits, _Allocator>::size_type, + typename basic_string<_CharT, _Traits, _Allocator>::size_type, + const _Allocator& = _Allocator()) + -> basic_string<_CharT, _Traits, _Allocator>; +} + + + template + + inline _Str + __str_concat(typename _Str::value_type const* __lhs, + typename _Str::size_type __lhs_len, + typename _Str::value_type const* __rhs, + typename _Str::size_type __rhs_len, + typename _Str::allocator_type const& __a) + { + typedef typename _Str::allocator_type allocator_type; + typedef __gnu_cxx::__alloc_traits _Alloc_traits; + _Str __str(_Alloc_traits::_S_select_on_copy(__a)); + __str.reserve(__lhs_len + __rhs_len); + __str.append(__lhs, __lhs_len); + __str.append(__rhs, __rhs_len); + return __str; + } +# 3538 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { + typedef basic_string<_CharT, _Traits, _Alloc> _Str; + return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(), + __rhs.c_str(), __rhs.size(), + __lhs.get_allocator()); + } + + + + + + + + template + [[__nodiscard__]] + inline basic_string<_CharT,_Traits,_Alloc> + operator+(const _CharT* __lhs, + const basic_string<_CharT,_Traits,_Alloc>& __rhs) + { + ; + typedef basic_string<_CharT, _Traits, _Alloc> _Str; + return std::__str_concat<_Str>(__lhs, _Traits::length(__lhs), + __rhs.c_str(), __rhs.size(), + __rhs.get_allocator()); + } + + + + + + + + template + [[__nodiscard__]] + inline basic_string<_CharT,_Traits,_Alloc> + operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs) + { + typedef basic_string<_CharT, _Traits, _Alloc> _Str; + return std::__str_concat<_Str>(__builtin_addressof(__lhs), 1, + __rhs.c_str(), __rhs.size(), + __rhs.get_allocator()); + } + + + + + + + + template + [[__nodiscard__]] + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { + ; + typedef basic_string<_CharT, _Traits, _Alloc> _Str; + return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(), + __rhs, _Traits::length(__rhs), + __lhs.get_allocator()); + } + + + + + + + template + [[__nodiscard__]] + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) + { + typedef basic_string<_CharT, _Traits, _Alloc> _Str; + return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(), + __builtin_addressof(__rhs), 1, + __lhs.get_allocator()); + } + + + template + [[__nodiscard__]] + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return std::move(__lhs.append(__rhs)); } + + template + + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { return std::move(__rhs.insert(0, __lhs)); } + + template + [[__nodiscard__]] + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { + + using _Alloc_traits = allocator_traits<_Alloc>; + bool __use_rhs = false; + if constexpr (typename _Alloc_traits::is_always_equal{}) + __use_rhs = true; + else if (__lhs.get_allocator() == __rhs.get_allocator()) + __use_rhs = true; + if (__use_rhs) + + { + const auto __size = __lhs.size() + __rhs.size(); + if (__size > __lhs.capacity() && __size <= __rhs.capacity()) + return std::move(__rhs.insert(0, __lhs)); + } + return std::move(__lhs.append(__rhs)); + } + + template + [[__nodiscard__]] [[__nodiscard__]] + inline basic_string<_CharT, _Traits, _Alloc> + operator+(const _CharT* __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { return std::move(__rhs.insert(0, __lhs)); } + + template + [[__nodiscard__]] + inline basic_string<_CharT, _Traits, _Alloc> + operator+(_CharT __lhs, + basic_string<_CharT, _Traits, _Alloc>&& __rhs) + { return std::move(__rhs.insert(0, 1, __lhs)); } + + template + [[__nodiscard__]] + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + const _CharT* __rhs) + { return std::move(__lhs.append(__rhs)); } + + template + [[__nodiscard__]] + inline basic_string<_CharT, _Traits, _Alloc> + operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, + _CharT __rhs) + { return std::move(__lhs.append(1, __rhs)); } +# 3695 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { + return __lhs.size() == __rhs.size() + && !_Traits::compare(__lhs.data(), __rhs.data(), __lhs.size()); + } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { + return __lhs.size() == _Traits::length(__rhs) + && !_Traits::compare(__lhs.data(), __rhs, __lhs.size()); + } +# 3759 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs == __lhs; } +# 3773 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return !(__lhs == __rhs); } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator!=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return !(__rhs == __lhs); } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return !(__lhs == __rhs); } +# 3814 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) < 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) < 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator<(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) > 0; } +# 3855 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) > 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) > 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator>(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) < 0; } +# 3896 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) <= 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) <= 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator<=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) >= 0; } +# 3937 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + [[__nodiscard__]] + inline bool + operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept + { return __lhs.compare(__rhs) >= 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, + const _CharT* __rhs) + { return __lhs.compare(__rhs) >= 0; } + + + + + + + + template + [[__nodiscard__]] + inline bool + operator>=(const _CharT* __lhs, + const basic_string<_CharT, _Traits, _Alloc>& __rhs) + { return __rhs.compare(__lhs) <= 0; } +# 3979 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + + inline void + swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, + basic_string<_CharT, _Traits, _Alloc>& __rhs) + noexcept(noexcept(__lhs.swap(__rhs))) + { __lhs.swap(__rhs); } +# 4000 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str); + + template<> + basic_istream& + operator>>(basic_istream& __is, basic_string& __str); +# 4018 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, + const basic_string<_CharT, _Traits, _Alloc>& __str) + { + + + return __ostream_insert(__os, __str.data(), __str.size()); + } +# 4041 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); +# 4058 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + inline basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __is, + basic_string<_CharT, _Traits, _Alloc>& __str) + { return std::getline(__is, __str, __is.widen('\n')); } + + + + template + inline basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>&& __is, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) + { return std::getline(__is, __str, __delim); } + + + template + inline basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>&& __is, + basic_string<_CharT, _Traits, _Alloc>& __str) + { return std::getline(__is, __str); } + + + template<> + basic_istream& + getline(basic_istream& __in, basic_string& __str, + char __delim); + + + template<> + basic_istream& + getline(basic_istream& __in, basic_string& __str, + wchar_t __delim); + + + +} + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 +# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 59 "/usr/include/stdlib.h" 3 4 +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 159 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") + + + __attribute__ ((__nonnull__ (1))); +extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); +# 278 "/usr/include/stdlib.h" 3 4 +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 298 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 316 "/usr/include/stdlib.h" 3 4 +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 340 "/usr/include/stdlib.h" 3 4 +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + + + + + +extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") + + + + __attribute__ ((__nonnull__ (1, 4))); +extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +# 415 "/usr/include/stdlib.h" 3 4 +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 436 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 457 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 480 "/usr/include/stdlib.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) int + atoi (const char *__nptr) noexcept (true) +{ + return (int) strtol (__nptr, (char **) __null, 10); +} +extern __inline __attribute__ ((__gnu_inline__)) long int + atol (const char *__nptr) noexcept (true) +{ + return strtol (__nptr, (char **) __null, 10); +} + + +__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int + atoll (const char *__nptr) noexcept (true) +{ + return strtoll (__nptr, (char **) __null, 10); +} +# 505 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 27 "/usr/include/sys/types.h" 3 4 +extern "C" { + + + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; +# 103 "/usr/include/sys/types.h" 3 4 +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; +# 134 "/usr/include/sys/types.h" 3 4 +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 145 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/sys/types.h" 2 3 4 + + +typedef __uint8_t u_int8_t; +typedef __uint16_t u_int16_t; +typedef __uint32_t u_int32_t; +typedef __uint64_t u_int64_t; + + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 176 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + + + return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8))); + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + + + return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); + +} +# 69 "/usr/include/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + + + return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56)); + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 + + + + + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 +# 49 "/usr/include/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/sys/select.h" 3 4 +} +# 180 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; +# 230 "/usr/include/sys/types.h" 3 4 +} +# 515 "/usr/include/stdlib.h" 2 3 4 + + + + + + +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern __uint32_t arc4random (void) + noexcept (true) ; + + +extern void arc4random_buf (void *__buf, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) + noexcept (true) ; + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) ; + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + + ; + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) ; + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 707 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) + ; + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)); + + + +extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 749 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) noexcept (true); +# 814 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 827 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 837 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 849 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 859 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 870 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 881 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 891 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 901 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 913 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 923 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) + ; +# 940 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + +# 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4 +# 19 "/usr/include/bits/stdlib-bsearch.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) void * +bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) +{ + size_t __l, __u, __idx; + const void *__p; + int __comparison; + + __l = 0; + __u = __nmemb; + while (__l < __u) + { + __idx = (__l + __u) / 2; + __p = (const void *) (((const char *) __base) + (__idx * __size)); + __comparison = (*__compar) (__key, __p); + if (__comparison < 0) + __u = __idx; + else if (__comparison > 0) + __l = __idx + 1; + else + { + + + + + return (void *) __p; + + + + } + } + + return __null; +} +# 966 "/usr/include/stdlib.h" 2 3 4 + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; +extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) ; +# 1012 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) noexcept (true); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) noexcept (true); + + +extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) noexcept (true) + ; + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + noexcept (true) + + ; + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 1099 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) noexcept (true); + + + +extern int unlockpt (int __fd) noexcept (true); + + + + +extern char *ptsname (int __fd) noexcept (true) ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) ; + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1155 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 +# 24 "/usr/include/bits/stdlib-float.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) double + atof (const char *__nptr) noexcept (true) +{ + return strtod (__nptr, (char **) __null); +} +# 1156 "/usr/include/stdlib.h" 2 3 4 +# 1167 "/usr/include/stdlib.h" 3 4 +} +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::abs; + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 + inline constexpr double + abs(double __x) + { return __builtin_fabs(__x); } + + inline constexpr float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + abs(long double __x) + { return __builtin_fabsl(__x); } +# 151 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 +} +} +# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + + using ::aligned_alloc; + + using ::atexit; + + + using ::at_quick_exit; + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + using ::quick_exit; + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline ldiv_t + div(long __i, long __j) noexcept { return ldiv(__i, __j); } + + + + +} +# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +# 231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 + using ::atoll; + using ::strtoll; + using ::strtoull; + + using ::strtof; + using ::strtold; + + +} + +namespace std +{ + + using ::__gnu_cxx::lldiv_t; + + using ::__gnu_cxx::_Exit; + + using ::__gnu_cxx::llabs; + using ::__gnu_cxx::div; + using ::__gnu_cxx::lldiv; + + using ::__gnu_cxx::atoll; + using ::__gnu_cxx::strtof; + using ::__gnu_cxx::strtoll; + using ::__gnu_cxx::strtoull; + using ::__gnu_cxx::strtold; +} + + + +} +# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 + + +# 1 "/usr/include/stdio.h" 1 3 4 +# 27 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/stdio.h" 2 3 4 + +extern "C" { + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 34 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 +# 37 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4 +# 10 "/usr/include/bits/types/__fpos_t.h" 3 4 +typedef struct _G_fpos_t +{ + __off_t __pos; + __mbstate_t __state; +} __fpos_t; +# 40 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4 +# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4 +typedef struct _G_fpos64_t +{ + __off64_t __pos; + __mbstate_t __state; +} __fpos64_t; +# 41 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4 +# 35 "/usr/include/bits/types/struct_FILE.h" 3 4 +struct _IO_FILE; +struct _IO_marker; +struct _IO_codecvt; +struct _IO_wide_data; + + + + +typedef void _IO_lock_t; + + + + + +struct _IO_FILE +{ + int _flags; + + + char *_IO_read_ptr; + char *_IO_read_end; + char *_IO_read_base; + char *_IO_write_base; + char *_IO_write_ptr; + char *_IO_write_end; + char *_IO_buf_base; + char *_IO_buf_end; + + + char *_IO_save_base; + char *_IO_backup_base; + char *_IO_save_end; + + struct _IO_marker *_markers; + + struct _IO_FILE *_chain; + + int _fileno; + int _flags2; + __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/bits/types/cookie_io_functions_t.h" 1 3 4 +# 27 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4 +typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, + size_t __nbytes); + + + + + + + +typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, + size_t __nbytes); + + + + + + + +typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); + + +typedef int cookie_close_function_t (void *__cookie); + + + + + + +typedef struct _IO_cookie_io_functions_t +{ + cookie_read_function_t *read; + cookie_write_function_t *write; + cookie_seek_function_t *seek; + cookie_close_function_t *close; +} cookie_io_functions_t; +# 47 "/usr/include/stdio.h" 2 3 4 +# 84 "/usr/include/stdio.h" 3 4 +typedef __fpos_t fpos_t; + + + + +typedef __fpos64_t fpos64_t; +# 128 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 +# 129 "/usr/include/stdio.h" 2 3 4 +# 148 "/usr/include/stdio.h" 3 4 +extern FILE *stdin; +extern FILE *stdout; +extern FILE *stderr; + + + + + + +extern int remove (const char *__filename) noexcept (true); + +extern int rename (const char *__old, const char *__new) noexcept (true); + + + +extern int renameat (int __oldfd, const char *__old, int __newfd, + const char *__new) noexcept (true); +# 175 "/usr/include/stdio.h" 3 4 +extern int renameat2 (int __oldfd, const char *__old, int __newfd, + const char *__new, unsigned int __flags) noexcept (true); + + + + + + +extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 193 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile (void) + __attribute__ ((__malloc__)) ; +# 205 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile64 (void) + __attribute__ ((__malloc__)) ; + + + +extern char *tmpnam (char[20]) noexcept (true) ; + + + + +extern char *tmpnam_r (char __s[20]) noexcept (true) ; +# 227 "/usr/include/stdio.h" 3 4 +extern char *tempnam (const char *__dir, const char *__pfx) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + + + +extern int fflush (FILE *__stream); +# 244 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 254 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); +# 263 "/usr/include/stdio.h" 3 4 +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) ; + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); +# 288 "/usr/include/stdio.h" 3 4 +extern FILE *fopen64 (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) ; +extern FILE *freopen64 (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); + + + + +extern FILE *fdopen (int __fd, const char *__modes) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern FILE *fopencookie (void *__restrict __magic_cookie, + const char *__restrict __modes, + cookie_io_functions_t __io_funcs) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + +extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + +extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) noexcept (true); + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) noexcept (true); + + +extern void setlinebuf (FILE *__stream) noexcept (true); + + + + + + + +extern int fprintf (FILE *__restrict __stream, + const char *__restrict __format, ...); + + + + +extern int printf (const char *__restrict __format, ...); + +extern int sprintf (char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); + + + + + +extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg); + + + + +extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); + +extern int vsprintf (char *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) noexcept (true); + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); + + + + + +extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, + __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ; +extern int __asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; +extern int asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; + + + + +extern int vdprintf (int __fd, const char *__restrict __fmt, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__printf__, 2, 0))); +extern int dprintf (int __fd, const char *__restrict __fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); + + + + + + + +extern int fscanf (FILE *__restrict __stream, + const char *__restrict __format, ...) ; + + + + +extern int scanf (const char *__restrict __format, ...) ; + +extern int sscanf (const char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); +# 440 "/usr/include/stdio.h" 3 4 +extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") ; + + +extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") ; + +extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf"); +# 486 "/usr/include/stdio.h" 3 4 +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 2, 0))) ; + + + + + +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 1, 0))) ; + + +extern int vsscanf (const char *__restrict __s, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0))); + + + + + + +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))) ; +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf") + + __attribute__ ((__format__ (__scanf__, 1, 0))) ; +extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))); +# 571 "/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); +# 596 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream); +# 607 "/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); +# 623 "/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) + ; +# 673 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) + ; +# 690 "/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); +# 749 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream); +# 760 "/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); +# 794 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence); + + + + +extern __off_t ftello (FILE *__stream) ; +# 818 "/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); +# 837 "/usr/include/stdio.h" 3 4 +extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); +extern __off64_t ftello64 (FILE *__stream) ; +extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); +extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); + + + +extern void clearerr (FILE *__stream) noexcept (true); + +extern int feof (FILE *__stream) noexcept (true) ; + +extern int ferror (FILE *__stream) noexcept (true) ; + + + +extern void clearerr_unlocked (FILE *__stream) noexcept (true); +extern int feof_unlocked (FILE *__stream) noexcept (true) ; +extern int ferror_unlocked (FILE *__stream) noexcept (true) ; + + + + + + + +extern void perror (const char *__s) __attribute__ ((__cold__)); + + + + +extern int fileno (FILE *__stream) noexcept (true) ; + + + + +extern int fileno_unlocked (FILE *__stream) noexcept (true) ; +# 881 "/usr/include/stdio.h" 3 4 +extern int pclose (FILE *__stream); + + + + + +extern FILE *popen (const char *__command, const char *__modes) + __attribute__ ((__malloc__)) ; + + + + + + +extern char *ctermid (char *__s) noexcept (true) + ; + + + + + +extern char *cuserid (char *__s) + ; + + + + +struct obstack; + + +extern int obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); +extern int obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __format, + __gnuc_va_list __args) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); + + + + + + + +extern void flockfile (FILE *__stream) noexcept (true); + + + +extern int ftrylockfile (FILE *__stream) noexcept (true) ; + + +extern void funlockfile (FILE *__stream) noexcept (true); +# 943 "/usr/include/stdio.h" 3 4 +extern int __uflow (FILE *); +extern int __overflow (FILE *, int); +# 960 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio.h" 1 3 4 +# 38 "/usr/include/bits/stdio.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) int +vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) +{ + return vfprintf (stdout, __fmt, __arg); +} + + + +extern __inline __attribute__ ((__gnu_inline__)) int +getchar (void) +{ + return getc (stdin); +} + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +fgetc_unlocked (FILE *__fp) +{ + return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +getc_unlocked (FILE *__fp) +{ + return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int +getchar_unlocked (void) +{ + return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++); +} + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +putchar (int __c) +{ + return putc (__c, stdout); +} + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +fputc_unlocked (int __c, FILE *__stream) +{ + return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +putc_unlocked (int __c, FILE *__stream) +{ + return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int +putchar_unlocked (int __c) +{ + return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c))); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) __ssize_t +getline (char **__lineptr, size_t *__n, FILE *__stream) +{ + return __getdelim (__lineptr, __n, '\n', __stream); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int + feof_unlocked (FILE *__stream) noexcept (true) +{ + return (((__stream)->_flags & 0x0010) != 0); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int + ferror_unlocked (FILE *__stream) noexcept (true) +{ + return (((__stream)->_flags & 0x0020) != 0); +} +# 961 "/usr/include/stdio.h" 2 3 4 + + + + + + +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 2 3 +# 96 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 +namespace std +{ + using ::FILE; + using ::fpos_t; + + using ::clearerr; + using ::fclose; + using ::feof; + using ::ferror; + using ::fflush; + using ::fgetc; + using ::fgetpos; + using ::fgets; + using ::fopen; + using ::fprintf; + using ::fputc; + using ::fputs; + using ::fread; + using ::freopen; + using ::fscanf; + using ::fseek; + using ::fsetpos; + using ::ftell; + using ::fwrite; + using ::getc; + using ::getchar; + + + + + using ::perror; + using ::printf; + using ::putc; + using ::putchar; + using ::puts; + using ::remove; + using ::rename; + using ::rewind; + using ::scanf; + using ::setbuf; + using ::setvbuf; + using ::sprintf; + using ::sscanf; + using ::tmpfile; + + using ::tmpnam; + + using ::ungetc; + using ::vfprintf; + using ::vprintf; + using ::vsprintf; +} +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 +namespace __gnu_cxx +{ +# 175 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 + using ::snprintf; + using ::vfscanf; + using ::vscanf; + using ::vsnprintf; + using ::vsscanf; + +} + +namespace std +{ + using ::__gnu_cxx::snprintf; + using ::__gnu_cxx::vfscanf; + using ::__gnu_cxx::vscanf; + using ::__gnu_cxx::vsnprintf; + using ::__gnu_cxx::vsscanf; +} +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 3 + + +# 1 "/usr/include/errno.h" 1 3 4 +# 28 "/usr/include/errno.h" 3 4 +# 1 "/usr/include/bits/errno.h" 1 3 4 +# 26 "/usr/include/bits/errno.h" 3 4 +# 1 "/usr/include/linux/errno.h" 1 3 4 +# 1 "/usr/include/asm/errno.h" 1 3 4 +# 1 "/usr/include/asm-generic/errno.h" 1 3 4 + + + + +# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4 +# 6 "/usr/include/asm-generic/errno.h" 2 3 4 +# 2 "/usr/include/asm/errno.h" 2 3 4 +# 2 "/usr/include/linux/errno.h" 2 3 4 +# 27 "/usr/include/bits/errno.h" 2 3 4 +# 29 "/usr/include/errno.h" 2 3 4 + + + + + +extern "C" { + + +extern int *__errno_location (void) noexcept (true) __attribute__ ((__const__)); + + + + + + + +extern char *program_invocation_name; +extern char *program_invocation_short_name; + +# 1 "/usr/include/bits/types/error_t.h" 1 3 4 +# 22 "/usr/include/bits/types/error_t.h" 3 4 +typedef int error_t; +# 49 "/usr/include/errno.h" 2 3 4 + + + +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 2 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + _Ret + __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...), + const char* __name, const _CharT* __str, std::size_t* __idx, + _Base... __base) + { + _Ret __ret; + + _CharT* __endptr; + + struct _Save_errno { + _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; } + ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; } + int _M_errno; + } const __save_errno; + + struct _Range_chk { + static bool + _S_chk(_TRet, std::false_type) { return false; } + + static bool + _S_chk(_TRet __val, std::true_type) + { + return __val < _TRet(__numeric_traits::__min) + || __val > _TRet(__numeric_traits::__max); + } + }; + + const _TRet __tmp = __convf(__str, &__endptr, __base...); + + if (__endptr == __str) + std::__throw_invalid_argument(__name); + else if ((*__errno_location ()) == 34 + || _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{})) + std::__throw_out_of_range(__name); + else + __ret = __tmp; + + if (__idx) + *__idx = __endptr - __str; + + return __ret; + } + + + template + _String + __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*, + __builtin_va_list), std::size_t __n, + const _CharT* __fmt, ...) + { + + + _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __n)); + + __builtin_va_list __args; + __builtin_va_start(__args, __fmt); + + const int __len = __convf(__s, __n, __fmt, __args); + + __builtin_va_end(__args); + + return _String(__s, __s + __len); + } + + +} +# 4098 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/charconv.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/charconv.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace __detail +{ + + + template + constexpr bool __integer_to_chars_is_unsigned + = ! __gnu_cxx::__int_traits<_Tp>::__is_signed; + + + + template + constexpr unsigned + __to_chars_len(_Tp __value, int __base = 10) noexcept + { + + static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug"); + + + unsigned __n = 1; + const unsigned __b2 = __base * __base; + const unsigned __b3 = __b2 * __base; + const unsigned long __b4 = __b3 * __base; + for (;;) + { + if (__value < (unsigned)__base) return __n; + if (__value < __b2) return __n + 1; + if (__value < __b3) return __n + 2; + if (__value < __b4) return __n + 3; + __value /= __b4; + __n += 4; + } + } + + + + + template + void + __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept + { + + static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug"); + + + constexpr char __digits[201] = + "0001020304050607080910111213141516171819" + "2021222324252627282930313233343536373839" + "4041424344454647484950515253545556575859" + "6061626364656667686970717273747576777879" + "8081828384858687888990919293949596979899"; + unsigned __pos = __len - 1; + while (__val >= 100) + { + auto const __num = (__val % 100) * 2; + __val /= 100; + __first[__pos] = __digits[__num + 1]; + __first[__pos - 1] = __digits[__num]; + __pos -= 2; + } + if (__val >= 10) + { + auto const __num = __val * 2; + __first[1] = __digits[__num + 1]; + __first[0] = __digits[__num]; + } + else + __first[0] = '0' + __val; + } + +} + +} +# 4099 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace __cxx11 { + + + + inline int + stoi(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtol, "stoi", __str.c_str(), + __idx, __base); } + + inline long + stol(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(), + __idx, __base); } + + inline unsigned long + stoul(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(), + __idx, __base); } + + inline long long + stoll(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(), + __idx, __base); } + + inline unsigned long long + stoull(const string& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(), + __idx, __base); } + + + inline float + stof(const string& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); } + + inline double + stod(const string& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); } + + inline long double + stold(const string& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); } + + + + + [[__nodiscard__]] + inline string + to_string(int __val) + + noexcept + + { + const bool __neg = __val < 0; + const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val; + const auto __len = __detail::__to_chars_len(__uval); + string __str(__neg + __len, '-'); + __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(unsigned __val) + + noexcept + + { + string __str(__detail::__to_chars_len(__val), '\0'); + __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(long __val) + + + + { + const bool __neg = __val < 0; + const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val; + const auto __len = __detail::__to_chars_len(__uval); + string __str(__neg + __len, '-'); + __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(unsigned long __val) + + + + { + string __str(__detail::__to_chars_len(__val), '\0'); + __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(long long __val) + { + const bool __neg = __val < 0; + const unsigned long long __uval + = __neg ? (unsigned long long)~__val + 1ull : __val; + const auto __len = __detail::__to_chars_len(__uval); + string __str(__neg + __len, '-'); + __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); + return __str; + } + + [[__nodiscard__]] + inline string + to_string(unsigned long long __val) + { + string __str(__detail::__to_chars_len(__val), '\0'); + __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); + return __str; + } + + + + + [[__nodiscard__]] + inline string + to_string(float __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%f", __val); + } + + [[__nodiscard__]] + inline string + to_string(double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%f", __val); + } + + [[__nodiscard__]] + inline string + to_string(long double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, + "%Lf", __val); + } + + + + inline int + stoi(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstol, "stoi", __str.c_str(), + __idx, __base); } + + inline long + stol(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(), + __idx, __base); } + + inline unsigned long + stoul(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(), + __idx, __base); } + + inline long long + stoll(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(), + __idx, __base); } + + inline unsigned long long + stoull(const wstring& __str, size_t* __idx = 0, int __base = 10) + { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(), + __idx, __base); } + + + inline float + stof(const wstring& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); } + + inline double + stod(const wstring& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); } + + inline long double + stold(const wstring& __str, size_t* __idx = 0) + { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); } + + + + [[__nodiscard__]] + inline wstring + to_wstring(int __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(int), + L"%d", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(unsigned __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned), + L"%u", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(long), + L"%ld", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(unsigned long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned long), + L"%lu", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(long long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(long long), + L"%lld", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(unsigned long long __val) + { return __gnu_cxx::__to_xstring(&std::vswprintf, + 4 * sizeof(unsigned long long), + L"%llu", __val); } + + [[__nodiscard__]] + inline wstring + to_wstring(float __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%f", __val); + } + + [[__nodiscard__]] + inline wstring + to_wstring(double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%f", __val); + } + + [[__nodiscard__]] + inline wstring + to_wstring(long double __val) + { + const int __n = + __gnu_cxx::__numeric_traits::__max_exponent10 + 20; + return __gnu_cxx::__to_xstring(&std::vswprintf, __n, + L"%Lf", __val); + } + + + +} + +} + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + template, _Alloc>> + struct __str_hash_base + : public __hash_base + { + [[__nodiscard__]] + size_t + operator()(const _StrT& __s) const noexcept + { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(_CharT)); } + }; + + + + template + struct hash, _Alloc>> + : public __str_hash_base + { }; + + + template + struct hash, _Alloc>> + : public __str_hash_base + { }; + + template + struct __is_fast_hash, + _Alloc>>> + : std::false_type + { }; +# 4428 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + template + struct hash, _Alloc>> + : public __str_hash_base + { }; + + + template + struct hash, _Alloc>> + : public __str_hash_base + { }; + + + + template<> struct __is_fast_hash> : std::false_type { }; + template<> struct __is_fast_hash> : std::false_type { }; + template<> struct __is_fast_hash> : std::false_type { }; + template<> struct __is_fast_hash> : std::false_type { }; +# 4460 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + inline namespace literals + { + inline namespace string_literals + { +#pragma GCC diagnostic push + + + + + + + + + __attribute ((__abi_tag__ ("cxx11"))) + inline basic_string + operator""s(const char* __str, size_t __len) + { return basic_string{__str, __len}; } + + __attribute ((__abi_tag__ ("cxx11"))) + inline basic_string + operator""s(const wchar_t* __str, size_t __len) + { return basic_string{__str, __len}; } +# 4490 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 + __attribute ((__abi_tag__ ("cxx11"))) + inline basic_string + operator""s(const char16_t* __str, size_t __len) + { return basic_string{__str, __len}; } + + __attribute ((__abi_tag__ ("cxx11"))) + inline basic_string + operator""s(const char32_t* __str, size_t __len) + { return basic_string{__str, __len}; } + + +#pragma GCC diagnostic pop + } + } + + + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : __and_< + is_nothrow_move_constructible>, + is_nothrow_move_assignable> + >::type + { }; + } + + + + +} +# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 1 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + const typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>::npos; + + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + swap(basic_string& __s) noexcept + { + if (this == std::__addressof(__s)) + return; + + _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator()); + + if (_M_is_local()) + if (__s._M_is_local()) + { + if (length() && __s.length()) + { + _CharT __tmp_data[_S_local_capacity + 1]; + traits_type::copy(__tmp_data, __s._M_local_buf, + __s.length() + 1); + traits_type::copy(__s._M_local_buf, _M_local_buf, + length() + 1); + traits_type::copy(_M_local_buf, __tmp_data, + __s.length() + 1); + } + else if (__s.length()) + { + traits_type::copy(_M_local_buf, __s._M_local_buf, + __s.length() + 1); + _M_length(__s.length()); + __s._M_set_length(0); + return; + } + else if (length()) + { + traits_type::copy(__s._M_local_buf, _M_local_buf, + length() + 1); + __s._M_length(length()); + _M_set_length(0); + return; + } + } + else + { + const size_type __tmp_capacity = __s._M_allocated_capacity; + traits_type::copy(__s._M_local_buf, _M_local_buf, + length() + 1); + _M_data(__s._M_data()); + __s._M_data(__s._M_local_buf); + _M_capacity(__tmp_capacity); + } + else + { + const size_type __tmp_capacity = _M_allocated_capacity; + if (__s._M_is_local()) + { + traits_type::copy(_M_local_buf, __s._M_local_buf, + __s.length() + 1); + __s._M_data(_M_data()); + _M_data(_M_local_buf); + } + else + { + pointer __tmp_ptr = _M_data(); + _M_data(__s._M_data()); + __s._M_data(__tmp_ptr); + _M_capacity(__s._M_allocated_capacity); + } + __s._M_capacity(__tmp_capacity); + } + + const size_type __tmp_length = length(); + _M_length(__s.length()); + __s._M_length(__tmp_length); + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::pointer + basic_string<_CharT, _Traits, _Alloc>:: + _M_create(size_type& __capacity, size_type __old_capacity) + { + + + if (__capacity > max_size()) + std::__throw_length_error(("basic_string::_M_create")); + + + + + if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) + { + __capacity = 2 * __old_capacity; + + if (__capacity > max_size()) + __capacity = max_size(); + } + + + + return _S_allocate(_M_get_allocator(), __capacity + 1); + } + + + + + + template + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_construct(_InIterator __beg, _InIterator __end, + std::input_iterator_tag) + { + size_type __len = 0; + size_type __capacity = size_type(_S_local_capacity); + + pointer __p = _M_use_local_data(); + + while (__beg != __end && __len < __capacity) + { + __p[__len++] = *__beg; + ++__beg; + } + + struct _Guard + { + + explicit _Guard(basic_string* __s) : _M_guarded(__s) { } + + + ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); } + + basic_string* _M_guarded; + } __guard(this); + + while (__beg != __end) + { + if (__len == __capacity) + { + + __capacity = __len + 1; + pointer __another = _M_create(__capacity, __len); + this->_S_copy(__another, _M_data(), __len); + _M_dispose(); + _M_data(__another); + _M_capacity(__capacity); + } + traits_type::assign(_M_data()[__len++], *__beg); + ++__beg; + } + + __guard._M_guarded = 0; + + _M_set_length(__len); + } + + template + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_construct(_InIterator __beg, _InIterator __end, + std::forward_iterator_tag) + { + size_type __dnew = static_cast(std::distance(__beg, __end)); + + if (__dnew > size_type(_S_local_capacity)) + { + _M_data(_M_create(__dnew, size_type(0))); + _M_capacity(__dnew); + } + else + _M_use_local_data(); + + + struct _Guard + { + + explicit _Guard(basic_string* __s) : _M_guarded(__s) { } + + + ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); } + + basic_string* _M_guarded; + } __guard(this); + + this->_S_copy_chars(_M_data(), __beg, __end); + + __guard._M_guarded = 0; + + _M_set_length(__dnew); + } + + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_construct(size_type __n, _CharT __c) + { + if (__n > size_type(_S_local_capacity)) + { + _M_data(_M_create(__n, size_type(0))); + _M_capacity(__n); + } + else + _M_use_local_data(); + + if (__n) + this->_S_assign(_M_data(), __n, __c); + + _M_set_length(__n); + } + + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_assign(const basic_string& __str) + { + if (this != std::__addressof(__str)) + { + const size_type __rsize = __str.length(); + const size_type __capacity = capacity(); + + if (__rsize > __capacity) + { + size_type __new_capacity = __rsize; + pointer __tmp = _M_create(__new_capacity, __capacity); + _M_dispose(); + _M_data(__tmp); + _M_capacity(__new_capacity); + } + + if (__rsize) + this->_S_copy(_M_data(), __str._M_data(), __rsize); + + _M_set_length(__rsize); + } + } + + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + reserve(size_type __res) + { + const size_type __capacity = capacity(); + + + + + if (__res <= __capacity) + return; + + pointer __tmp = _M_create(__res, __capacity); + this->_S_copy(__tmp, _M_data(), length() + 1); + _M_dispose(); + _M_data(__tmp); + _M_capacity(__res); + } + + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, + size_type __len2) + { + const size_type __how_much = length() - __pos - __len1; + + size_type __new_capacity = length() + __len2 - __len1; + pointer __r = _M_create(__new_capacity, capacity()); + + if (__pos) + this->_S_copy(__r, _M_data(), __pos); + if (__s && __len2) + this->_S_copy(__r + __pos, __s, __len2); + if (__how_much) + this->_S_copy(__r + __pos + __len2, + _M_data() + __pos + __len1, __how_much); + + _M_dispose(); + _M_data(__r); + _M_capacity(__new_capacity); + } + + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + _M_erase(size_type __pos, size_type __n) + { + const size_type __how_much = length() - __pos - __n; + + if (__how_much && __n) + this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much); + + _M_set_length(length() - __n); + } + + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + reserve() + { + if (_M_is_local()) + return; + + const size_type __length = length(); + const size_type __capacity = _M_allocated_capacity; + + if (__length <= size_type(_S_local_capacity)) + { + this->_S_copy(_M_use_local_data(), _M_data(), __length + 1); + _M_destroy(__capacity); + _M_data(_M_local_data()); + } + + else if (__length < __capacity) + try + { + pointer __tmp = _S_allocate(_M_get_allocator(), __length + 1); + this->_S_copy(__tmp, _M_data(), __length + 1); + _M_dispose(); + _M_data(__tmp); + _M_capacity(__length); + } + catch (const __cxxabiv1::__forced_unwind&) + { throw; } + catch (...) + { } + + } + + template + + void + basic_string<_CharT, _Traits, _Alloc>:: + resize(size_type __n, _CharT __c) + { + const size_type __size = this->size(); + if (__size < __n) + this->append(__n - __size, __c); + else if (__n < __size) + this->_M_set_length(__n); + } + + template + + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_append(const _CharT* __s, size_type __n) + { + const size_type __len = __n + this->size(); + + if (__len <= this->capacity()) + { + if (__n) + this->_S_copy(this->_M_data() + this->size(), __s, __n); + } + else + this->_M_mutate(this->size(), size_type(0), __s, __n); + + this->_M_set_length(__len); + return *this; + } + + template + template + + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace_dispatch(const_iterator __i1, const_iterator __i2, + _InputIterator __k1, _InputIterator __k2, + std::__false_type) + { + + + const basic_string __s(__k1, __k2, this->get_allocator()); + const size_type __n1 = __i2 - __i1; + return _M_replace(__i1 - begin(), __n1, __s._M_data(), + __s.size()); + } + + template + + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, + _CharT __c) + { + _M_check_length(__n1, __n2, "basic_string::_M_replace_aux"); + + const size_type __old_size = this->size(); + const size_type __new_size = __old_size + __n2 - __n1; + + if (__new_size <= this->capacity()) + { + pointer __p = this->_M_data() + __pos1; + + const size_type __how_much = __old_size - __pos1 - __n1; + if (__how_much && __n1 != __n2) + this->_S_move(__p + __n2, __p + __n1, __how_much); + } + else + this->_M_mutate(__pos1, __n1, 0, __n2); + + if (__n2) + this->_S_assign(this->_M_data() + __pos1, __n2, __c); + + this->_M_set_length(__new_size); + return *this; + } + + template + __attribute__((__noinline__, __noclone__, __cold__)) void + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s, + const size_type __len2, const size_type __how_much) + { + + if (__len2 && __len2 <= __len1) + this->_S_move(__p, __s, __len2); + if (__how_much && __len1 != __len2) + this->_S_move(__p + __len2, __p + __len1, __how_much); + if (__len2 > __len1) + { + if (__s + __len2 <= __p + __len1) + this->_S_move(__p, __s, __len2); + else if (__s >= __p + __len1) + { + + + const size_type __poff = (__s - __p) + (__len2 - __len1); + this->_S_copy(__p, __p + __poff, __len2); + } + else + { + const size_type __nleft = (__p + __len1) - __s; + this->_S_move(__p, __s, __nleft); + this->_S_copy(__p + __nleft, __p + __len2, __len2 - __nleft); + } + } + } + + template + + basic_string<_CharT, _Traits, _Alloc>& + basic_string<_CharT, _Traits, _Alloc>:: + _M_replace(size_type __pos, size_type __len1, const _CharT* __s, + const size_type __len2) + { + _M_check_length(__len1, __len2, "basic_string::_M_replace"); + + const size_type __old_size = this->size(); + const size_type __new_size = __old_size + __len2 - __len1; + + if (__new_size <= this->capacity()) + { + pointer __p = this->_M_data() + __pos; + + const size_type __how_much = __old_size - __pos - __len1; +# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 + if (__builtin_expect(_M_disjunct(__s), true)) + { + if (__how_much && __len1 != __len2) + this->_S_move(__p + __len2, __p + __len1, __how_much); + if (__len2) + this->_S_copy(__p, __s, __len2); + } + else + _M_replace_cold(__p, __len1, __s, __len2, __how_much); + } + else + this->_M_mutate(__pos, __len1, __s, __len2); + + this->_M_set_length(__new_size); + return *this; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + copy(_CharT* __s, size_type __n, size_type __pos) const + { + _M_check(__pos, "basic_string::copy"); + __n = _M_limit(__pos, __n); + ; + if (__n) + _S_copy(__s, _M_data() + __pos, __n); + + return __n; + } +# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find(const _CharT* __s, size_type __pos, size_type __n) const + noexcept + { + ; + const size_type __size = this->size(); + + if (__n == 0) + return __pos <= __size ? __pos : npos; + if (__pos >= __size) + return npos; + + const _CharT __elem0 = __s[0]; + const _CharT* const __data = data(); + const _CharT* __first = __data + __pos; + const _CharT* const __last = __data + __size; + size_type __len = __size - __pos; + + while (__len >= __n) + { + + __first = traits_type::find(__first, __len - __n + 1, __elem0); + if (!__first) + return npos; + + + + if (traits_type::compare(__first, __s, __n) == 0) + return __first - __data; + __len = __last - ++__first; + } + return npos; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find(_CharT __c, size_type __pos) const noexcept + { + size_type __ret = npos; + const size_type __size = this->size(); + if (__pos < __size) + { + const _CharT* __data = _M_data(); + const size_type __n = __size - __pos; + const _CharT* __p = traits_type::find(__data + __pos, __n, __c); + if (__p) + __ret = __p - __data; + } + return __ret; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + rfind(const _CharT* __s, size_type __pos, size_type __n) const + noexcept + { + ; + const size_type __size = this->size(); + if (__n <= __size) + { + __pos = std::min(size_type(__size - __n), __pos); + const _CharT* __data = _M_data(); + do + { + if (traits_type::compare(__data + __pos, __s, __n) == 0) + return __pos; + } + while (__pos-- > 0); + } + return npos; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + rfind(_CharT __c, size_type __pos) const noexcept + { + size_type __size = this->size(); + if (__size) + { + if (--__size > __pos) + __size = __pos; + for (++__size; __size-- > 0; ) + if (traits_type::eq(_M_data()[__size], __c)) + return __size; + } + return npos; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_first_of(const _CharT* __s, size_type __pos, size_type __n) const + noexcept + { + ; + for (; __n && __pos < this->size(); ++__pos) + { + const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]); + if (__p) + return __pos; + } + return npos; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_last_of(const _CharT* __s, size_type __pos, size_type __n) const + noexcept + { + ; + size_type __size = this->size(); + if (__size && __n) + { + if (--__size > __pos) + __size = __pos; + do + { + if (traits_type::find(__s, __n, _M_data()[__size])) + return __size; + } + while (__size-- != 0); + } + return npos; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const + noexcept + { + ; + for (; __pos < this->size(); ++__pos) + if (!traits_type::find(__s, __n, _M_data()[__pos])) + return __pos; + return npos; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_first_not_of(_CharT __c, size_type __pos) const noexcept + { + for (; __pos < this->size(); ++__pos) + if (!traits_type::eq(_M_data()[__pos], __c)) + return __pos; + return npos; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const + noexcept + { + ; + size_type __size = this->size(); + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::find(__s, __n, _M_data()[__size])) + return __size; + } + while (__size--); + } + return npos; + } + + template + + typename basic_string<_CharT, _Traits, _Alloc>::size_type + basic_string<_CharT, _Traits, _Alloc>:: + find_last_not_of(_CharT __c, size_type __pos) const noexcept + { + size_type __size = this->size(); + if (__size) + { + if (--__size > __pos) + __size = __pos; + do + { + if (!traits_type::eq(_M_data()[__size], __c)) + return __size; + } + while (__size--); + } + return npos; + } + + + + + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, + basic_string<_CharT, _Traits, _Alloc>& __str) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __istream_type::ios_base __ios_base; + typedef typename __istream_type::int_type __int_type; + typedef typename __string_type::size_type __size_type; + typedef ctype<_CharT> __ctype_type; + typedef typename __ctype_type::ctype_base __ctype_base; + + __size_type __extracted = 0; + typename __ios_base::iostate __err = __ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + try + { + + __str.erase(); + _CharT __buf[128]; + __size_type __len = 0; + const streamsize __w = __in.width(); + const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) + : __str.max_size(); + const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); + const __int_type __eof = _Traits::eof(); + __int_type __c = __in.rdbuf()->sgetc(); + + while (__extracted < __n + && !_Traits::eq_int_type(__c, __eof) + && !__ct.is(__ctype_base::space, + _Traits::to_char_type(__c))) + { + if (__len == sizeof(__buf) / sizeof(_CharT)) + { + __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); + __len = 0; + } + __buf[__len++] = _Traits::to_char_type(__c); + ++__extracted; + __c = __in.rdbuf()->snextc(); + } + __str.append(__buf, __len); + + if (__extracted < __n && _Traits::eq_int_type(__c, __eof)) + __err |= __ios_base::eofbit; + __in.width(0); + } + catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(__ios_base::badbit); + throw; + } + catch(...) + { + + + + __in._M_setstate(__ios_base::badbit); + } + } + + if (!__extracted) + __err |= __ios_base::failbit; + if (__err) + __in.setstate(__err); + return __in; + } + + template + basic_istream<_CharT, _Traits>& + getline(basic_istream<_CharT, _Traits>& __in, + basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_string<_CharT, _Traits, _Alloc> __string_type; + typedef typename __istream_type::ios_base __ios_base; + typedef typename __istream_type::int_type __int_type; + typedef typename __string_type::size_type __size_type; + + __size_type __extracted = 0; + const __size_type __n = __str.max_size(); + typename __ios_base::iostate __err = __ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, true); + if (__cerb) + { + try + { + __str.erase(); + const __int_type __idelim = _Traits::to_int_type(__delim); + const __int_type __eof = _Traits::eof(); + __int_type __c = __in.rdbuf()->sgetc(); + + while (__extracted < __n + && !_Traits::eq_int_type(__c, __eof) + && !_Traits::eq_int_type(__c, __idelim)) + { + __str += _Traits::to_char_type(__c); + ++__extracted; + __c = __in.rdbuf()->snextc(); + } + + if (_Traits::eq_int_type(__c, __eof)) + __err |= __ios_base::eofbit; + else if (_Traits::eq_int_type(__c, __idelim)) + { + ++__extracted; + __in.rdbuf()->sbumpc(); + } + else + __err |= __ios_base::failbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(__ios_base::badbit); + throw; + } + catch(...) + { + + + + __in._M_setstate(__ios_base::badbit); + } + } + if (!__extracted) + __err |= __ios_base::failbit; + if (__err) + __in.setstate(__err); + return __in; + } +# 963 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 + extern template class basic_string; +# 976 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 + extern template + basic_istream& + operator>>(basic_istream&, string&); + extern template + basic_ostream& + operator<<(basic_ostream&, const string&); + extern template + basic_istream& + getline(basic_istream&, string&, char); + extern template + basic_istream& + getline(basic_istream&, string&); + + + + extern template class basic_string; +# 1002 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 + extern template + basic_istream& + operator>>(basic_istream&, wstring&); + extern template + basic_ostream& + operator<<(basic_ostream&, const wstring&); + extern template + basic_istream& + getline(basic_istream&, wstring&, wchar_t); + extern template + basic_istream& + getline(basic_istream&, wstring&); + + + + +} +# 56 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 1 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 + + + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 +# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 2 3 + +extern "C++" +{ + +namespace std +{ + + using ::max_align_t; +} + + + +namespace std +{ + + + + + enum class byte : unsigned char {}; + + template struct __byte_operand { }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + + + + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; +# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + + template + using __byte_op_t = typename __byte_operand<_IntegerType>::__type; + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType> + operator<<(byte __b, _IntegerType __shift) noexcept + { return (byte)(unsigned char)((unsigned)__b << __shift); } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType> + operator>>(byte __b, _IntegerType __shift) noexcept + { return (byte)(unsigned char)((unsigned)__b >> __shift); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator|(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator&(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator^(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator~(byte __b) noexcept + { return (byte)(unsigned char)~(unsigned)__b; } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType>& + operator<<=(byte& __b, _IntegerType __shift) noexcept + { return __b = __b << __shift; } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType>& + operator>>=(byte& __b, _IntegerType __shift) noexcept + { return __b = __b >> __shift; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator|=(byte& __l, byte __r) noexcept + { return __l = __l | __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator&=(byte& __l, byte __r) noexcept + { return __l = __l & __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator^=(byte& __l, byte __r) noexcept + { return __l = __l ^ __r; } + + template + [[nodiscard,__gnu__::__always_inline__]] + constexpr _IntegerType + to_integer(__byte_op_t<_IntegerType> __b) noexcept + { return _IntegerType(__b); } + + +} + +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + struct __erased_type { }; + + + + + template + using __is_erased_or_convertible + = __or_, is_same<_Tp, __erased_type>>; + + + struct allocator_arg_t { explicit allocator_arg_t() = default; }; + + inline constexpr allocator_arg_t allocator_arg = + allocator_arg_t(); + + template> + struct __uses_allocator_helper + : false_type { }; + + template + struct __uses_allocator_helper<_Tp, _Alloc, + __void_t> + : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type + { }; + + + template + struct uses_allocator + : __uses_allocator_helper<_Tp, _Alloc>::type + { }; + + struct __uses_alloc_base { }; + + struct __uses_alloc0 : __uses_alloc_base + { + struct _Sink { void operator=(const void*) { } } _M_a; + }; + + template + struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc; + + template + struct __uses_alloc + : __conditional_t< + is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, + __uses_alloc1<_Alloc>, + __uses_alloc2<_Alloc>> + { + + + static_assert(__or_< + is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, + is_constructible<_Tp, _Args..., const _Alloc&>>::value, + "construction with an allocator must be possible" + " if uses_allocator is true"); + }; + + template + struct __uses_alloc + : __uses_alloc0 { }; + + template + using __uses_alloc_t = + __uses_alloc::value, _Tp, _Alloc, _Args...>; + + template + + inline __uses_alloc_t<_Tp, _Alloc, _Args...> + __use_alloc(const _Alloc& __a) + { + __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; + __ret._M_a = std::__addressof(__a); + return __ret; + } + + template + void + __use_alloc(const _Alloc&&) = delete; + + + template + inline constexpr bool uses_allocator_v = + uses_allocator<_Tp, _Alloc>::value; + + + template class _Predicate, + typename _Tp, typename _Alloc, typename... _Args> + struct __is_uses_allocator_predicate + : __conditional_t::value, + __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, + _Predicate<_Tp, _Args..., _Alloc>>, + _Predicate<_Tp, _Args...>> { }; + + template + struct __is_uses_allocator_constructible + : __is_uses_allocator_predicate + { }; + + + template + inline constexpr bool __is_uses_allocator_constructible_v = + __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; + + + template + struct __is_nothrow_uses_allocator_constructible + : __is_uses_allocator_predicate + { }; + + + + template + inline constexpr bool + __is_nothrow_uses_allocator_constructible_v = + __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; + + + template + void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr, + _Args&&... __args) + { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } + + template + void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr, + _Args&&... __args) + { + ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a, + std::forward<_Args>(__args)...); + } + + template + void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr, + _Args&&... __args) + { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); } + + template + void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr, + _Args&&... __args) + { + std::__uses_allocator_construct_impl( + std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr, + std::forward<_Args>(__args)...); + } + + + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + class tuple; + + template + struct __is_empty_non_tuple : is_empty<_Tp> { }; + + + template + struct __is_empty_non_tuple> : false_type { }; + + + template + using __empty_not_final + = __conditional_t<__is_final(_Tp), false_type, + __is_empty_non_tuple<_Tp>>; + + template::value> + struct _Head_base; + + + template + struct _Head_base<_Idx, _Head, true> + { + constexpr _Head_base() + : _M_head_impl() { } + + constexpr _Head_base(const _Head& __h) + : _M_head_impl(__h) { } + + constexpr _Head_base(const _Head_base&) = default; + constexpr _Head_base(_Head_base&&) = default; + + template + constexpr _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + + + _Head_base(allocator_arg_t, __uses_alloc0) + : _M_head_impl() { } + + template + + _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) + : _M_head_impl(allocator_arg, *__a._M_a) { } + + template + + _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) + : _M_head_impl(*__a._M_a) { } + + template + + _Head_base(__uses_alloc0, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead)) { } + + template + + _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) + { } + + template + + _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } + + static constexpr _Head& + _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } + + static constexpr const _Head& + _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } + + [[__no_unique_address__]] _Head _M_head_impl; + }; +# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + struct _Head_base<_Idx, _Head, false> + { + constexpr _Head_base() + : _M_head_impl() { } + + constexpr _Head_base(const _Head& __h) + : _M_head_impl(__h) { } + + constexpr _Head_base(const _Head_base&) = default; + constexpr _Head_base(_Head_base&&) = default; + + template + constexpr _Head_base(_UHead&& __h) + : _M_head_impl(std::forward<_UHead>(__h)) { } + + + _Head_base(allocator_arg_t, __uses_alloc0) + : _M_head_impl() { } + + template + + _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) + : _M_head_impl(allocator_arg, *__a._M_a) { } + + template + + _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) + : _M_head_impl(*__a._M_a) { } + + template + + _Head_base(__uses_alloc0, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead)) { } + + template + + _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) + { } + + template + + _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) + : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } + + static constexpr _Head& + _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } + + static constexpr const _Head& + _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } + + _Head _M_head_impl; + }; +# 250 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + struct _Tuple_impl; + + + + + + + template + struct _Tuple_impl<_Idx, _Head, _Tail...> + : public _Tuple_impl<_Idx + 1, _Tail...>, + private _Head_base<_Idx, _Head> + { + template friend struct _Tuple_impl; + + typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; + typedef _Head_base<_Idx, _Head> _Base; + + static constexpr _Head& + _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr const _Head& + _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr _Inherited& + _M_tail(_Tuple_impl& __t) noexcept { return __t; } + + static constexpr const _Inherited& + _M_tail(const _Tuple_impl& __t) noexcept { return __t; } + + constexpr _Tuple_impl() + : _Inherited(), _Base() { } + + explicit constexpr + _Tuple_impl(const _Head& __head, const _Tail&... __tail) + : _Inherited(__tail...), _Base(__head) + { } + + template> + explicit constexpr + _Tuple_impl(_UHead&& __head, _UTail&&... __tail) + : _Inherited(std::forward<_UTail>(__tail)...), + _Base(std::forward<_UHead>(__head)) + { } + + constexpr _Tuple_impl(const _Tuple_impl&) = default; + + + + _Tuple_impl& operator=(const _Tuple_impl&) = delete; + + _Tuple_impl(_Tuple_impl&&) = default; + + template + constexpr + _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) + : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), + _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) + { } + + template + constexpr + _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + : _Inherited(std::move + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), + _Base(std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) + { } +# 338 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a), + _Base(__tag, __use_alloc<_Head>(__a)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Head& __head, const _Tail&... __tail) + : _Inherited(__tag, __a, __tail...), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) + { } + + template> + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _UHead&& __head, _UTail&&... __tail) + : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), + _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(__head)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl& __in) + : _Inherited(__tag, __a, _M_tail(__in)), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl&& __in) + : _Inherited(__tag, __a, std::move(_M_tail(__in))), + _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + std::forward<_Head>(_M_head(__in))) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl<_Idx, _UHead, _UTails...>& __in) + : _Inherited(__tag, __a, + _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), + _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), + _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + : _Inherited(__tag, __a, std::move + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), + _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) + { } +# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + void + _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) + { + _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); + _M_tail(*this)._M_assign( + _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); + } + + template + + void + _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) + { + _M_head(*this) = std::forward<_UHead> + (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); + _M_tail(*this)._M_assign( + std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); + } +# 466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + protected: + + void + _M_swap(_Tuple_impl& __in) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + _Inherited::_M_swap(_M_tail(__in)); + } +# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + template + struct _Tuple_impl<_Idx, _Head> + : private _Head_base<_Idx, _Head> + { + template friend struct _Tuple_impl; + + typedef _Head_base<_Idx, _Head> _Base; + + static constexpr _Head& + _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + static constexpr const _Head& + _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } + + constexpr + _Tuple_impl() + : _Base() { } + + explicit constexpr + _Tuple_impl(const _Head& __head) + : _Base(__head) + { } + + template + explicit constexpr + _Tuple_impl(_UHead&& __head) + : _Base(std::forward<_UHead>(__head)) + { } + + constexpr _Tuple_impl(const _Tuple_impl&) = default; + + + + _Tuple_impl& operator=(const _Tuple_impl&) = delete; + + + + + constexpr + _Tuple_impl(_Tuple_impl&& __in) + noexcept(is_nothrow_move_constructible<_Head>::value) + : _Base(static_cast<_Base&&>(__in)) + { } + + + template + constexpr + _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) + : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) + { } + + template + constexpr + _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) + : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) + { } +# 559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) + : _Base(__tag, __use_alloc<_Head>(__a)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Head& __head) + : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _UHead&& __head) + : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(__head)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl& __in) + : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl&& __in) + : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), + std::forward<_Head>(_M_head(__in))) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + const _Tuple_impl<_Idx, _UHead>& __in) + : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), + _Tuple_impl<_Idx, _UHead>::_M_head(__in)) + { } + + template + + _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, + _Tuple_impl<_Idx, _UHead>&& __in) + : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), + std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) + { } +# 629 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + void + _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) + { + _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); + } + + template + + void + _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) + { + _M_head(*this) + = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); + } +# 663 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + protected: + + void + _M_swap(_Tuple_impl& __in) + { + using std::swap; + swap(_M_head(*this), _M_head(__in)); + } +# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + + template + struct _TupleConstraints + { + template + using __constructible = __and_...>; + + template + using __convertible = __and_...>; + + + + + template + static constexpr bool __is_implicitly_constructible() + { + return __and_<__constructible<_UTypes...>, + __convertible<_UTypes...> + >::value; + } + + + + + template + static constexpr bool __is_explicitly_constructible() + { + return __and_<__constructible<_UTypes...>, + __not_<__convertible<_UTypes...>> + >::value; + } + + static constexpr bool __is_implicitly_default_constructible() + { + return __and_... + >::value; + } + + static constexpr bool __is_explicitly_default_constructible() + { + return __and_..., + __not_<__and_< + std::__is_implicitly_default_constructible<_Types>...> + >>::value; + } + }; + + + + template + struct _TupleConstraints + { + template + static constexpr bool __is_implicitly_constructible() + { return false; } + + template + static constexpr bool __is_explicitly_constructible() + { return false; } + }; + + + template + class tuple : public _Tuple_impl<0, _Elements...> + { + typedef _Tuple_impl<0, _Elements...> _Inherited; + + template + using _TCC = _TupleConstraints<_Cond, _Elements...>; + + + template + using _ImplicitDefaultCtor = __enable_if_t< + _TCC<_Dummy>::__is_implicitly_default_constructible(), + bool>; + + + template + using _ExplicitDefaultCtor = __enable_if_t< + _TCC<_Dummy>::__is_explicitly_default_constructible(), + bool>; + + + template + using _ImplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), + bool>; + + + template + using _ExplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), + bool>; + + template + static constexpr + __enable_if_t + __assignable() + { return __and_...>::value; } + + + template + static constexpr bool __nothrow_assignable() + { + return + __and_...>::value; + } + + + template + static constexpr bool __nothrow_constructible() + { + return + __and_...>::value; + } + + + template + static constexpr bool __valid_args() + { + return sizeof...(_Elements) == 1 + && !is_same>::value; + } + + + template + static constexpr bool __valid_args() + { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } +# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template> + struct _UseOtherCtor + : false_type + { }; + + + template + struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> + : __or_, is_constructible<_Tp, _Tuple>>::type + { }; + + + template + struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> + : true_type + { }; + + + + + template + static constexpr bool __use_other_ctor() + { return _UseOtherCtor<_Tuple>::value; } +# 856 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + public: + template::value> = true> + constexpr + tuple() + noexcept(__and_...>::value) + : _Inherited() { } + + template::value> = false> + explicit constexpr + tuple() + noexcept(__and_...>::value) + : _Inherited() { } + + template= 1), + _ImplicitCtor<_NotEmpty, const _Elements&...> = true> + constexpr + tuple(const _Elements&... __elements) + noexcept(__nothrow_constructible()) + : _Inherited(__elements...) { } + + template= 1), + _ExplicitCtor<_NotEmpty, const _Elements&...> = false> + explicit constexpr + tuple(const _Elements&... __elements) + noexcept(__nothrow_constructible()) + : _Inherited(__elements...) { } + + template(), + _ImplicitCtor<_Valid, _UElements...> = true> + constexpr + tuple(_UElements&&... __elements) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + template(), + _ExplicitCtor<_Valid, _UElements...> = false> + explicit constexpr + tuple(_UElements&&... __elements) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(std::forward<_UElements>(__elements)...) { } + + constexpr tuple(const tuple&) = default; + + constexpr tuple(tuple&&) = default; + + template&>(), + _ImplicitCtor<_Valid, const _UElements&...> = true> + constexpr + tuple(const tuple<_UElements...>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) + { } + + template&>(), + _ExplicitCtor<_Valid, const _UElements&...> = false> + explicit constexpr + tuple(const tuple<_UElements...>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) + { } + + template&&>(), + _ImplicitCtor<_Valid, _UElements...> = true> + constexpr + tuple(tuple<_UElements...>&& __in) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } + + template&&>(), + _ExplicitCtor<_Valid, _UElements...> = false> + explicit constexpr + tuple(tuple<_UElements...>&& __in) + noexcept(__nothrow_constructible<_UElements...>()) + : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } +# 968 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template::value> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template= 1), + _ImplicitCtor<_NotEmpty, const _Elements&...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template= 1), + _ExplicitCtor<_NotEmpty, const _Elements&...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _Elements&... __elements) + : _Inherited(__tag, __a, __elements...) { } + + template(), + _ImplicitCtor<_Valid, _UElements...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + _UElements&&... __elements) + : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) + { } + + template(), + _ExplicitCtor<_Valid, _UElements...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + _UElements&&... __elements) + : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) + { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) + : _Inherited(__tag, __a, static_cast(__in)) { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) + : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } + + template&>(), + _ImplicitCtor<_Valid, const _UElements&...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template&>(), + _ExplicitCtor<_Valid, const _UElements&...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_UElements...>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template&&>(), + _ImplicitCtor<_Valid, _UElements...> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_UElements...>&& __in) + : _Inherited(__tag, __a, + static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) + { } + + template&&>(), + _ExplicitCtor<_Valid, _UElements...> = false> + + explicit + tuple(allocator_arg_t __tag, const _Alloc& __a, + tuple<_UElements...>&& __in) + : _Inherited(__tag, __a, + static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) + { } +# 1093 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + tuple& + operator=(__conditional_t<__assignable(), + const tuple&, + const __nonesuch&> __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + + tuple& + operator=(__conditional_t<__assignable<_Elements...>(), + tuple&&, + __nonesuch&&> __in) + noexcept(__nothrow_assignable<_Elements...>()) + { + this->_M_assign(std::move(__in)); + return *this; + } + + template + + __enable_if_t<__assignable(), tuple&> + operator=(const tuple<_UElements...>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + template + + __enable_if_t<__assignable<_UElements...>(), tuple&> + operator=(tuple<_UElements...>&& __in) + noexcept(__nothrow_assignable<_UElements...>()) + { + this->_M_assign(std::move(__in)); + return *this; + } +# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + void + swap(tuple& __in) + noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) + { _Inherited::_M_swap(__in); } +# 1192 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + template + tuple(_UTypes...) -> tuple<_UTypes...>; + template + tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; + template + tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; + template + tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; + template + tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; + + + + template<> + class tuple<> + { + public: + + void swap(tuple&) noexcept { } + + + + + + tuple() = default; + + template + + tuple(allocator_arg_t, const _Alloc&) noexcept { } + template + + tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } + }; + + + + template + class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> + { + typedef _Tuple_impl<0, _T1, _T2> _Inherited; + + + template + using _ImplicitDefaultCtor = __enable_if_t< + _TupleConstraints<_Dummy, _U1, _U2>:: + __is_implicitly_default_constructible(), + bool>; + + + template + using _ExplicitDefaultCtor = __enable_if_t< + _TupleConstraints<_Dummy, _U1, _U2>:: + __is_explicitly_default_constructible(), + bool>; + + template + using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; + + + template + using _ImplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), + bool>; + + + template + using _ExplicitCtor = __enable_if_t< + _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), + bool>; + + template + static constexpr bool __assignable() + { + return __and_, + is_assignable<_T2&, _U2>>::value; + } + + template + static constexpr bool __nothrow_assignable() + { + return __and_, + is_nothrow_assignable<_T2&, _U2>>::value; + } + + template + static constexpr bool __nothrow_constructible() + { + return __and_, + is_nothrow_constructible<_T2, _U2>>::value; + } + + static constexpr bool __nothrow_default_constructible() + { + return __and_, + is_nothrow_default_constructible<_T2>>::value; + } + + template + static constexpr bool __is_alloc_arg() + { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } +# 1306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + public: + template = true> + constexpr + tuple() + noexcept(__nothrow_default_constructible()) + : _Inherited() { } + + template = false> + explicit constexpr + tuple() + noexcept(__nothrow_default_constructible()) + : _Inherited() { } + + template = true> + constexpr + tuple(const _T1& __a1, const _T2& __a2) + noexcept(__nothrow_constructible()) + : _Inherited(__a1, __a2) { } + + template = false> + explicit constexpr + tuple(const _T1& __a1, const _T2& __a2) + noexcept(__nothrow_constructible()) + : _Inherited(__a1, __a2) { } + + template(), _U1, _U2> = true> + constexpr + tuple(_U1&& __a1, _U2&& __a2) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + template(), _U1, _U2> = false> + explicit constexpr + tuple(_U1&& __a1, _U2&& __a2) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } + + constexpr tuple(const tuple&) = default; + + constexpr tuple(tuple&&) = default; + + template = true> + constexpr + tuple(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) { } + + template = false> + explicit constexpr + tuple(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(static_cast&>(__in)) { } + + template = true> + constexpr + tuple(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } + + template = false> + explicit constexpr + tuple(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } +# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template = true> + constexpr + tuple(const pair<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(__in.first, __in.second) { } + + template = false> + explicit constexpr + tuple(const pair<_U1, _U2>& __in) + noexcept(__nothrow_constructible()) + : _Inherited(__in.first, __in.second) { } + + template = true> + constexpr + tuple(pair<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + template = false> + explicit constexpr + tuple(pair<_U1, _U2>&& __in) + noexcept(__nothrow_constructible<_U1, _U2>()) + : _Inherited(std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } +# 1450 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template::value, _T1, _T2> = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a) + : _Inherited(__tag, __a) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const _T1& __a1, const _T2& __a2) + : _Inherited(__tag, __a, __a1, __a2) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) + : _Inherited(__tag, __a, std::forward<_U1>(__a1), + std::forward<_U2>(__a2)) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + _U1&& __a1, _U2&& __a2) + : _Inherited(__tag, __a, std::forward<_U1>(__a1), + std::forward<_U2>(__a2)) { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) + : _Inherited(__tag, __a, static_cast(__in)) { } + + template + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) + : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const tuple<_U1, _U2>& __in) + : _Inherited(__tag, __a, + static_cast&>(__in)) + { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) + : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) + { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) + : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) + { } +# 1553 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, + const pair<_U1, _U2>& __in) + : _Inherited(__tag, __a, __in.first, __in.second) { } + + template = true> + + tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) + : _Inherited(__tag, __a, std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } + + template = false> + explicit + + tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) + : _Inherited(__tag, __a, std::forward<_U1>(__in.first), + std::forward<_U2>(__in.second)) { } +# 1604 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + tuple& + operator=(__conditional_t<__assignable(), + const tuple&, + const __nonesuch&> __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + + tuple& + operator=(__conditional_t<__assignable<_T1, _T2>(), + tuple&&, + __nonesuch&&> __in) + noexcept(__nothrow_assignable<_T1, _T2>()) + { + this->_M_assign(std::move(__in)); + return *this; + } + + template + + __enable_if_t<__assignable(), tuple&> + operator=(const tuple<_U1, _U2>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_assign(__in); + return *this; + } + + template + + __enable_if_t<__assignable<_U1, _U2>(), tuple&> + operator=(tuple<_U1, _U2>&& __in) + noexcept(__nothrow_assignable<_U1, _U2>()) + { + this->_M_assign(std::move(__in)); + return *this; + } +# 1683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + __enable_if_t<__assignable(), tuple&> + operator=(const pair<_U1, _U2>& __in) + noexcept(__nothrow_assignable()) + { + this->_M_head(*this) = __in.first; + this->_M_tail(*this)._M_head(*this) = __in.second; + return *this; + } + + template + + __enable_if_t<__assignable<_U1, _U2>(), tuple&> + operator=(pair<_U1, _U2>&& __in) + noexcept(__nothrow_assignable<_U1, _U2>()) + { + this->_M_head(*this) = std::forward<_U1>(__in.first); + this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); + return *this; + } +# 1730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + void + swap(tuple& __in) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { _Inherited::_M_swap(__in); } +# 1744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + inline constexpr size_t tuple_size_v> + = sizeof...(_Types); + + template + inline constexpr size_t tuple_size_v> + = sizeof...(_Types); + + + + template + struct tuple_element<__i, tuple<_Types...>> + { + static_assert(__i < sizeof...(_Types), "tuple index must be in range"); + + using type = typename _Nth_type<__i, _Types...>::type; + }; + + template + constexpr _Head& + __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + template + constexpr const _Head& + __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept + { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } + + + template + __enable_if_t<(__i >= sizeof...(_Types))> + __get_helper(const tuple<_Types...>&) = delete; + + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>& + get(tuple<_Elements...>& __t) noexcept + { return std::__get_helper<__i>(__t); } + + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>& + get(const tuple<_Elements...>& __t) noexcept + { return std::__get_helper<__i>(__t); } + + + template + constexpr __tuple_element_t<__i, tuple<_Elements...>>&& + get(tuple<_Elements...>&& __t) noexcept + { + typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; + return std::forward<__element_type>(std::__get_helper<__i>(__t)); + } + + + template + constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& + get(const tuple<_Elements...>&& __t) noexcept + { + typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; + return std::forward(std::__get_helper<__i>(__t)); + } + + + + template + constexpr __enable_if_t<(__i >= sizeof...(_Elements))> + get(const tuple<_Elements...>&) = delete; + + + + + + + + template + constexpr _Tp& + get(tuple<_Types...>& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::__get_helper<__idx>(__t); + } + + + template + constexpr _Tp&& + get(tuple<_Types...>&& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::forward<_Tp>(std::__get_helper<__idx>(__t)); + } + + + template + constexpr const _Tp& + get(const tuple<_Types...>& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::__get_helper<__idx>(__t); + } + + + + template + constexpr const _Tp&& + get(const tuple<_Types...>&& __t) noexcept + { + constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); + static_assert(__idx < sizeof...(_Types), + "the type T in std::get must occur exactly once in the tuple"); + return std::forward(std::__get_helper<__idx>(__t)); + } + + + + template + struct __tuple_compare + { + static constexpr bool + __eq(const _Tp& __t, const _Up& __u) + { + return bool(std::get<__i>(__t) == std::get<__i>(__u)) + && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); + } + + static constexpr bool + __less(const _Tp& __t, const _Up& __u) + { + return bool(std::get<__i>(__t) < std::get<__i>(__u)) + || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) + && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); + } + }; + + template + struct __tuple_compare<_Tp, _Up, __size, __size> + { + static constexpr bool + __eq(const _Tp&, const _Up&) { return true; } + + static constexpr bool + __less(const _Tp&, const _Up&) { return false; } + }; + + template + constexpr bool + operator==(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) == sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare = __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__eq(__t, __u); + } +# 1945 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + constexpr bool + operator<(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { + static_assert(sizeof...(_TElements) == sizeof...(_UElements), + "tuple objects can only be compared if they have equal sizes."); + using __compare = __tuple_compare, + tuple<_UElements...>, + 0, sizeof...(_TElements)>; + return __compare::__less(__t, __u); + } + + template + constexpr bool + operator!=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t == __u); } + + template + constexpr bool + operator>(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return __u < __t; } + + template + constexpr bool + operator<=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__u < __t); } + + template + constexpr bool + operator>=(const tuple<_TElements...>& __t, + const tuple<_UElements...>& __u) + { return !(__t < __u); } + + + + + template + constexpr tuple::__type...> + make_tuple(_Elements&&... __args) + { + typedef tuple::__type...> + __result_type; + return __result_type(std::forward<_Elements>(__args)...); + } + + + + + template + constexpr tuple<_Elements&&...> + forward_as_tuple(_Elements&&... __args) noexcept + { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } + + + + + template struct array; + + template + constexpr _Tp& + get(array<_Tp, _Nm>&) noexcept; + + template + constexpr _Tp&& + get(array<_Tp, _Nm>&&) noexcept; + + template + constexpr const _Tp& + get(const array<_Tp, _Nm>&) noexcept; + + template + constexpr const _Tp&& + get(const array<_Tp, _Nm>&&) noexcept; + + + template + struct __make_tuple_impl; + + template + struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> + : __make_tuple_impl<_Idx + 1, + tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, + _Tuple, _Nm> + { }; + + template + struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> + { + typedef tuple<_Tp...> __type; + }; + + template + struct __do_make_tuple + : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value> + { }; + + + template + struct __make_tuple + : public __do_make_tuple<__remove_cvref_t<_Tuple>> + { }; + + + template + struct __combine_tuples; + + template<> + struct __combine_tuples<> + { + typedef tuple<> __type; + }; + + template + struct __combine_tuples> + { + typedef tuple<_Ts...> __type; + }; + + template + struct __combine_tuples, tuple<_T2s...>, _Rem...> + { + typedef typename __combine_tuples, + _Rem...>::__type __type; + }; + + + template + struct __tuple_cat_result + { + typedef typename __combine_tuples + ::__type...>::__type __type; + }; + + + + template + struct __make_1st_indices; + + template<> + struct __make_1st_indices<> + { + typedef _Index_tuple<> __type; + }; + + template + struct __make_1st_indices<_Tp, _Tpls...> + { + typedef typename _Build_index_tuple::type>::value>::__type __type; + }; + + + + + template + struct __tuple_concater; + + template + struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...> + { + template + static constexpr _Ret + _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) + { + typedef typename __make_1st_indices<_Tpls...>::__type __idx; + typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; + return __next::_S_do(std::forward<_Tpls>(__tps)..., + std::forward<_Us>(__us)..., + std::get<_Is>(std::forward<_Tp>(__tp))...); + } + }; + + template + struct __tuple_concater<_Ret, _Index_tuple<>> + { + template + static constexpr _Ret + _S_do(_Us&&... __us) + { + return _Ret(std::forward<_Us>(__us)...); + } + }; + + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template...>::value>::type> + constexpr auto + tuple_cat(_Tpls&&... __tpls) + -> typename __tuple_cat_result<_Tpls...>::__type + { + typedef typename __tuple_cat_result<_Tpls...>::__type __ret; + typedef typename __make_1st_indices<_Tpls...>::__type __idx; + typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; + return __concater::_S_do(std::forward<_Tpls>(__tpls)...); + } + + + + + template + constexpr tuple<_Elements&...> + tie(_Elements&... __args) noexcept + { return tuple<_Elements&...>(__args...); } + + + template + + inline + + + typename enable_if<__and_<__is_swappable<_Elements>...>::value + >::type + + + + swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 2184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + + typename enable_if...>::value>::type + swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; + + + + + + + struct _Swallow_assign + { + template + constexpr const _Swallow_assign& + operator=(const _Tp&) const + { return *this; } + }; +# 2219 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + inline constexpr _Swallow_assign ignore{}; + + + template + struct uses_allocator, _Alloc> : true_type { }; +# 2234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 + template + template + + inline + pair<_T1, _T2>:: + pair(piecewise_construct_t, + tuple<_Args1...> __first, tuple<_Args2...> __second) + : pair(__first, __second, + typename _Build_index_tuple::__type(), + typename _Build_index_tuple::__type()) + { } + + template + template + inline + pair<_T1, _T2>:: + pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) + : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), + second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) + { } + + + + + + + + template class _Trait, typename _Tp, typename _Tuple> + inline constexpr bool __unpack_std_tuple = false; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> + = _Trait<_Tp, _Up...>::value; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> + = _Trait<_Tp, _Up&...>::value; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> + = _Trait<_Tp, const _Up...>::value; + + template class _Trait, typename _Tp, typename... _Up> + inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> + = _Trait<_Tp, const _Up&...>::value; + + + + template + constexpr decltype(auto) + __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) + { + return std::__invoke(std::forward<_Fn>(__f), + std::get<_Idx>(std::forward<_Tuple>(__t))...); + } + + template + constexpr decltype(auto) + apply(_Fn&& __f, _Tuple&& __t) + noexcept(__unpack_std_tuple) + { + using _Indices + = make_index_sequence>>; + return std::__apply_impl(std::forward<_Fn>(__f), + std::forward<_Tuple>(__t), + _Indices{}); + } + + + + template + constexpr _Tp + __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) + { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } + + template + constexpr _Tp + make_from_tuple(_Tuple&& __t) + noexcept(__unpack_std_tuple) + { + constexpr size_t __n = tuple_size_v>; + + + + + + + + return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t), + make_index_sequence<__n>{}); + } +# 2345 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 +} +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + +namespace pmr +{ + + + + + + + class memory_resource + { + static constexpr size_t _S_max_align = alignof(max_align_t); + + public: + memory_resource() = default; + memory_resource(const memory_resource&) = default; + virtual ~memory_resource(); + + memory_resource& operator=(const memory_resource&) = default; + + [[nodiscard]] + void* + allocate(size_t __bytes, size_t __alignment = _S_max_align) + __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3))) + { return ::operator new(__bytes, do_allocate(__bytes, __alignment)); } + + void + deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align) + __attribute__((__nonnull__)) + { return do_deallocate(__p, __bytes, __alignment); } + + [[nodiscard]] + bool + is_equal(const memory_resource& __other) const noexcept + { return do_is_equal(__other); } + + private: + virtual void* + do_allocate(size_t __bytes, size_t __alignment) = 0; + + virtual void + do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0; + + virtual bool + do_is_equal(const memory_resource& __other) const noexcept = 0; + }; + + [[nodiscard]] + inline bool + operator==(const memory_resource& __a, const memory_resource& __b) noexcept + { return &__a == &__b || __a.is_equal(__b); } + + + [[nodiscard]] + inline bool + operator!=(const memory_resource& __a, const memory_resource& __b) noexcept + { return !(__a == __b); } +# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + class polymorphic_allocator + { + + + template + struct __not_pair { using type = void; }; + + template + struct __not_pair> { }; + + public: + using value_type = _Tp; + + polymorphic_allocator() noexcept + { + extern memory_resource* get_default_resource() noexcept + __attribute__((__returns_nonnull__)); + _M_resource = get_default_resource(); + } + + polymorphic_allocator(memory_resource* __r) noexcept + __attribute__((__nonnull__)) + : _M_resource(__r) + { ; } + + polymorphic_allocator(const polymorphic_allocator& __other) = default; + + template + polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept + : _M_resource(__x.resource()) + { } + + polymorphic_allocator& + operator=(const polymorphic_allocator&) = delete; + + [[nodiscard]] + _Tp* + allocate(size_t __n) + __attribute__((__returns_nonnull__)) + { + if ((__gnu_cxx::__int_traits::__max / sizeof(_Tp)) < __n) + std::__throw_bad_array_new_length(); + return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp), + alignof(_Tp))); + } + + void + deallocate(_Tp* __p, size_t __n) noexcept + __attribute__((__nonnull__)) + { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); } +# 224 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + __attribute__((__nonnull__)) + typename __not_pair<_Tp1>::type + construct(_Tp1* __p, _Args&&... __args) + { + + + using __use_tag + = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>; + if constexpr (is_base_of_v<__uses_alloc0, __use_tag>) + ::new(__p) _Tp1(std::forward<_Args>(__args)...); + else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>) + ::new(__p) _Tp1(allocator_arg, *this, + std::forward<_Args>(__args)...); + else + ::new(__p) _Tp1(std::forward<_Args>(__args)..., *this); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t, + tuple<_Args1...> __x, tuple<_Args2...> __y) + { + auto __x_tag = + __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this); + auto __y_tag = + __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this); + index_sequence_for<_Args1...> __x_i; + index_sequence_for<_Args2...> __y_i; + + ::new(__p) pair<_Tp1, _Tp2>(piecewise_construct, + _S_construct_p(__x_tag, __x_i, __x), + _S_construct_p(__y_tag, __y_i, __y)); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p) + { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y) + { + this->construct(__p, piecewise_construct, + std::forward_as_tuple(std::forward<_Up>(__x)), + std::forward_as_tuple(std::forward<_Vp>(__y))); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, const std::pair<_Up, _Vp>& __pr) + { + this->construct(__p, piecewise_construct, + std::forward_as_tuple(__pr.first), + std::forward_as_tuple(__pr.second)); + } + + template + __attribute__((__nonnull__)) + void + construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr) + { + this->construct(__p, piecewise_construct, + std::forward_as_tuple(std::forward<_Up>(__pr.first)), + std::forward_as_tuple(std::forward<_Vp>(__pr.second))); + } +# 307 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + + __attribute__((__nonnull__)) + void + destroy(_Up* __p) + { __p->~_Up(); } + + polymorphic_allocator + select_on_container_copy_construction() const noexcept + { return polymorphic_allocator(); } + + memory_resource* + resource() const noexcept + __attribute__((__returns_nonnull__)) + { return _M_resource; } + + + + [[nodiscard]] + friend bool + operator==(const polymorphic_allocator& __a, + const polymorphic_allocator& __b) noexcept + { return *__a.resource() == *__b.resource(); } + + + [[nodiscard]] + friend bool + operator!=(const polymorphic_allocator& __a, + const polymorphic_allocator& __b) noexcept + { return !(__a == __b); } + + + private: + + using __uses_alloc1_ = __uses_alloc1; + using __uses_alloc2_ = __uses_alloc2; + + template + static tuple<_Args&&...> + _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t) + { return std::move(__t); } + + template + static tuple + _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>, + tuple<_Args...>& __t) + { + return { + allocator_arg, *__ua._M_a, std::get<_Ind>(std::move(__t))... + }; + } + + template + static tuple<_Args&&..., polymorphic_allocator> + _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>, + tuple<_Args...>& __t) + { return { std::get<_Ind>(std::move(__t))..., *__ua._M_a }; } + + + memory_resource* _M_resource; + }; + + template + [[nodiscard]] + inline bool + operator==(const polymorphic_allocator<_Tp1>& __a, + const polymorphic_allocator<_Tp2>& __b) noexcept + { return *__a.resource() == *__b.resource(); } + + + template + [[nodiscard]] + inline bool + operator!=(const polymorphic_allocator<_Tp1>& __a, + const polymorphic_allocator<_Tp2>& __b) noexcept + { return !(__a == __b); } + + +} + + template struct allocator_traits; + + + template + struct allocator_traits> + { + + using allocator_type = pmr::polymorphic_allocator<_Tp>; + + + using value_type = _Tp; + + + using pointer = _Tp*; + + + using const_pointer = const _Tp*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + + + + using propagate_on_container_copy_assignment = false_type; + using propagate_on_container_move_assignment = false_type; + using propagate_on_container_swap = false_type; + + static allocator_type + select_on_container_copy_construction(const allocator_type&) noexcept + { return allocator_type(); } + + + + using is_always_equal = false_type; + + template + using rebind_alloc = pmr::polymorphic_allocator<_Up>; + + template + using rebind_traits = allocator_traits>; +# 446 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + [[nodiscard]] static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 461 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + [[nodiscard]] static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer) + { return __a.allocate(__n); } +# 473 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + static void + construct(allocator_type& __a, _Up* __p, _Args&&... __args) + { __a.construct(__p, std::forward<_Args>(__args)...); } +# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + template + static void + destroy(allocator_type&, _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { __p->~_Up(); } + + + + + + static size_type + max_size(const allocator_type&) noexcept + { return size_t(-1) / sizeof(value_type); } + }; + + +} +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + namespace pmr { + template> + using basic_string = std::basic_string<_CharT, _Traits, + polymorphic_allocator<_CharT>>; + using string = basic_string; + + + + using u16string = basic_string; + using u32string = basic_string; + using wstring = basic_string; + } + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + class locale + { + public: + + + typedef int category; + + + class facet; + class id; + class _Impl; + + friend class facet; + friend class _Impl; + + template + friend bool + has_facet(const locale&) throw(); + + template + friend const _Facet& + use_facet(const locale&); + + template + friend const _Facet* + __try_use_facet(const locale&) noexcept; + + template + friend struct __use_cache; +# 102 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + static const category none = 0; + static const category ctype = 1L << 0; + static const category numeric = 1L << 1; + static const category collate = 1L << 2; + static const category time = 1L << 3; + static const category monetary = 1L << 4; + static const category messages = 1L << 5; + static const category all = (ctype | numeric | collate | + time | monetary | messages); +# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + locale() throw(); +# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + locale(const locale& __other) throw(); +# 140 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + explicit + locale(const char* __s); +# 155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + locale(const locale& __base, const char* __s, category __cat); +# 166 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + explicit + locale(const std::string& __s) : locale(__s.c_str()) { } +# 181 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + locale(const locale& __base, const std::string& __s, category __cat) + : locale(__base, __s.c_str(), __cat) { } +# 196 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + locale(const locale& __base, const locale& __add, category __cat); +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + template + locale(const locale& __other, _Facet* __f); + + + ~locale() throw(); +# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + const locale& + operator=(const locale& __other) throw(); +# 238 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + template + locale + combine(const locale& __other) const; + + + + + + + __attribute ((__abi_tag__ ("cxx11"))) + string + name() const; +# 258 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + bool + operator==(const locale& __other) const throw(); +# 268 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + bool + operator!=(const locale& __other) const throw() + { return !(this->operator==(__other)); } +# 288 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + template + bool + operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, + const basic_string<_Char, _Traits, _Alloc>& __s2) const; +# 304 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + static locale + global(const locale& __loc); + + + + + static const locale& + classic(); + + private: + + _Impl* _M_impl; + + + static _Impl* _S_classic; + + + static _Impl* _S_global; + + + + + + static const char* const* const _S_categories; +# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + enum { _S_categories_size = 6 + 6 }; + + + static __gthread_once_t _S_once; + + + explicit + locale(_Impl*) throw(); + + static void + _S_initialize(); + + static void + _S_initialize_once() throw(); + + static category + _S_normalize_category(category); + + void + _M_coalesce(const locale& __base, const locale& __add, category __cat); + + + static const id* const _S_twinned_facets[]; + + }; +# 377 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + class locale::facet + { + private: + friend class locale; + friend class locale::_Impl; + + mutable _Atomic_word _M_refcount; + + + static __c_locale _S_c_locale; + + + static const char _S_c_name[2]; + + + static __gthread_once_t _S_once; + + + static void + _S_initialize_once(); + + protected: +# 408 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + explicit + facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0) + { } + + + virtual + ~facet(); + + static void + _S_create_c_locale(__c_locale& __cloc, const char* __s, + __c_locale __old = 0); + + static __c_locale + _S_clone_c_locale(__c_locale& __cloc) throw(); + + static void + _S_destroy_c_locale(__c_locale& __cloc); + + static __c_locale + _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s); + + + + static __c_locale + _S_get_c_locale(); + + __attribute__ ((__const__)) static const char* + _S_get_c_name() throw(); +# 444 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + facet(const facet&) = delete; + + facet& + operator=(const facet&) = delete; + + + private: + void + _M_add_reference() const throw() + { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } + + void + _M_remove_reference() const throw() + { + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) + { + ; + try + { delete this; } + catch(...) + { } + } + } + + const facet* _M_sso_shim(const id*) const; + const facet* _M_cow_shim(const id*) const; + + protected: + class __shim; + }; +# 489 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + class locale::id + { + private: + friend class locale; + friend class locale::_Impl; + + template + friend const _Facet& + use_facet(const locale&); + + template + friend bool + has_facet(const locale&) throw(); + + template + friend const _Facet* + __try_use_facet(const locale&) noexcept; + + + + + mutable size_t _M_index; + + + static _Atomic_word _S_refcount; + + void + operator=(const id&); + + id(const id&); + + public: + + + + id() { } + + size_t + _M_id() const throw(); + }; + + + + class locale::_Impl + { + public: + + friend class locale; + friend class locale::facet; + + template + friend bool + has_facet(const locale&) throw(); + + template + friend const _Facet& + use_facet(const locale&); + + template + friend const _Facet* + __try_use_facet(const locale&) noexcept; + + template + friend struct __use_cache; + + private: + + _Atomic_word _M_refcount; + const facet** _M_facets; + size_t _M_facets_size; + const facet** _M_caches; + char** _M_names; + static const locale::id* const _S_id_ctype[]; + static const locale::id* const _S_id_numeric[]; + static const locale::id* const _S_id_collate[]; + static const locale::id* const _S_id_time[]; + static const locale::id* const _S_id_monetary[]; + static const locale::id* const _S_id_messages[]; + static const locale::id* const* const _S_facet_categories[]; + + void + _M_add_reference() throw() + { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } + + void + _M_remove_reference() throw() + { + + ; + if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) + { + ; + try + { delete this; } + catch(...) + { } + } + } + + _Impl(const _Impl&, size_t); + _Impl(const char*, size_t); + _Impl(size_t) throw(); + + ~_Impl() throw(); + + _Impl(const _Impl&); + + void + operator=(const _Impl&); + + bool + _M_check_same_name() + { + bool __ret = true; + if (_M_names[1]) + + for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i) + __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0; + return __ret; + } + + void + _M_replace_categories(const _Impl*, category); + + void + _M_replace_category(const _Impl*, const locale::id* const*); + + void + _M_replace_facet(const _Impl*, const locale::id*); + + void + _M_install_facet(const locale::id*, const facet*); + + template + void + _M_init_facet(_Facet* __facet) + { _M_install_facet(&_Facet::id, __facet); } + + template + void + _M_init_facet_unchecked(_Facet* __facet) + { + __facet->_M_add_reference(); + _M_facets[_Facet::id._M_id()] = __facet; + } + + void + _M_install_cache(const facet*, size_t); + + void _M_init_extra(facet**); + void _M_init_extra(void*, void*, const char*, const char*); + + + + + }; +# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + template + class __cxx11:: collate : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + + protected: + + + __c_locale _M_c_locale_collate; + + public: + + static locale::id id; +# 686 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + explicit + collate(size_t __refs = 0) + : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) + { } +# 700 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + explicit + collate(__c_locale __cloc, size_t __refs = 0) + : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) + { } +# 717 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + int + compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const + { return this->do_compare(__lo1, __hi1, __lo2, __hi2); } +# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + string_type + transform(const _CharT* __lo, const _CharT* __hi) const + { return this->do_transform(__lo, __hi); } +# 750 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + long + hash(const _CharT* __lo, const _CharT* __hi) const + { return this->do_hash(__lo, __hi); } + + + int + _M_compare(const _CharT*, const _CharT*) const throw(); + + size_t + _M_transform(_CharT*, const _CharT*, size_t) const throw(); + + protected: + + virtual + ~collate() + { _S_destroy_c_locale(_M_c_locale_collate); } +# 779 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + virtual int + do_compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const; +# 793 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + virtual string_type + do_transform(const _CharT* __lo, const _CharT* __hi) const; +# 806 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 + virtual long + do_hash(const _CharT* __lo, const _CharT* __hi) const; + }; + + template + locale::id collate<_CharT>::id; + + + template<> + int + collate::_M_compare(const char*, const char*) const throw(); + + template<> + size_t + collate::_M_transform(char*, const char*, size_t) const throw(); + + + template<> + int + collate::_M_compare(const wchar_t*, const wchar_t*) const throw(); + + template<> + size_t + collate::_M_transform(wchar_t*, const wchar_t*, size_t) const throw(); + + + + template + class __cxx11:: collate_byname : public collate<_CharT> + { + public: + + + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + + explicit + collate_byname(const char* __s, size_t __refs = 0) + : collate<_CharT>(__refs) + { + if (__builtin_strcmp(__s, "C") != 0 + && __builtin_strcmp(__s, "POSIX") != 0) + { + this->_S_destroy_c_locale(this->_M_c_locale_collate); + this->_S_create_c_locale(this->_M_c_locale_collate, __s); + } + } + + + explicit + collate_byname(const string& __s, size_t __refs = 0) + : collate_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~collate_byname() { } + }; + + +} + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.tcc" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + locale:: + locale(const locale& __other, _Facet* __f) + { + _M_impl = new _Impl(*__other._M_impl, 1); + + try + { _M_impl->_M_install_facet(&_Facet::id, __f); } + catch(...) + { + _M_impl->_M_remove_reference(); + throw; + } + delete [] _M_impl->_M_names[0]; + _M_impl->_M_names[0] = 0; + } + + template + locale + locale:: + combine(const locale& __other) const + { + _Impl* __tmp = new _Impl(*_M_impl, 1); + try + { + __tmp->_M_replace_facet(__other._M_impl, &_Facet::id); + } + catch(...) + { + __tmp->_M_remove_reference(); + throw; + } + return locale(__tmp); + } + + template + bool + locale:: + operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1, + const basic_string<_CharT, _Traits, _Alloc>& __s2) const + { + typedef std::collate<_CharT> __collate_type; + const __collate_type& __collate = use_facet<__collate_type>(*this); + return (__collate.compare(__s1.data(), __s1.data() + __s1.length(), + __s2.data(), __s2.data() + __s2.length()) < 0); + } + + template + inline const _Facet* + __try_use_facet(const locale& __loc) noexcept + { + const size_t __i = _Facet::id._M_id(); + const locale::facet** __facets = __loc._M_impl->_M_facets; + + + + + + + + if constexpr (__is_same(_Facet, ctype)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, num_get)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, num_put)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, codecvt)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, collate)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, moneypunct)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, moneypunct)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, money_get)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, money_put)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, numpunct)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, time_get)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, time_put)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, messages)) return static_cast(__facets[__i]); + + + if constexpr (__is_same(_Facet, ctype)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, num_get)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, num_put)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, codecvt)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, collate)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, moneypunct)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, moneypunct)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, money_get)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, money_put)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, numpunct)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, time_get)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, time_put)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, messages)) return static_cast(__facets[__i]); + + + if constexpr (__is_same(_Facet, codecvt)) return static_cast(__facets[__i]); + if constexpr (__is_same(_Facet, codecvt)) return static_cast(__facets[__i]); + + + + + if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i]) + return 0; + + + return dynamic_cast(__facets[__i]); + + + + } +# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.tcc" 3 + template + inline bool + has_facet(const locale& __loc) throw() + { + + static_assert(__is_base_of(locale::facet, _Facet), + "template argument must be derived from locale::facet"); + + + + return std::__try_use_facet<_Facet>(__loc) != 0; + } +# 188 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.tcc" 3 +#pragma GCC diagnostic push + + template + inline const _Facet& + use_facet(const locale& __loc) + { + + static_assert(__is_base_of(locale::facet, _Facet), + "template argument must be derived from locale::facet"); + + + + if (const _Facet* __f = std::__try_use_facet<_Facet>(__loc)) + return *__f; + __throw_bad_cast(); + } +#pragma GCC diagnostic pop + + + + template + int + collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw () + { return 0; } + + + template + size_t + collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw () + { return 0; } + + template + int + collate<_CharT>:: + do_compare(const _CharT* __lo1, const _CharT* __hi1, + const _CharT* __lo2, const _CharT* __hi2) const + { + + + const string_type __one(__lo1, __hi1); + const string_type __two(__lo2, __hi2); + + const _CharT* __p = __one.c_str(); + const _CharT* __pend = __one.data() + __one.length(); + const _CharT* __q = __two.c_str(); + const _CharT* __qend = __two.data() + __two.length(); + + + + + for (;;) + { + const int __res = _M_compare(__p, __q); + if (__res) + return __res; + + __p += char_traits<_CharT>::length(__p); + __q += char_traits<_CharT>::length(__q); + if (__p == __pend && __q == __qend) + return 0; + else if (__p == __pend) + return -1; + else if (__q == __qend) + return 1; + + __p++; + __q++; + } + } + + template + typename collate<_CharT>::string_type + collate<_CharT>:: + do_transform(const _CharT* __lo, const _CharT* __hi) const + { + string_type __ret; + + + const string_type __str(__lo, __hi); + + const _CharT* __p = __str.c_str(); + const _CharT* __pend = __str.data() + __str.length(); + + size_t __len = (__hi - __lo) * 2; + + _CharT* __c = new _CharT[__len]; + + try + { + + + + for (;;) + { + + size_t __res = _M_transform(__c, __p, __len); + + + if (__res >= __len) + { + __len = __res + 1; + delete [] __c, __c = 0; + __c = new _CharT[__len]; + __res = _M_transform(__c, __p, __len); + } + + __ret.append(__c, __res); + __p += char_traits<_CharT>::length(__p); + if (__p == __pend) + break; + + __p++; + __ret.push_back(_CharT()); + } + } + catch(...) + { + delete [] __c; + throw; + } + + delete [] __c; + + return __ret; + } + + template + long + collate<_CharT>:: + do_hash(const _CharT* __lo, const _CharT* __hi) const + { + unsigned long __val = 0; + for (; __lo < __hi; ++__lo) + __val = + *__lo + ((__val << 7) + | (__val >> (__gnu_cxx::__numeric_traits:: + __digits - 7))); + return static_cast(__val); + } + + + + + extern template class collate; + extern template class collate_byname; + + extern template + const collate* + __try_use_facet >(const locale&) noexcept; + + extern template + const collate& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + extern template class collate; + extern template class collate_byname; + + extern template + const collate* + __try_use_facet >(const locale&) noexcept; + + extern template + const collate& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + + +} +# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 2 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + + + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/error_constants.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/error_constants.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/error_constants.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + enum class errc + { + address_family_not_supported = 97, + address_in_use = 98, + address_not_available = 99, + already_connected = 106, + argument_list_too_long = 7, + argument_out_of_domain = 33, + bad_address = 14, + bad_file_descriptor = 9, + + + bad_message = 74, + + + broken_pipe = 32, + connection_aborted = 103, + connection_already_in_progress = 114, + connection_refused = 111, + connection_reset = 104, + cross_device_link = 18, + destination_address_required = 89, + device_or_resource_busy = 16, + directory_not_empty = 39, + executable_format_error = 8, + file_exists = 17, + file_too_large = 27, + filename_too_long = 36, + function_not_supported = 38, + host_unreachable = 113, + + + identifier_removed = 43, + + + illegal_byte_sequence = 84, + inappropriate_io_control_operation = 25, + interrupted = 4, + invalid_argument = 22, + invalid_seek = 29, + io_error = 5, + is_a_directory = 21, + message_size = 90, + network_down = 100, + network_reset = 102, + network_unreachable = 101, + no_buffer_space = 105, + no_child_process = 10, + + + no_link = 67, + + + no_lock_available = 37, + + + no_message_available = 61, + + + no_message = 42, + no_protocol_option = 92, + no_space_on_device = 28, + + + no_stream_resources = 63, + + + no_such_device_or_address = 6, + no_such_device = 19, + no_such_file_or_directory = 2, + no_such_process = 3, + not_a_directory = 20, + not_a_socket = 88, + + + not_a_stream = 60, + + + not_connected = 107, + not_enough_memory = 12, + + + not_supported = 95, + + + + operation_canceled = 125, + + + operation_in_progress = 115, + operation_not_permitted = 1, + operation_not_supported = 95, + operation_would_block = 11, + + + owner_dead = 130, + + + permission_denied = 13, + + + protocol_error = 71, + + + protocol_not_supported = 93, + read_only_file_system = 30, + resource_deadlock_would_occur = 35, + resource_unavailable_try_again = 11, + result_out_of_range = 34, + + + state_not_recoverable = 131, + + + + stream_timeout = 62, + + + + text_file_busy = 26, + + + timed_out = 110, + too_many_files_open_in_system = 23, + too_many_files_open = 24, + too_many_links = 31, + too_many_symbolic_link_levels = 40, + + + value_too_large = 75, + + + + + wrong_protocol_type = 91 + }; + + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdexcept" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdexcept" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + struct __cow_string + { + union { + const char* _M_p; + char _M_bytes[sizeof(const char*)]; + }; + + __cow_string(); + __cow_string(const std::string&); + __cow_string(const char*, size_t); + __cow_string(const __cow_string&) noexcept; + __cow_string& operator=(const __cow_string&) noexcept; + ~__cow_string(); + + __cow_string(__cow_string&&) noexcept; + __cow_string& operator=(__cow_string&&) noexcept; + + }; + + typedef basic_string __sso_string; +# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdexcept" 3 + class logic_error : public exception + { + __cow_string _M_msg; + + public: + + explicit + logic_error(const string& __arg) ; + + + explicit + logic_error(const char*) ; + + logic_error(logic_error&&) noexcept; + logic_error& operator=(logic_error&&) noexcept; + + + + logic_error(const logic_error&) noexcept; + logic_error& operator=(const logic_error&) noexcept; + + + + + + virtual ~logic_error() noexcept; + + + + virtual const char* + what() const noexcept; + + + + + + }; + + + + class domain_error : public logic_error + { + public: + explicit domain_error(const string& __arg) ; + + explicit domain_error(const char*) ; + domain_error(const domain_error&) = default; + domain_error& operator=(const domain_error&) = default; + domain_error(domain_error&&) = default; + domain_error& operator=(domain_error&&) = default; + + virtual ~domain_error() noexcept; + }; + + + class invalid_argument : public logic_error + { + public: + explicit invalid_argument(const string& __arg) ; + + explicit invalid_argument(const char*) ; + invalid_argument(const invalid_argument&) = default; + invalid_argument& operator=(const invalid_argument&) = default; + invalid_argument(invalid_argument&&) = default; + invalid_argument& operator=(invalid_argument&&) = default; + + virtual ~invalid_argument() noexcept; + }; + + + + class length_error : public logic_error + { + public: + explicit length_error(const string& __arg) ; + + explicit length_error(const char*) ; + length_error(const length_error&) = default; + length_error& operator=(const length_error&) = default; + length_error(length_error&&) = default; + length_error& operator=(length_error&&) = default; + + virtual ~length_error() noexcept; + }; + + + + class out_of_range : public logic_error + { + public: + explicit out_of_range(const string& __arg) ; + + explicit out_of_range(const char*) ; + out_of_range(const out_of_range&) = default; + out_of_range& operator=(const out_of_range&) = default; + out_of_range(out_of_range&&) = default; + out_of_range& operator=(out_of_range&&) = default; + + virtual ~out_of_range() noexcept; + }; + + + + + + + class runtime_error : public exception + { + __cow_string _M_msg; + + public: + + explicit + runtime_error(const string& __arg) ; + + + explicit + runtime_error(const char*) ; + + runtime_error(runtime_error&&) noexcept; + runtime_error& operator=(runtime_error&&) noexcept; + + + + runtime_error(const runtime_error&) noexcept; + runtime_error& operator=(const runtime_error&) noexcept; + + + + + + virtual ~runtime_error() noexcept; + + + + virtual const char* + what() const noexcept; + + + + + + }; + + + class range_error : public runtime_error + { + public: + explicit range_error(const string& __arg) ; + + explicit range_error(const char*) ; + range_error(const range_error&) = default; + range_error& operator=(const range_error&) = default; + range_error(range_error&&) = default; + range_error& operator=(range_error&&) = default; + + virtual ~range_error() noexcept; + }; + + + class overflow_error : public runtime_error + { + public: + explicit overflow_error(const string& __arg) ; + + explicit overflow_error(const char*) ; + overflow_error(const overflow_error&) = default; + overflow_error& operator=(const overflow_error&) = default; + overflow_error(overflow_error&&) = default; + overflow_error& operator=(overflow_error&&) = default; + + virtual ~overflow_error() noexcept; + }; + + + class underflow_error : public runtime_error + { + public: + explicit underflow_error(const string& __arg) ; + + explicit underflow_error(const char*) ; + underflow_error(const underflow_error&) = default; + underflow_error& operator=(const underflow_error&) = default; + underflow_error(underflow_error&&) = default; + underflow_error& operator=(underflow_error&&) = default; + + virtual ~underflow_error() noexcept; + }; + + + + +} +# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 2 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + class error_code; + class error_condition; + class system_error; + + + template + struct is_error_code_enum : public false_type { }; + + + template + struct is_error_condition_enum : public false_type { }; + + template<> + struct is_error_condition_enum + : public true_type { }; + + + template + inline constexpr bool is_error_code_enum_v = + is_error_code_enum<_Tp>::value; + template + inline constexpr bool is_error_condition_enum_v = + is_error_condition_enum<_Tp>::value; + + + +inline namespace _V2 { +# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + class error_category + { + public: + constexpr error_category() noexcept = default; + + virtual ~error_category(); + + error_category(const error_category&) = delete; + error_category& operator=(const error_category&) = delete; + + + virtual const char* + name() const noexcept = 0; + + + + + + + private: + __attribute ((__abi_tag__ ("cxx11"))) + virtual __cow_string + _M_message(int) const; + + public: + + __attribute ((__abi_tag__ ("cxx11"))) + virtual string + message(int) const = 0; +# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + public: + + virtual error_condition + default_error_condition(int __i) const noexcept; + + + virtual bool + equivalent(int __i, const error_condition& __cond) const noexcept; + + + virtual bool + equivalent(const error_code& __code, int __i) const noexcept; + + + [[__nodiscard__]] + bool + operator==(const error_category& __other) const noexcept + { return this == &__other; } +# 170 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + bool + operator<(const error_category& __other) const noexcept + { return less()(this, &__other); } + + bool + operator!=(const error_category& __other) const noexcept + { return this != &__other; } + + }; + + + + + [[__nodiscard__, __gnu__::__const__]] + const error_category& + generic_category() noexcept; + + + [[__nodiscard__, __gnu__::__const__]] + const error_category& + system_category() noexcept; + + + +} + + + + + +namespace __adl_only +{ + void make_error_code() = delete; + void make_error_condition() = delete; +} +# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + class error_code + { + template + using _Check + = __enable_if_t::value>; + + public: + error_code() noexcept + : _M_value(0), _M_cat(&system_category()) { } + + error_code(int __v, const error_category& __cat) noexcept + : _M_value(__v), _M_cat(&__cat) { } + + + template> + error_code(_ErrorCodeEnum __e) noexcept + { + using __adl_only::make_error_code; + *this = make_error_code(__e); + } + + error_code(const error_code&) = default; + error_code& operator=(const error_code&) = default; + + void + assign(int __v, const error_category& __cat) noexcept + { + _M_value = __v; + _M_cat = &__cat; + } + + void + clear() noexcept + { assign(0, system_category()); } + + + [[__nodiscard__]] + int + value() const noexcept { return _M_value; } + + + [[__nodiscard__]] + const error_category& + category() const noexcept { return *_M_cat; } + + + error_condition + default_error_condition() const noexcept; + + + __attribute ((__abi_tag__ ("cxx11"))) + string + message() const + { return category().message(value()); } + + + [[__nodiscard__]] + explicit operator bool() const noexcept + { return _M_value != 0; } + + + private: + int _M_value; + const error_category* _M_cat; + }; +# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + [[__nodiscard__]] + inline error_code + make_error_code(errc __e) noexcept + { return error_code(static_cast(__e), generic_category()); } +# 323 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + inline bool + operator<(const error_code& __lhs, const error_code& __rhs) noexcept + { + return (__lhs.category() < __rhs.category() + || (__lhs.category() == __rhs.category() + && __lhs.value() < __rhs.value())); + } + + + + + + + + template + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e) + { return (__os << __e.category().name() << ':' << __e.value()); } +# 354 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + class error_condition + { + template + using _Check + = __enable_if_t::value>; + + public: + + error_condition() noexcept + : _M_value(0), _M_cat(&generic_category()) { } + + + error_condition(int __v, const error_category& __cat) noexcept + : _M_value(__v), _M_cat(&__cat) { } + + + template> + error_condition(_ErrorConditionEnum __e) noexcept + { + using __adl_only::make_error_condition; + *this = make_error_condition(__e); + } + + error_condition(const error_condition&) = default; + error_condition& operator=(const error_condition&) = default; + + + void + assign(int __v, const error_category& __cat) noexcept + { + _M_value = __v; + _M_cat = &__cat; + } + + + void + clear() noexcept + { assign(0, generic_category()); } + + + + + [[__nodiscard__]] + int + value() const noexcept { return _M_value; } + + + [[__nodiscard__]] + const error_category& + category() const noexcept { return *_M_cat; } + + + __attribute ((__abi_tag__ ("cxx11"))) + string + message() const + { return category().message(value()); } + + + [[__nodiscard__]] + explicit operator bool() const noexcept + { return _M_value != 0; } + + + private: + int _M_value; + const error_category* _M_cat; + }; +# 433 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + [[__nodiscard__]] + inline error_condition + make_error_condition(errc __e) noexcept + { return error_condition(static_cast(__e), generic_category()); } +# 447 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + [[__nodiscard__]] + inline bool + operator==(const error_code& __lhs, const error_code& __rhs) noexcept + { + return __lhs.category() == __rhs.category() + && __lhs.value() == __rhs.value(); + } +# 463 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + [[__nodiscard__]] + inline bool + operator==(const error_code& __lhs, const error_condition& __rhs) noexcept + { + return __lhs.category().equivalent(__lhs.value(), __rhs) + || __rhs.category().equivalent(__lhs, __rhs.value()); + } +# 478 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + [[__nodiscard__]] + inline bool + operator==(const error_condition& __lhs, + const error_condition& __rhs) noexcept + { + return __lhs.category() == __rhs.category() + && __lhs.value() == __rhs.value(); + } +# 506 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + inline bool + operator<(const error_condition& __lhs, + const error_condition& __rhs) noexcept + { + return (__lhs.category() < __rhs.category() + || (__lhs.category() == __rhs.category() + && __lhs.value() < __rhs.value())); + } + + + inline bool + operator==(const error_condition& __lhs, const error_code& __rhs) noexcept + { + return (__rhs.category().equivalent(__rhs.value(), __lhs) + || __lhs.category().equivalent(__rhs, __lhs.value())); + } + + + inline bool + operator!=(const error_code& __lhs, const error_code& __rhs) noexcept + { return !(__lhs == __rhs); } + + + inline bool + operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept + { return !(__lhs == __rhs); } + + + inline bool + operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept + { return !(__lhs == __rhs); } + + + inline bool + operator!=(const error_condition& __lhs, + const error_condition& __rhs) noexcept + { return !(__lhs == __rhs); } +# 556 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 + class system_error : public std::runtime_error + { + private: + error_code _M_code; + + public: + system_error(error_code __ec = error_code()) + : runtime_error(__ec.message()), _M_code(__ec) { } + + system_error(error_code __ec, const string& __what) + : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { } + + system_error(error_code __ec, const char* __what) + : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } + + system_error(int __v, const error_category& __ecat, const char* __what) + : system_error(error_code(__v, __ecat), __what) { } + + system_error(int __v, const error_category& __ecat) + : runtime_error(error_code(__v, __ecat).message()), + _M_code(__v, __ecat) { } + + system_error(int __v, const error_category& __ecat, const string& __what) + : runtime_error(__what + ": " + error_code(__v, __ecat).message()), + _M_code(__v, __ecat) { } + + + system_error (const system_error &) = default; + system_error &operator= (const system_error &) = default; + + + virtual ~system_error() noexcept; + + const error_code& + code() const noexcept { return _M_code; } + }; + + +} + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template<> + struct hash + : public __hash_base + { + size_t + operator()(const error_code& __e) const noexcept + { + const size_t __tmp = std::_Hash_impl::hash(__e.value()); + return std::_Hash_impl::__hash_combine(&__e.category(), __tmp); + } + }; + + + + + + + template<> + struct hash + : public __hash_base + { + size_t + operator()(const error_condition& __e) const noexcept + { + const size_t __tmp = std::_Hash_impl::hash(__e.value()); + return std::_Hash_impl::__hash_combine(&__e.category(), __tmp); + } + }; + + + +} +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + enum _Ios_Fmtflags + { + _S_boolalpha = 1L << 0, + _S_dec = 1L << 1, + _S_fixed = 1L << 2, + _S_hex = 1L << 3, + _S_internal = 1L << 4, + _S_left = 1L << 5, + _S_oct = 1L << 6, + _S_right = 1L << 7, + _S_scientific = 1L << 8, + _S_showbase = 1L << 9, + _S_showpoint = 1L << 10, + _S_showpos = 1L << 11, + _S_skipws = 1L << 12, + _S_unitbuf = 1L << 13, + _S_uppercase = 1L << 14, + _S_adjustfield = _S_left | _S_right | _S_internal, + _S_basefield = _S_dec | _S_oct | _S_hex, + _S_floatfield = _S_scientific | _S_fixed, + _S_ios_fmtflags_end = 1L << 16, + _S_ios_fmtflags_max = 2147483647, + _S_ios_fmtflags_min = ~2147483647 + }; + + inline constexpr _Ios_Fmtflags + operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); } + + inline constexpr _Ios_Fmtflags + operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); } + + inline constexpr _Ios_Fmtflags + operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) + { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); } + + inline constexpr _Ios_Fmtflags + operator~(_Ios_Fmtflags __a) + { return _Ios_Fmtflags(~static_cast(__a)); } + + inline const _Ios_Fmtflags& + operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a = __a | __b; } + + inline const _Ios_Fmtflags& + operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a = __a & __b; } + + inline const _Ios_Fmtflags& + operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) + { return __a = __a ^ __b; } + + + enum _Ios_Openmode + { + _S_app = 1L << 0, + _S_ate = 1L << 1, + _S_bin = 1L << 2, + _S_in = 1L << 3, + _S_out = 1L << 4, + _S_trunc = 1L << 5, + _S_noreplace = 1L << 6, + _S_ios_openmode_end = 1L << 16, + _S_ios_openmode_max = 2147483647, + _S_ios_openmode_min = ~2147483647 + }; + + inline constexpr _Ios_Openmode + operator&(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); } + + inline constexpr _Ios_Openmode + operator|(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); } + + inline constexpr _Ios_Openmode + operator^(_Ios_Openmode __a, _Ios_Openmode __b) + { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); } + + inline constexpr _Ios_Openmode + operator~(_Ios_Openmode __a) + { return _Ios_Openmode(~static_cast(__a)); } + + inline const _Ios_Openmode& + operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a = __a | __b; } + + inline const _Ios_Openmode& + operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a = __a & __b; } + + inline const _Ios_Openmode& + operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) + { return __a = __a ^ __b; } + + + enum _Ios_Iostate + { + _S_goodbit = 0, + _S_badbit = 1L << 0, + _S_eofbit = 1L << 1, + _S_failbit = 1L << 2, + _S_ios_iostate_end = 1L << 16, + _S_ios_iostate_max = 2147483647, + _S_ios_iostate_min = ~2147483647 + }; + + inline constexpr _Ios_Iostate + operator&(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); } + + inline constexpr _Ios_Iostate + operator|(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); } + + inline constexpr _Ios_Iostate + operator^(_Ios_Iostate __a, _Ios_Iostate __b) + { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); } + + inline constexpr _Ios_Iostate + operator~(_Ios_Iostate __a) + { return _Ios_Iostate(~static_cast(__a)); } + + inline const _Ios_Iostate& + operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a = __a | __b; } + + inline const _Ios_Iostate& + operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a = __a & __b; } + + inline const _Ios_Iostate& + operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) + { return __a = __a ^ __b; } + + + enum _Ios_Seekdir + { + _S_beg = 0, + _S_cur = 1, + _S_end = 2, + _S_ios_seekdir_end = 1L << 16 + }; + + + + enum class io_errc { stream = 1 }; + + template <> struct is_error_code_enum : public true_type { }; + + [[__nodiscard__, __gnu__::__const__]] + const error_category& + iostream_category() noexcept; + + [[__nodiscard__]] + inline error_code + make_error_code(io_errc __e) noexcept + { return error_code(static_cast(__e), iostream_category()); } + + [[__nodiscard__]] + inline error_condition + make_error_condition(io_errc __e) noexcept + { return error_condition(static_cast(__e), iostream_category()); } +# 233 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + class ios_base + { +# 251 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + public: +# 260 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error + { + public: + explicit + failure(const string& __str); + + + explicit + failure(const string&, const error_code&); + + explicit + failure(const char*, const error_code& = io_errc::stream); + + + virtual + ~failure() throw(); + + virtual const char* + what() const throw(); + }; +# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + typedef _Ios_Fmtflags fmtflags; + + + static const fmtflags boolalpha = _S_boolalpha; + + + static const fmtflags dec = _S_dec; + + + static const fmtflags fixed = _S_fixed; + + + static const fmtflags hex = _S_hex; + + + + + static const fmtflags internal = _S_internal; + + + + static const fmtflags left = _S_left; + + + static const fmtflags oct = _S_oct; + + + + static const fmtflags right = _S_right; + + + static const fmtflags scientific = _S_scientific; + + + + static const fmtflags showbase = _S_showbase; + + + + static const fmtflags showpoint = _S_showpoint; + + + static const fmtflags showpos = _S_showpos; + + + static const fmtflags skipws = _S_skipws; + + + static const fmtflags unitbuf = _S_unitbuf; + + + + static const fmtflags uppercase = _S_uppercase; + + + static const fmtflags adjustfield = _S_adjustfield; + + + static const fmtflags basefield = _S_basefield; + + + static const fmtflags floatfield = _S_floatfield; +# 421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + typedef _Ios_Iostate iostate; + + + + static const iostate badbit = _S_badbit; + + + static const iostate eofbit = _S_eofbit; + + + + + static const iostate failbit = _S_failbit; + + + static const iostate goodbit = _S_goodbit; +# 452 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + typedef _Ios_Openmode openmode; + + + static const openmode app = _S_app; + + + static const openmode ate = _S_ate; + + + + + static const openmode binary = _S_bin; + + + static const openmode in = _S_in; + + + static const openmode out = _S_out; + + + static const openmode trunc = _S_trunc; + + static const openmode __noreplace = _S_noreplace; +# 492 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + typedef _Ios_Seekdir seekdir; + + + static const seekdir beg = _S_beg; + + + static const seekdir cur = _S_cur; + + + static const seekdir end = _S_end; +# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + enum event + { + erase_event, + imbue_event, + copyfmt_event + }; +# 542 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + typedef void (*event_callback) (event __e, ios_base& __b, int __i); +# 554 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + void + register_callback(event_callback __fn, int __index); + + protected: + streamsize _M_precision; + streamsize _M_width; + fmtflags _M_flags; + iostate _M_exception; + iostate _M_streambuf_state; + + + + struct _Callback_list + { + + _Callback_list* _M_next; + ios_base::event_callback _M_fn; + int _M_index; + _Atomic_word _M_refcount; + + _Callback_list(ios_base::event_callback __fn, int __index, + _Callback_list* __cb) + : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { } + + void + _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } + + + int + _M_remove_reference() + { + + ; + int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); + if (__res == 0) + { + ; + } + return __res; + } + }; + + _Callback_list* _M_callbacks; + + void + _M_call_callbacks(event __ev) throw(); + + void + _M_dispose_callbacks(void) throw(); + + + struct _Words + { + void* _M_pword; + long _M_iword; + _Words() : _M_pword(0), _M_iword(0) { } + }; + + + _Words _M_word_zero; + + + + enum { _S_local_word_size = 8 }; + _Words _M_local_word[_S_local_word_size]; + + + int _M_word_size; + _Words* _M_word; + + _Words& + _M_grow_words(int __index, bool __iword); + + + locale _M_ios_locale; + + void + _M_init() throw(); + + public: + + + + + + class Init + { + friend class ios_base; + public: + Init(); + ~Init(); + + + Init(const Init&) = default; + Init& operator=(const Init&) = default; + + + private: + static _Atomic_word _S_refcount; + static bool _S_synced_with_stdio; + }; + + + + + + + fmtflags + flags() const + { return _M_flags; } +# 672 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + fmtflags + flags(fmtflags __fmtfl) + { + fmtflags __old = _M_flags; + _M_flags = __fmtfl; + return __old; + } +# 688 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + fmtflags + setf(fmtflags __fmtfl) + { + fmtflags __old = _M_flags; + _M_flags |= __fmtfl; + return __old; + } +# 705 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + fmtflags + setf(fmtflags __fmtfl, fmtflags __mask) + { + fmtflags __old = _M_flags; + _M_flags &= ~__mask; + _M_flags |= (__fmtfl & __mask); + return __old; + } + + + + + + + + void + unsetf(fmtflags __mask) + { _M_flags &= ~__mask; } +# 731 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + streamsize + precision() const + { return _M_precision; } + + + + + + + streamsize + precision(streamsize __prec) + { + streamsize __old = _M_precision; + _M_precision = __prec; + return __old; + } + + + + + + + + streamsize + width() const + { return _M_width; } + + + + + + + streamsize + width(streamsize __wide) + { + streamsize __old = _M_width; + _M_width = __wide; + return __old; + } +# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + static bool + sync_with_stdio(bool __sync = true); +# 794 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + locale + imbue(const locale& __loc) throw(); +# 805 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + locale + getloc() const + { return _M_ios_locale; } +# 816 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + const locale& + _M_getloc() const + { return _M_ios_locale; } +# 835 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + static int + xalloc() throw(); +# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + long& + iword(int __ix) + { + _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size) + ? _M_word[__ix] : _M_grow_words(__ix, true); + return __word._M_iword; + } +# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + void*& + pword(int __ix) + { + _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size) + ? _M_word[__ix] : _M_grow_words(__ix, false); + return __word._M_pword; + } +# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + virtual ~ios_base(); + + protected: + ios_base() throw (); +# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 + public: + ios_base(const ios_base&) = delete; + + ios_base& + operator=(const ios_base&) = delete; + + protected: + void + _M_move(ios_base&) noexcept; + + void + _M_swap(ios_base& __rhs) noexcept; + + }; + + + + inline ios_base& + boolalpha(ios_base& __base) + { + __base.setf(ios_base::boolalpha); + return __base; + } + + + inline ios_base& + noboolalpha(ios_base& __base) + { + __base.unsetf(ios_base::boolalpha); + return __base; + } + + + inline ios_base& + showbase(ios_base& __base) + { + __base.setf(ios_base::showbase); + return __base; + } + + + inline ios_base& + noshowbase(ios_base& __base) + { + __base.unsetf(ios_base::showbase); + return __base; + } + + + inline ios_base& + showpoint(ios_base& __base) + { + __base.setf(ios_base::showpoint); + return __base; + } + + + inline ios_base& + noshowpoint(ios_base& __base) + { + __base.unsetf(ios_base::showpoint); + return __base; + } + + + inline ios_base& + showpos(ios_base& __base) + { + __base.setf(ios_base::showpos); + return __base; + } + + + inline ios_base& + noshowpos(ios_base& __base) + { + __base.unsetf(ios_base::showpos); + return __base; + } + + + inline ios_base& + skipws(ios_base& __base) + { + __base.setf(ios_base::skipws); + return __base; + } + + + inline ios_base& + noskipws(ios_base& __base) + { + __base.unsetf(ios_base::skipws); + return __base; + } + + + inline ios_base& + uppercase(ios_base& __base) + { + __base.setf(ios_base::uppercase); + return __base; + } + + + inline ios_base& + nouppercase(ios_base& __base) + { + __base.unsetf(ios_base::uppercase); + return __base; + } + + + inline ios_base& + unitbuf(ios_base& __base) + { + __base.setf(ios_base::unitbuf); + return __base; + } + + + inline ios_base& + nounitbuf(ios_base& __base) + { + __base.unsetf(ios_base::unitbuf); + return __base; + } + + + + inline ios_base& + internal(ios_base& __base) + { + __base.setf(ios_base::internal, ios_base::adjustfield); + return __base; + } + + + inline ios_base& + left(ios_base& __base) + { + __base.setf(ios_base::left, ios_base::adjustfield); + return __base; + } + + + inline ios_base& + right(ios_base& __base) + { + __base.setf(ios_base::right, ios_base::adjustfield); + return __base; + } + + + + inline ios_base& + dec(ios_base& __base) + { + __base.setf(ios_base::dec, ios_base::basefield); + return __base; + } + + + inline ios_base& + hex(ios_base& __base) + { + __base.setf(ios_base::hex, ios_base::basefield); + return __base; + } + + + inline ios_base& + oct(ios_base& __base) + { + __base.setf(ios_base::oct, ios_base::basefield); + return __base; + } + + + + inline ios_base& + fixed(ios_base& __base) + { + __base.setf(ios_base::fixed, ios_base::floatfield); + return __base; + } + + + inline ios_base& + scientific(ios_base& __base) + { + __base.setf(ios_base::scientific, ios_base::floatfield); + return __base; + } + + + + + + + inline ios_base& + hexfloat(ios_base& __base) + { + __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield); + return __base; + } + + + inline ios_base& + defaultfloat(ios_base& __base) + { + __base.unsetf(ios_base::floatfield); + return __base; + } + + + +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + streamsize + __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, + basic_streambuf<_CharT, _Traits>*, bool&); +# 123 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + template + class basic_streambuf + { + public: + + + + + + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + + + + typedef basic_streambuf __streambuf_type; + + + friend class basic_ios; + friend class basic_istream; + friend class basic_ostream; + friend class istreambuf_iterator; + friend class ostreambuf_iterator; + + friend streamsize + __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + _CharT2*>::__type + __copy_move_a2(istreambuf_iterator<_CharT2>, + istreambuf_iterator<_CharT2>, _CharT2*); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + istreambuf_iterator<_CharT2> >::__type + find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + const _CharT2&); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + void>::__type + advance(istreambuf_iterator<_CharT2>&, _Distance); + + friend void __istream_extract(istream&, char*, streamsize); + + template + friend basic_istream<_CharT2, _Traits2>& + operator>>(basic_istream<_CharT2, _Traits2>&, + basic_string<_CharT2, _Traits2, _Alloc>&); + + template + friend basic_istream<_CharT2, _Traits2>& + getline(basic_istream<_CharT2, _Traits2>&, + basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); + + protected: + + + + + + + + char_type* _M_in_beg; + char_type* _M_in_cur; + char_type* _M_in_end; + char_type* _M_out_beg; + char_type* _M_out_cur; + char_type* _M_out_end; + + + locale _M_buf_locale; + + public: + + virtual + ~basic_streambuf() + { } +# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + locale + pubimbue(const locale& __loc) + { + locale __tmp(this->getloc()); + this->imbue(__loc); + _M_buf_locale = __loc; + return __tmp; + } +# 232 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + locale + getloc() const + { return _M_buf_locale; } +# 245 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + basic_streambuf* + pubsetbuf(char_type* __s, streamsize __n) + { return this->setbuf(__s, __n); } +# 257 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + pos_type + pubseekoff(off_type __off, ios_base::seekdir __way, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { return this->seekoff(__off, __way, __mode); } +# 269 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + pos_type + pubseekpos(pos_type __sp, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { return this->seekpos(__sp, __mode); } + + + + + int + pubsync() { return this->sync(); } +# 290 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + streamsize + in_avail() + { + const streamsize __ret = this->egptr() - this->gptr(); + return __ret ? __ret : this->showmanyc(); + } +# 304 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + int_type + snextc() + { + int_type __ret = traits_type::eof(); + if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), + __ret), true)) + __ret = this->sgetc(); + return __ret; + } +# 322 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + int_type + sbumpc() + { + int_type __ret; + if (__builtin_expect(this->gptr() < this->egptr(), true)) + { + __ret = traits_type::to_int_type(*this->gptr()); + this->gbump(1); + } + else + __ret = this->uflow(); + return __ret; + } +# 344 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + int_type + sgetc() + { + int_type __ret; + if (__builtin_expect(this->gptr() < this->egptr(), true)) + __ret = traits_type::to_int_type(*this->gptr()); + else + __ret = this->underflow(); + return __ret; + } +# 363 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + streamsize + sgetn(char_type* __s, streamsize __n) + { return this->xsgetn(__s, __n); } +# 378 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + int_type + sputbackc(char_type __c) + { + int_type __ret; + const bool __testpos = this->eback() < this->gptr(); + if (__builtin_expect(!__testpos || + !traits_type::eq(__c, this->gptr()[-1]), false)) + __ret = this->pbackfail(traits_type::to_int_type(__c)); + else + { + this->gbump(-1); + __ret = traits_type::to_int_type(*this->gptr()); + } + return __ret; + } +# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + int_type + sungetc() + { + int_type __ret; + if (__builtin_expect(this->eback() < this->gptr(), true)) + { + this->gbump(-1); + __ret = traits_type::to_int_type(*this->gptr()); + } + else + __ret = this->pbackfail(); + return __ret; + } +# 430 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + int_type + sputc(char_type __c) + { + int_type __ret; + if (__builtin_expect(this->pptr() < this->epptr(), true)) + { + *this->pptr() = __c; + this->pbump(1); + __ret = traits_type::to_int_type(__c); + } + else + __ret = this->overflow(traits_type::to_int_type(__c)); + return __ret; + } +# 456 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + streamsize + sputn(const char_type* __s, streamsize __n) + { return this->xsputn(__s, __n); } + + protected: +# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + basic_streambuf() + : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), + _M_out_beg(0), _M_out_cur(0), _M_out_end(0), + _M_buf_locale(locale()) + { } +# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + char_type* + eback() const { return _M_in_beg; } + + char_type* + gptr() const { return _M_in_cur; } + + char_type* + egptr() const { return _M_in_end; } +# 504 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + void + gbump(int __n) { _M_in_cur += __n; } +# 515 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + void + setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) + { + _M_in_beg = __gbeg; + _M_in_cur = __gnext; + _M_in_end = __gend; + } +# 535 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + char_type* + pbase() const { return _M_out_beg; } + + char_type* + pptr() const { return _M_out_cur; } + + char_type* + epptr() const { return _M_out_end; } +# 551 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + void + pbump(int __n) { _M_out_cur += __n; } +# 561 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + void + setp(char_type* __pbeg, char_type* __pend) + { + _M_out_beg = _M_out_cur = __pbeg; + _M_out_end = __pend; + } +# 582 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual void + imbue(const locale& __loc __attribute__ ((__unused__))) + { } +# 597 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual basic_streambuf* + setbuf(char_type*, streamsize) + { return this; } +# 608 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual pos_type + seekoff(off_type, ios_base::seekdir, + ios_base::openmode = ios_base::in | ios_base::out) + { return pos_type(off_type(-1)); } +# 620 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual pos_type + seekpos(pos_type, + ios_base::openmode = ios_base::in | ios_base::out) + { return pos_type(off_type(-1)); } +# 633 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual int + sync() { return 0; } +# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual streamsize + showmanyc() { return 0; } +# 671 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual streamsize + xsgetn(char_type* __s, streamsize __n); +# 693 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual int_type + underflow() + { return traits_type::eof(); } +# 706 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual int_type + uflow() + { + int_type __ret = traits_type::eof(); + const bool __testeof = traits_type::eq_int_type(this->underflow(), + __ret); + if (!__testeof) + { + __ret = traits_type::to_int_type(*this->gptr()); + this->gbump(1); + } + return __ret; + } +# 730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual int_type + pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof()) + { return traits_type::eof(); } +# 748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual streamsize + xsputn(const char_type* __s, streamsize __n); +# 774 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + virtual int_type + overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof()) + { return traits_type::eof(); } +# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 + void + __safe_gbump(streamsize __n) { _M_in_cur += __n; } + + void + __safe_pbump(streamsize __n) { _M_out_cur += __n; } + + + + + protected: + + basic_streambuf(const basic_streambuf&); + + basic_streambuf& + operator=(const basic_streambuf&); + + + void + swap(basic_streambuf& __sb) + { + std::swap(_M_in_beg, __sb._M_in_beg); + std::swap(_M_in_cur, __sb._M_in_cur); + std::swap(_M_in_end, __sb._M_in_end); + std::swap(_M_out_beg, __sb._M_out_beg); + std::swap(_M_out_cur, __sb._M_out_cur); + std::swap(_M_out_end, __sb._M_out_end); + std::swap(_M_buf_locale, __sb._M_buf_locale); + } + + }; + + + template + std::basic_streambuf<_CharT, _Traits>:: + basic_streambuf(const basic_streambuf&) = default; + + template + std::basic_streambuf<_CharT, _Traits>& + std::basic_streambuf<_CharT, _Traits>:: + operator=(const basic_streambuf&) = default; + + + + template<> + streamsize + __copy_streambufs_eof(basic_streambuf* __sbin, + basic_streambuf* __sbout, bool& __ineof); + + template<> + streamsize + __copy_streambufs_eof(basic_streambuf* __sbin, + basic_streambuf* __sbout, bool& __ineof); + + + + + +} + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf.tcc" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + streamsize + basic_streambuf<_CharT, _Traits>:: + xsgetn(char_type* __s, streamsize __n) + { + streamsize __ret = 0; + while (__ret < __n) + { + const streamsize __buf_len = this->egptr() - this->gptr(); + if (__buf_len) + { + const streamsize __remaining = __n - __ret; + const streamsize __len = std::min(__buf_len, __remaining); + traits_type::copy(__s, this->gptr(), __len); + __ret += __len; + __s += __len; + this->__safe_gbump(__len); + } + + if (__ret < __n) + { + const int_type __c = this->uflow(); + if (!traits_type::eq_int_type(__c, traits_type::eof())) + { + traits_type::assign(*__s++, traits_type::to_char_type(__c)); + ++__ret; + } + else + break; + } + } + return __ret; + } + + template + streamsize + basic_streambuf<_CharT, _Traits>:: + xsputn(const char_type* __s, streamsize __n) + { + streamsize __ret = 0; + while (__ret < __n) + { + const streamsize __buf_len = this->epptr() - this->pptr(); + if (__buf_len) + { + const streamsize __remaining = __n - __ret; + const streamsize __len = std::min(__buf_len, __remaining); + traits_type::copy(this->pptr(), __s, __len); + __ret += __len; + __s += __len; + this->__safe_pbump(__len); + } + + if (__ret < __n) + { + int_type __c = this->overflow(traits_type::to_int_type(*__s)); + if (!traits_type::eq_int_type(__c, traits_type::eof())) + { + ++__ret; + ++__s; + } + else + break; + } + } + return __ret; + } + + + + + template + streamsize + __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin, + basic_streambuf<_CharT, _Traits>* __sbout, + bool& __ineof) + { + streamsize __ret = 0; + __ineof = true; + typename _Traits::int_type __c = __sbin->sgetc(); + while (!_Traits::eq_int_type(__c, _Traits::eof())) + { + __c = __sbout->sputc(_Traits::to_char_type(__c)); + if (_Traits::eq_int_type(__c, _Traits::eof())) + { + __ineof = false; + break; + } + ++__ret; + __c = __sbin->snextc(); + } + return __ret; + } + + template + inline streamsize + __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin, + basic_streambuf<_CharT, _Traits>* __sbout) + { + bool __ineof; + return __copy_streambufs_eof(__sbin, __sbout, __ineof); + } + + + + + extern template class basic_streambuf; + + extern template + streamsize + __copy_streambufs(basic_streambuf*, + basic_streambuf*); + + + extern template class basic_streambuf; + + extern template + streamsize + __copy_streambufs(basic_streambuf*, + basic_streambuf*); + + + + +} +# 861 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 2 3 +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 3 +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 3 +# 1 "/usr/include/wctype.h" 1 3 4 +# 38 "/usr/include/wctype.h" 3 4 +# 1 "/usr/include/bits/wctype-wchar.h" 1 3 4 +# 38 "/usr/include/bits/wctype-wchar.h" 3 4 +typedef unsigned long int wctype_t; +# 56 "/usr/include/bits/wctype-wchar.h" 3 4 +enum +{ + __ISwupper = 0, + __ISwlower = 1, + __ISwalpha = 2, + __ISwdigit = 3, + __ISwxdigit = 4, + __ISwspace = 5, + __ISwprint = 6, + __ISwgraph = 7, + __ISwblank = 8, + __ISwcntrl = 9, + __ISwpunct = 10, + __ISwalnum = 11, + + _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))), + _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))), + _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))), + _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))), + _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))), + _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))), + _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))), + _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))), + _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))), + _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))), + _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))), + _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24)))) +}; + + + +extern "C" { + + + + + + + +extern int iswalnum (wint_t __wc) noexcept (true); + + + + + +extern int iswalpha (wint_t __wc) noexcept (true); + + +extern int iswcntrl (wint_t __wc) noexcept (true); + + + +extern int iswdigit (wint_t __wc) noexcept (true); + + + +extern int iswgraph (wint_t __wc) noexcept (true); + + + + +extern int iswlower (wint_t __wc) noexcept (true); + + +extern int iswprint (wint_t __wc) noexcept (true); + + + + +extern int iswpunct (wint_t __wc) noexcept (true); + + + + +extern int iswspace (wint_t __wc) noexcept (true); + + + + +extern int iswupper (wint_t __wc) noexcept (true); + + + + +extern int iswxdigit (wint_t __wc) noexcept (true); + + + + + +extern int iswblank (wint_t __wc) noexcept (true); +# 155 "/usr/include/bits/wctype-wchar.h" 3 4 +extern wctype_t wctype (const char *__property) noexcept (true); + + + +extern int iswctype (wint_t __wc, wctype_t __desc) noexcept (true); + + + + + + +extern wint_t towlower (wint_t __wc) noexcept (true); + + +extern wint_t towupper (wint_t __wc) noexcept (true); + +} +# 39 "/usr/include/wctype.h" 2 3 4 + + + + + +extern "C" { + + + +typedef const __int32_t *wctrans_t; + + + +extern wctrans_t wctrans (const char *__property) noexcept (true); + + +extern wint_t towctrans (wint_t __wc, wctrans_t __desc) noexcept (true); + + + + + + + +extern int iswalnum_l (wint_t __wc, locale_t __locale) noexcept (true); + + + + + +extern int iswalpha_l (wint_t __wc, locale_t __locale) noexcept (true); + + +extern int iswcntrl_l (wint_t __wc, locale_t __locale) noexcept (true); + + + +extern int iswdigit_l (wint_t __wc, locale_t __locale) noexcept (true); + + + +extern int iswgraph_l (wint_t __wc, locale_t __locale) noexcept (true); + + + + +extern int iswlower_l (wint_t __wc, locale_t __locale) noexcept (true); + + +extern int iswprint_l (wint_t __wc, locale_t __locale) noexcept (true); + + + + +extern int iswpunct_l (wint_t __wc, locale_t __locale) noexcept (true); + + + + +extern int iswspace_l (wint_t __wc, locale_t __locale) noexcept (true); + + + + +extern int iswupper_l (wint_t __wc, locale_t __locale) noexcept (true); + + + + +extern int iswxdigit_l (wint_t __wc, locale_t __locale) noexcept (true); + + + + +extern int iswblank_l (wint_t __wc, locale_t __locale) noexcept (true); + + + +extern wctype_t wctype_l (const char *__property, locale_t __locale) + noexcept (true); + + + +extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale) + noexcept (true); + + + + + + +extern wint_t towlower_l (wint_t __wc, locale_t __locale) noexcept (true); + + +extern wint_t towupper_l (wint_t __wc, locale_t __locale) noexcept (true); + + + +extern wctrans_t wctrans_l (const char *__property, locale_t __locale) + noexcept (true); + + +extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc, + locale_t __locale) noexcept (true); + + + +} +# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 2 3 +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 3 +namespace std +{ + using ::wctrans_t; + using ::wctype_t; + using ::wint_t; + + using ::iswalnum; + using ::iswalpha; + + using ::iswblank; + + using ::iswcntrl; + using ::iswctype; + using ::iswdigit; + using ::iswgraph; + using ::iswlower; + using ::iswprint; + using ::iswpunct; + using ::iswspace; + using ::iswupper; + using ::iswxdigit; + using ::towctrans; + using ::towlower; + using ::towupper; + using ::wctrans; + using ::wctype; +} +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 3 +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/ctype_base.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + struct ctype_base + { + + typedef const int* __to_type; + + + + typedef unsigned short mask; + static const mask upper = _ISupper; + static const mask lower = _ISlower; + static const mask alpha = _ISalpha; + static const mask digit = _ISdigit; + static const mask xdigit = _ISxdigit; + static const mask space = _ISspace; + static const mask print = _ISprint; + static const mask graph = _ISalpha | _ISdigit | _ISpunct; + static const mask cntrl = _IScntrl; + static const mask punct = _ISpunct; + static const mask alnum = _ISalpha | _ISdigit; + + static const mask blank = _ISblank; + + }; + + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + class istreambuf_iterator + : public iterator + { + public: +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 3 + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename _Traits::int_type int_type; + typedef basic_streambuf<_CharT, _Traits> streambuf_type; + typedef basic_istream<_CharT, _Traits> istream_type; + + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + ostreambuf_iterator<_CharT2> >::__type + copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + ostreambuf_iterator<_CharT2>); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + _CharT2*>::__type + __copy_move_a2(istreambuf_iterator<_CharT2>, + istreambuf_iterator<_CharT2>, _CharT2*); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + _CharT2*>::__type + __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*, bool); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + istreambuf_iterator<_CharT2> >::__type + find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + const _CharT2&); + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + void>::__type + advance(istreambuf_iterator<_CharT2>&, _Distance); + + private: + + + + + + + + mutable streambuf_type* _M_sbuf; + int_type _M_c; + + public: + + constexpr istreambuf_iterator() noexcept + : _M_sbuf(0), _M_c(traits_type::eof()) { } + + + + + + + + istreambuf_iterator(const istreambuf_iterator&) noexcept = default; + + ~istreambuf_iterator() = default; + + + + istreambuf_iterator(istream_type& __s) noexcept + : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { } + + + istreambuf_iterator(streambuf_type* __s) noexcept + : _M_sbuf(__s), _M_c(traits_type::eof()) { } + + + istreambuf_iterator& + operator=(const istreambuf_iterator&) noexcept = default; + + + + + + [[__nodiscard__]] + char_type + operator*() const + { + int_type __c = _M_get(); +# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 3 + return traits_type::to_char_type(__c); + } + + + istreambuf_iterator& + operator++() + { + + + + ; + + _M_sbuf->sbumpc(); + _M_c = traits_type::eof(); + return *this; + } + + + istreambuf_iterator + operator++(int) + { + + + + ; + + istreambuf_iterator __old = *this; + __old._M_c = _M_sbuf->sbumpc(); + _M_c = traits_type::eof(); + return __old; + } + + + + + + [[__nodiscard__]] + bool + equal(const istreambuf_iterator& __b) const + { return _M_at_eof() == __b._M_at_eof(); } + + private: + int_type + _M_get() const + { + int_type __ret = _M_c; + if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc())) + _M_sbuf = 0; + return __ret; + } + + bool + _M_at_eof() const + { return _S_is_eof(_M_get()); } + + static bool + _S_is_eof(int_type __c) + { + const int_type __eof = traits_type::eof(); + return traits_type::eq_int_type(__c, __eof); + } + + + + + + + + }; + + template + [[__nodiscard__]] + inline bool + operator==(const istreambuf_iterator<_CharT, _Traits>& __a, + const istreambuf_iterator<_CharT, _Traits>& __b) + { return __a.equal(__b); } + + + template + [[__nodiscard__]] + inline bool + operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, + const istreambuf_iterator<_CharT, _Traits>& __b) + { return !__a.equal(__b); } + + + + template + class ostreambuf_iterator + : public iterator + { + public: + + + + + + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef basic_streambuf<_CharT, _Traits> streambuf_type; + typedef basic_ostream<_CharT, _Traits> ostream_type; + + + template + friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, + ostreambuf_iterator<_CharT2> >::__type + copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, + ostreambuf_iterator<_CharT2>); + + private: + streambuf_type* _M_sbuf; + bool _M_failed; + + public: +# 284 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 3 + ostreambuf_iterator(ostream_type& __s) noexcept + : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { } + + + ostreambuf_iterator(streambuf_type* __s) noexcept + : _M_sbuf(__s), _M_failed(!_M_sbuf) { } + + + ostreambuf_iterator& + operator=(_CharT __c) + { + if (!_M_failed && + _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) + _M_failed = true; + return *this; + } + + + [[__nodiscard__]] + ostreambuf_iterator& + operator*() + { return *this; } + + + ostreambuf_iterator& + operator++(int) + { return *this; } + + + ostreambuf_iterator& + operator++() + { return *this; } + + + [[__nodiscard__]] + bool + failed() const noexcept + { return _M_failed; } + + ostreambuf_iterator& + _M_put(const _CharT* __ws, streamsize __len) + { + if (__builtin_expect(!_M_failed, true) + && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, + false)) + _M_failed = true; + return *this; + } + }; +#pragma GCC diagnostic pop + + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT> >::__type + copy(istreambuf_iterator<_CharT> __first, + istreambuf_iterator<_CharT> __last, + ostreambuf_iterator<_CharT> __result) + { + if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed) + { + bool __ineof; + __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof); + if (!__ineof) + __result._M_failed = true; + } + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT> >::__type + __copy_move_a2(_CharT* __first, _CharT* __last, + ostreambuf_iterator<_CharT> __result) + { + const streamsize __num = __last - __first; + if (__num > 0) + __result._M_put(__first, __num); + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT> >::__type + __copy_move_a2(const _CharT* __first, const _CharT* __last, + ostreambuf_iterator<_CharT> __result) + { + const streamsize __num = __last - __first; + if (__num > 0) + __result._M_put(__first, __num); + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT> __first, + istreambuf_iterator<_CharT> __last, _CharT* __result) + { + typedef istreambuf_iterator<_CharT> __is_iterator_type; + typedef typename __is_iterator_type::traits_type traits_type; + typedef typename __is_iterator_type::streambuf_type streambuf_type; + typedef typename traits_type::int_type int_type; + + if (__first._M_sbuf && !__last._M_sbuf) + { + streambuf_type* __sb = __first._M_sbuf; + int_type __c = __sb->sgetc(); + while (!traits_type::eq_int_type(__c, traits_type::eof())) + { + const streamsize __n = __sb->egptr() - __sb->gptr(); + if (__n > 1) + { + traits_type::copy(__result, __sb->gptr(), __n); + __sb->__safe_gbump(__n); + __result += __n; + __c = __sb->underflow(); + } + else + { + *__result++ = traits_type::to_char_type(__c); + __c = __sb->snextc(); + } + } + } + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result, + bool __strict __attribute__((__unused__))) + { + if (__n == 0) + return __result; + + + + ; + _CharT* __beg = __result; + __result += __it._M_sbuf->sgetn(__beg, __n); + + + ; + return __result; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + istreambuf_iterator<_CharT> >::__type + find(istreambuf_iterator<_CharT> __first, + istreambuf_iterator<_CharT> __last, const _CharT& __val) + { + typedef istreambuf_iterator<_CharT> __is_iterator_type; + typedef typename __is_iterator_type::traits_type traits_type; + typedef typename __is_iterator_type::streambuf_type streambuf_type; + typedef typename traits_type::int_type int_type; + const int_type __eof = traits_type::eof(); + + if (__first._M_sbuf && !__last._M_sbuf) + { + const int_type __ival = traits_type::to_int_type(__val); + streambuf_type* __sb = __first._M_sbuf; + int_type __c = __sb->sgetc(); + while (!traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __ival)) + { + streamsize __n = __sb->egptr() - __sb->gptr(); + if (__n > 1) + { + const _CharT* __p = traits_type::find(__sb->gptr(), + __n, __val); + if (__p) + __n = __p - __sb->gptr(); + __sb->__safe_gbump(__n); + __c = __sb->sgetc(); + } + else + __c = __sb->snextc(); + } + + __first._M_c = __eof; + } + + return __first; + } + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + void>::__type + advance(istreambuf_iterator<_CharT>& __i, _Distance __n) + { + if (__n == 0) + return; + + do { if (std::__is_constant_evaluated() && !bool(__n > 0)) __builtin_unreachable(); } while (false); + + + ; + + typedef istreambuf_iterator<_CharT> __is_iterator_type; + typedef typename __is_iterator_type::traits_type traits_type; + typedef typename __is_iterator_type::streambuf_type streambuf_type; + typedef typename traits_type::int_type int_type; + const int_type __eof = traits_type::eof(); + + streambuf_type* __sb = __i._M_sbuf; + while (__n > 0) + { + streamsize __size = __sb->egptr() - __sb->gptr(); + if (__size > __n) + { + __sb->__safe_gbump(__n); + break; + } + + __sb->__safe_gbump(__size); + __n -= __size; + if (traits_type::eq_int_type(__sb->underflow(), __eof)) + { + + + ; + break; + } + } + + __i._M_c = __eof; + } + + + + +} +# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + template + void + __convert_to_v(const char*, _Tp&, ios_base::iostate&, + const __c_locale&) throw(); + + + template<> + void + __convert_to_v(const char*, float&, ios_base::iostate&, + const __c_locale&) throw(); + + template<> + void + __convert_to_v(const char*, double&, ios_base::iostate&, + const __c_locale&) throw(); + + template<> + void + __convert_to_v(const char*, long double&, ios_base::iostate&, + const __c_locale&) throw(); + + + + template + struct __pad + { + static void + _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, + const _CharT* __olds, streamsize __newlen, streamsize __oldlen); + }; + + + + + + + template + _CharT* + __add_grouping(_CharT* __s, _CharT __sep, + const char* __gbeg, size_t __gsize, + const _CharT* __first, const _CharT* __last); + + + + + template + inline + ostreambuf_iterator<_CharT> + __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) + { + __s._M_put(__ws, __len); + return __s; + } + + + template + inline + _OutIter + __write(_OutIter __s, const _CharT* __ws, int __len) + { + for (int __j = 0; __j < __len; __j++, ++__s) + *__s = __ws[__j]; + return __s; + } +# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + template + class __ctype_abstract_base : public locale::facet, public ctype_base + { + public: + + + typedef _CharT char_type; +# 171 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + bool + is(mask __m, char_type __c) const + { return this->do_is(__m, __c); } +# 188 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char_type* + is(const char_type *__lo, const char_type *__hi, mask *__vec) const + { return this->do_is(__lo, __hi, __vec); } +# 204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char_type* + scan_is(mask __m, const char_type* __lo, const char_type* __hi) const + { return this->do_scan_is(__m, __lo, __hi); } +# 220 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char_type* + scan_not(mask __m, const char_type* __lo, const char_type* __hi) const + { return this->do_scan_not(__m, __lo, __hi); } +# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } +# 249 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char_type* + toupper(char_type *__lo, const char_type* __hi) const + { return this->do_toupper(__lo, __hi); } +# 263 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } +# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char_type* + tolower(char_type* __lo, const char_type* __hi) const + { return this->do_tolower(__lo, __hi); } +# 295 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char_type + widen(char __c) const + { return this->do_widen(__c); } +# 314 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char* + widen(const char* __lo, const char* __hi, char_type* __to) const + { return this->do_widen(__lo, __hi, __to); } +# 333 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char + narrow(char_type __c, char __dfault) const + { return this->do_narrow(__c, __dfault); } +# 355 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char_type* + narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const + { return this->do_narrow(__lo, __hi, __dfault, __to); } + + protected: + explicit + __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } + + virtual + ~__ctype_abstract_base() { } +# 380 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual bool + do_is(mask __m, char_type __c) const = 0; +# 399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, + mask* __vec) const = 0; +# 418 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, + const char_type* __hi) const = 0; +# 437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const = 0; +# 455 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const = 0; +# 472 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const = 0; +# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const = 0; +# 505 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const = 0; +# 524 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const = 0; +# 545 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0; +# 566 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const = 0; +# 591 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const = 0; + }; +# 614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + template + class ctype : public __ctype_abstract_base<_CharT> + { + public: + + typedef _CharT char_type; + typedef typename __ctype_abstract_base<_CharT>::mask mask; + + + static locale::id id; + + explicit + ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } + + protected: + virtual + ~ctype(); + + virtual bool + do_is(mask __m, char_type __c) const; + + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; + + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; + + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const; + + virtual char_type + do_toupper(char_type __c) const; + + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; + + virtual char_type + do_tolower(char_type __c) const; + + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; + + virtual char_type + do_widen(char __c) const; + + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __dest) const; + + virtual char + do_narrow(char_type, char __dfault) const; + + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const; + }; + + template + locale::id ctype<_CharT>::id; + + + + template + class ctype >; +# 688 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + template<> + class ctype : public locale::facet, public ctype_base + { + public: + + + typedef char char_type; + + protected: + + __c_locale _M_c_locale_ctype; + bool _M_del; + __to_type _M_toupper; + __to_type _M_tolower; + const mask* _M_table; + mutable char _M_widen_ok; + mutable char _M_widen[1 + static_cast(-1)]; + mutable char _M_narrow[1 + static_cast(-1)]; + mutable char _M_narrow_ok; + + + public: + + static locale::id id; + + static const size_t table_size = 1 + static_cast(-1); +# 725 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + explicit + ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); +# 738 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + explicit + ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, + size_t __refs = 0); +# 751 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + inline bool + is(mask __m, char __c) const; +# 766 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + inline const char* + is(const char* __lo, const char* __hi, mask* __vec) const; +# 780 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + inline const char* + scan_is(mask __m, const char* __lo, const char* __hi) const; +# 794 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + inline const char* + scan_not(mask __m, const char* __lo, const char* __hi) const; +# 809 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char_type + toupper(char_type __c) const + { return this->do_toupper(__c); } +# 826 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char_type* + toupper(char_type *__lo, const char_type* __hi) const + { return this->do_toupper(__lo, __hi); } +# 842 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char_type + tolower(char_type __c) const + { return this->do_tolower(__c); } +# 859 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char_type* + tolower(char_type* __lo, const char_type* __hi) const + { return this->do_tolower(__lo, __hi); } +# 879 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char_type + widen(char __c) const + { + if (_M_widen_ok) + return _M_widen[static_cast(__c)]; + this->_M_widen_init(); + return this->do_widen(__c); + } +# 906 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char* + widen(const char* __lo, const char* __hi, char_type* __to) const + { + if (_M_widen_ok == 1) + { + if (__builtin_expect(__hi != __lo, true)) + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + if (!_M_widen_ok) + _M_widen_init(); + return this->do_widen(__lo, __hi, __to); + } +# 938 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char + narrow(char_type __c, char __dfault) const + { + if (_M_narrow[static_cast(__c)]) + return _M_narrow[static_cast(__c)]; + const char __t = do_narrow(__c, __dfault); + if (__t != __dfault) + _M_narrow[static_cast(__c)] = __t; + return __t; + } +# 971 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + const char_type* + narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const + { + if (__builtin_expect(_M_narrow_ok == 1, true)) + { + if (__builtin_expect(__hi != __lo, true)) + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + if (!_M_narrow_ok) + _M_narrow_init(); + return this->do_narrow(__lo, __hi, __dfault, __to); + } + + + + + + const mask* + table() const throw() + { return _M_table; } + + + static const mask* + classic_table() throw(); + protected: + + + + + + + + virtual + ~ctype(); +# 1021 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const; +# 1038 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; +# 1054 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const; +# 1071 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; +# 1091 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const + { return __c; } +# 1114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const + { + if (__builtin_expect(__hi != __lo, true)) + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } +# 1141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const + { return __c; } +# 1167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault __attribute__((__unused__)), char* __to) const + { + if (__builtin_expect(__hi != __lo, true)) + __builtin_memcpy(__to, __lo, __hi - __lo); + return __hi; + } + + private: + void _M_narrow_init() const; + void _M_widen_init() const; + }; +# 1193 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + template<> + class ctype : public __ctype_abstract_base + { + public: + + + typedef wchar_t char_type; + typedef wctype_t __wmask_type; + + protected: + __c_locale _M_c_locale_ctype; + + + bool _M_narrow_ok; + char _M_narrow[128]; + wint_t _M_widen[1 + static_cast(-1)]; + + + mask _M_bit[16]; + __wmask_type _M_wmask[16]; + + public: + + + static locale::id id; +# 1226 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + explicit + ctype(size_t __refs = 0); +# 1237 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + explicit + ctype(__c_locale __cloc, size_t __refs = 0); + + protected: + __wmask_type + _M_convert_to_wmask(const mask __m) const throw(); + + + virtual + ~ctype(); +# 1261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual bool + do_is(mask __m, char_type __c) const; +# 1280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; +# 1298 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; +# 1316 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_scan_not(mask __m, const char_type* __lo, + const char_type* __hi) const; +# 1333 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_toupper(char_type __c) const; +# 1350 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_toupper(char_type* __lo, const char_type* __hi) const; +# 1366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_tolower(char_type __c) const; +# 1383 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_tolower(char_type* __lo, const char_type* __hi) const; +# 1403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_widen(char __c) const; +# 1425 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char* + do_widen(const char* __lo, const char* __hi, char_type* __to) const; +# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char + do_narrow(char_type __c, char __dfault) const; +# 1474 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual const char_type* + do_narrow(const char_type* __lo, const char_type* __hi, + char __dfault, char* __to) const; + + + void + _M_initialize_ctype() throw(); + }; + + + + template + class ctype_byname : public ctype<_CharT> + { + public: + typedef typename ctype<_CharT>::mask mask; + + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + + explicit + ctype_byname(const string& __s, size_t __refs = 0) + : ctype_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~ctype_byname() { } + }; + + + template<> + class ctype_byname : public ctype + { + public: + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + + explicit + ctype_byname(const string& __s, size_t __refs = 0); + + + protected: + virtual + ~ctype_byname(); + }; + + + template<> + class ctype_byname : public ctype + { + public: + explicit + ctype_byname(const char* __s, size_t __refs = 0); + + + explicit + ctype_byname(const string& __s, size_t __refs = 0); + + + protected: + virtual + ~ctype_byname(); + }; + + + +} + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/ctype_inline.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + bool + ctype:: + is(mask __m, char __c) const + { return _M_table[static_cast(__c)] & __m; } + + const char* + ctype:: + is(const char* __low, const char* __high, mask* __vec) const + { + while (__low < __high) + *__vec++ = _M_table[static_cast(*__low++)]; + return __high; + } + + const char* + ctype:: + scan_is(mask __m, const char* __low, const char* __high) const + { + while (__low < __high + && !(_M_table[static_cast(*__low)] & __m)) + ++__low; + return __low; + } + + const char* + ctype:: + scan_not(mask __m, const char* __low, const char* __high) const + { + while (__low < __high + && (_M_table[static_cast(*__low)] & __m) != 0) + ++__low; + return __low; + } + + +} +# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + class __num_base + { + public: + + + enum + { + _S_ominus, + _S_oplus, + _S_ox, + _S_oX, + _S_odigits, + _S_odigits_end = _S_odigits + 16, + _S_oudigits = _S_odigits_end, + _S_oudigits_end = _S_oudigits + 16, + _S_oe = _S_odigits + 14, + _S_oE = _S_oudigits + 14, + _S_oend = _S_oudigits_end + }; + + + + + + + static const char* _S_atoms_out; + + + + static const char* _S_atoms_in; + + enum + { + _S_iminus, + _S_iplus, + _S_ix, + _S_iX, + _S_izero, + _S_ie = _S_izero + 14, + _S_iE = _S_izero + 20, + _S_iend = 26 + }; + + + + static void + _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw(); + }; + + template + struct __numpunct_cache : public locale::facet + { + const char* _M_grouping; + size_t _M_grouping_size; + bool _M_use_grouping; + const _CharT* _M_truename; + size_t _M_truename_size; + const _CharT* _M_falsename; + size_t _M_falsename_size; + _CharT _M_decimal_point; + _CharT _M_thousands_sep; + + + + + + _CharT _M_atoms_out[__num_base::_S_oend]; + + + + + + _CharT _M_atoms_in[__num_base::_S_iend]; + + bool _M_allocated; + + __numpunct_cache(size_t __refs = 0) + : facet(__refs), _M_grouping(0), _M_grouping_size(0), + _M_use_grouping(false), + _M_truename(0), _M_truename_size(0), _M_falsename(0), + _M_falsename_size(0), _M_decimal_point(_CharT()), + _M_thousands_sep(_CharT()), _M_allocated(false) + { } + + ~__numpunct_cache(); + + void + _M_cache(const locale& __loc); + + private: + __numpunct_cache& + operator=(const __numpunct_cache&); + + explicit + __numpunct_cache(const __numpunct_cache&); + }; + + template + __numpunct_cache<_CharT>::~__numpunct_cache() + { + if (_M_allocated) + { + delete [] _M_grouping; + delete [] _M_truename; + delete [] _M_falsename; + } + } + +namespace __cxx11 { +# 1677 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + template + class numpunct : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + typedef __numpunct_cache<_CharT> __cache_type; + + protected: + __cache_type* _M_data; + + public: + + static locale::id id; + + + + + + + explicit + numpunct(size_t __refs = 0) + : facet(__refs), _M_data(0) + { _M_initialize_numpunct(); } +# 1715 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + explicit + numpunct(__cache_type* __cache, size_t __refs = 0) + : facet(__refs), _M_data(__cache) + { _M_initialize_numpunct(); } +# 1729 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + explicit + numpunct(__c_locale __cloc, size_t __refs = 0) + : facet(__refs), _M_data(0) + { _M_initialize_numpunct(__cloc); } +# 1743 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char_type + decimal_point() const + { return this->do_decimal_point(); } +# 1756 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + char_type + thousands_sep() const + { return this->do_thousands_sep(); } +# 1787 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + string + grouping() const + { return this->do_grouping(); } +# 1800 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + string_type + truename() const + { return this->do_truename(); } +# 1813 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + string_type + falsename() const + { return this->do_falsename(); } + + protected: + + virtual + ~numpunct(); +# 1830 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_decimal_point() const + { return _M_data->_M_decimal_point; } +# 1842 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual char_type + do_thousands_sep() const + { return _M_data->_M_thousands_sep; } +# 1855 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual string + do_grouping() const + { return _M_data->_M_grouping; } +# 1868 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual string_type + do_truename() const + { return _M_data->_M_truename; } +# 1881 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual string_type + do_falsename() const + { return _M_data->_M_falsename; } + + + void + _M_initialize_numpunct(__c_locale __cloc = 0); + }; + + template + locale::id numpunct<_CharT>::id; + + template<> + numpunct::~numpunct(); + + template<> + void + numpunct::_M_initialize_numpunct(__c_locale __cloc); + + + template<> + numpunct::~numpunct(); + + template<> + void + numpunct::_M_initialize_numpunct(__c_locale __cloc); + + + + template + class numpunct_byname : public numpunct<_CharT> + { + public: + typedef _CharT char_type; + typedef basic_string<_CharT> string_type; + + explicit + numpunct_byname(const char* __s, size_t __refs = 0) + : numpunct<_CharT>(__refs) + { + if (__builtin_strcmp(__s, "C") != 0 + && __builtin_strcmp(__s, "POSIX") != 0) + { + __c_locale __tmp; + this->_S_create_c_locale(__tmp, __s); + this->_M_initialize_numpunct(__tmp); + this->_S_destroy_c_locale(__tmp); + } + } + + + explicit + numpunct_byname(const string& __s, size_t __refs = 0) + : numpunct_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~numpunct_byname() { } + }; + +} +# 1959 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + template + class num_get : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef _InIter iter_type; + + + + static locale::id id; +# 1980 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + explicit + num_get(size_t __refs = 0) : facet(__refs) { } +# 2006 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, bool& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } +# 2043 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned short& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned int& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long long& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } +# 2103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, float& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, double& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long double& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } +# 2146 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + iter_type + get(iter_type __in, iter_type __end, ios_base& __io, + ios_base::iostate& __err, void*& __v) const + { return this->do_get(__in, __end, __io, __err, __v); } + + protected: + + virtual ~num_get() { } + + __attribute ((__abi_tag__ ("cxx11"))) + iter_type + _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&, + string&) const; + + template + __attribute ((__abi_tag__ ("cxx11"))) + iter_type + _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, + _ValueT&) const; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type + _M_find(const _CharT2*, size_t __len, _CharT2 __c) const + { + int __ret = -1; + if (__len <= 10) + { + if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len)) + __ret = __c - _CharT2('0'); + } + else + { + if (__c >= _CharT2('0') && __c <= _CharT2('9')) + __ret = __c - _CharT2('0'); + else if (__c >= _CharT2('a') && __c <= _CharT2('f')) + __ret = 10 + (__c - _CharT2('a')); + else if (__c >= _CharT2('A') && __c <= _CharT2('F')) + __ret = 10 + (__c - _CharT2('A')); + } + return __ret; + } + + template + typename __gnu_cxx::__enable_if::__value, + int>::__type + _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const + { + int __ret = -1; + const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); + if (__q) + { + __ret = __q - __zero; + if (__ret > 15) + __ret -= 6; + } + return __ret; + } +# 2219 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned short& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned int& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + virtual iter_type + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, unsigned long long& __v) const + { return _M_extract_int(__beg, __end, __io, __err, __v); } + + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const; + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + double&) const; +# 2271 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, + long double&) const; + + + virtual iter_type + do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const; +# 2299 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + }; + + template + locale::id num_get<_CharT, _InIter>::id; +# 2317 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + template + class num_put : public locale::facet + { + public: + + + + typedef _CharT char_type; + typedef _OutIter iter_type; + + + + static locale::id id; +# 2338 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + explicit + num_put(size_t __refs = 0) : facet(__refs) { } +# 2356 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const + { return this->do_put(__s, __io, __fill, __v); } +# 2398 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, long __v) const + { return this->do_put(__s, __io, __fill, __v); } + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long __v) const + { return this->do_put(__s, __io, __fill, __v); } + + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const + { return this->do_put(__s, __io, __fill, __v); } + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long long __v) const + { return this->do_put(__s, __io, __fill, __v); } +# 2461 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, double __v) const + { return this->do_put(__s, __io, __fill, __v); } + + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + long double __v) const + { return this->do_put(__s, __io, __fill, __v); } +# 2486 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + iter_type + put(iter_type __s, ios_base& __io, char_type __fill, + const void* __v) const + { return this->do_put(__s, __io, __fill, __v); } + + protected: + template + iter_type + _M_insert_float(iter_type, ios_base& __io, char_type __fill, + char __mod, _ValueT __v) const; + + void + _M_group_float(const char* __grouping, size_t __grouping_size, + char_type __sep, const char_type* __p, char_type* __new, + char_type* __cs, int& __len) const; + + template + iter_type + _M_insert_int(iter_type, ios_base& __io, char_type __fill, + _ValueT __v) const; + + void + _M_group_int(const char* __grouping, size_t __grouping_size, + char_type __sep, ios_base& __io, char_type* __new, + char_type* __cs, int& __len) const; + + void + _M_pad(char_type __fill, streamsize __w, ios_base& __io, + char_type* __new, const char_type* __cs, int& __len) const; + + + virtual + ~num_put() { } +# 2534 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const; + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, + long long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + virtual iter_type + do_put(iter_type __s, ios_base& __io, char_type __fill, + unsigned long long __v) const + { return _M_insert_int(__s, __io, __fill, __v); } + + + virtual iter_type + do_put(iter_type, ios_base&, char_type, double) const; + + + + + + + virtual iter_type + do_put(iter_type, ios_base&, char_type, long double) const; + + + virtual iter_type + do_put(iter_type, ios_base&, char_type, const void*) const; +# 2586 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + }; + + template + locale::id num_put<_CharT, _OutIter>::id; +# 2599 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 + template + inline bool + isspace(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::space, __c); } + + + template + inline bool + isprint(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::print, __c); } + + + template + inline bool + iscntrl(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::cntrl, __c); } + + + template + inline bool + isupper(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::upper, __c); } + + + template + inline bool + islower(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::lower, __c); } + + + template + inline bool + isalpha(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::alpha, __c); } + + + template + inline bool + isdigit(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::digit, __c); } + + + template + inline bool + ispunct(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::punct, __c); } + + + template + inline bool + isxdigit(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::xdigit, __c); } + + + template + inline bool + isalnum(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::alnum, __c); } + + + template + inline bool + isgraph(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::graph, __c); } + + + + template + inline bool + isblank(_CharT __c, const locale& __loc) + { return use_facet >(__loc).is(ctype_base::blank, __c); } + + + + template + inline _CharT + toupper(_CharT __c, const locale& __loc) + { return use_facet >(__loc).toupper(__c); } + + + template + inline _CharT + tolower(_CharT __c, const locale& __loc) + { return use_facet >(__loc).tolower(__c); } + + +} + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + struct __use_cache + { + const _Facet* + operator() (const locale& __loc) const; + }; + + + template + struct __use_cache<__numpunct_cache<_CharT> > + { + const __numpunct_cache<_CharT>* + operator() (const locale& __loc) const + { + const size_t __i = numpunct<_CharT>::id._M_id(); + const locale::facet** __caches = __loc._M_impl->_M_caches; + if (!__caches[__i]) + { + __numpunct_cache<_CharT>* __tmp = 0; + try + { + __tmp = new __numpunct_cache<_CharT>; + __tmp->_M_cache(__loc); + } + catch(...) + { + delete __tmp; + throw; + } + __loc._M_impl->_M_install_cache(__tmp, __i); + } + return static_cast*>(__caches[__i]); + } + }; + + template + void + __numpunct_cache<_CharT>::_M_cache(const locale& __loc) + { + const numpunct<_CharT>& __np = use_facet >(__loc); + + char* __grouping = 0; + _CharT* __truename = 0; + _CharT* __falsename = 0; + try + { + const string& __g = __np.grouping(); + _M_grouping_size = __g.size(); + __grouping = new char[_M_grouping_size]; + __g.copy(__grouping, _M_grouping_size); + _M_use_grouping = (_M_grouping_size + && static_cast(__grouping[0]) > 0 + && (__grouping[0] + != __gnu_cxx::__numeric_traits::__max)); + + const basic_string<_CharT>& __tn = __np.truename(); + _M_truename_size = __tn.size(); + __truename = new _CharT[_M_truename_size]; + __tn.copy(__truename, _M_truename_size); + + const basic_string<_CharT>& __fn = __np.falsename(); + _M_falsename_size = __fn.size(); + __falsename = new _CharT[_M_falsename_size]; + __fn.copy(__falsename, _M_falsename_size); + + _M_decimal_point = __np.decimal_point(); + _M_thousands_sep = __np.thousands_sep(); + + const ctype<_CharT>& __ct = use_facet >(__loc); + __ct.widen(__num_base::_S_atoms_out, + __num_base::_S_atoms_out + + __num_base::_S_oend, _M_atoms_out); + __ct.widen(__num_base::_S_atoms_in, + __num_base::_S_atoms_in + + __num_base::_S_iend, _M_atoms_in); + + _M_grouping = __grouping; + _M_truename = __truename; + _M_falsename = __falsename; + _M_allocated = true; + } + catch(...) + { + delete [] __grouping; + delete [] __truename; + delete [] __falsename; + throw; + } + } +# 139 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 + __attribute__ ((__pure__)) bool + __verify_grouping(const char* __grouping, size_t __grouping_size, + const string& __grouping_tmp) throw (); + + + + template + __attribute ((__abi_tag__ ("cxx11"))) + _InIter + num_get<_CharT, _InIter>:: + _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io, + ios_base::iostate& __err, string& __xtrc) const + { + typedef char_traits<_CharT> __traits_type; + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + const _CharT* __lit = __lc->_M_atoms_in; + char_type __c = char_type(); + + + bool __testeof = __beg == __end; + + + if (!__testeof) + { + __c = *__beg; + const bool __plus = __c == __lit[__num_base::_S_iplus]; + if ((__plus || __c == __lit[__num_base::_S_iminus]) + && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + && !(__c == __lc->_M_decimal_point)) + { + __xtrc += __plus ? '+' : '-'; + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + } + + + bool __found_mantissa = false; + int __sep_pos = 0; + while (!__testeof) + { + if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + || __c == __lc->_M_decimal_point) + break; + else if (__c == __lit[__num_base::_S_izero]) + { + if (!__found_mantissa) + { + __xtrc += '0'; + __found_mantissa = true; + } + ++__sep_pos; + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + else + break; + } + + + bool __found_dec = false; + bool __found_sci = false; + string __found_grouping; + if (__lc->_M_use_grouping) + __found_grouping.reserve(32); + const char_type* __lit_zero = __lit + __num_base::_S_izero; + + if (!__lc->_M_allocated) + + while (!__testeof) + { + const int __digit = _M_find(__lit_zero, 10, __c); + if (__digit != -1) + { + __xtrc += '0' + __digit; + __found_mantissa = true; + } + else if (__c == __lc->_M_decimal_point + && !__found_dec && !__found_sci) + { + __xtrc += '.'; + __found_dec = true; + } + else if ((__c == __lit[__num_base::_S_ie] + || __c == __lit[__num_base::_S_iE]) + && !__found_sci && __found_mantissa) + { + + __xtrc += 'e'; + __found_sci = true; + + + if (++__beg != __end) + { + __c = *__beg; + const bool __plus = __c == __lit[__num_base::_S_iplus]; + if (__plus || __c == __lit[__num_base::_S_iminus]) + __xtrc += __plus ? '+' : '-'; + else + continue; + } + else + { + __testeof = true; + break; + } + } + else + break; + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + else + while (!__testeof) + { + + + if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + { + if (!__found_dec && !__found_sci) + { + + + if (__sep_pos) + { + __found_grouping += static_cast(__sep_pos); + __sep_pos = 0; + } + else + { + + + __xtrc.clear(); + break; + } + } + else + break; + } + else if (__c == __lc->_M_decimal_point) + { + if (!__found_dec && !__found_sci) + { + + + + if (__found_grouping.size()) + __found_grouping += static_cast(__sep_pos); + __xtrc += '.'; + __found_dec = true; + } + else + break; + } + else + { + const char_type* __q = + __traits_type::find(__lit_zero, 10, __c); + if (__q) + { + __xtrc += '0' + (__q - __lit_zero); + __found_mantissa = true; + ++__sep_pos; + } + else if ((__c == __lit[__num_base::_S_ie] + || __c == __lit[__num_base::_S_iE]) + && !__found_sci && __found_mantissa) + { + + if (__found_grouping.size() && !__found_dec) + __found_grouping += static_cast(__sep_pos); + __xtrc += 'e'; + __found_sci = true; + + + if (++__beg != __end) + { + __c = *__beg; + const bool __plus = __c == __lit[__num_base::_S_iplus]; + if ((__plus || __c == __lit[__num_base::_S_iminus]) + && !(__lc->_M_use_grouping + && __c == __lc->_M_thousands_sep) + && !(__c == __lc->_M_decimal_point)) + __xtrc += __plus ? '+' : '-'; + else + continue; + } + else + { + __testeof = true; + break; + } + } + else + break; + } + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + + + + if (__found_grouping.size()) + { + + if (!__found_dec && !__found_sci) + __found_grouping += static_cast(__sep_pos); + + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __found_grouping)) + __err = ios_base::failbit; + } + + return __beg; + } + + template + template + __attribute ((__abi_tag__ ("cxx11"))) + _InIter + num_get<_CharT, _InIter>:: + _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io, + ios_base::iostate& __err, _ValueT& __v) const + { + typedef char_traits<_CharT> __traits_type; + using __gnu_cxx::__add_unsigned; + typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + const _CharT* __lit = __lc->_M_atoms_in; + char_type __c = char_type(); + + + const ios_base::fmtflags __basefield = __io.flags() + & ios_base::basefield; + const bool __oct = __basefield == ios_base::oct; + int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10); + + + bool __testeof = __beg == __end; + + + bool __negative = false; + if (!__testeof) + { + __c = *__beg; + __negative = __c == __lit[__num_base::_S_iminus]; + if ((__negative || __c == __lit[__num_base::_S_iplus]) + && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + && !(__c == __lc->_M_decimal_point)) + { + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + } + + + + bool __found_zero = false; + int __sep_pos = 0; + while (!__testeof) + { + if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + || __c == __lc->_M_decimal_point) + break; + else if (__c == __lit[__num_base::_S_izero] + && (!__found_zero || __base == 10)) + { + __found_zero = true; + ++__sep_pos; + if (__basefield == 0) + __base = 8; + if (__base == 8) + __sep_pos = 0; + } + else if (__found_zero + && (__c == __lit[__num_base::_S_ix] + || __c == __lit[__num_base::_S_iX])) + { + if (__basefield == 0) + __base = 16; + if (__base == 16) + { + __found_zero = false; + __sep_pos = 0; + } + else + break; + } + else + break; + + if (++__beg != __end) + { + __c = *__beg; + if (!__found_zero) + break; + } + else + __testeof = true; + } + + + + const size_t __len = (__base == 16 ? __num_base::_S_iend + - __num_base::_S_izero : __base); + + + typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits; + string __found_grouping; + if (__lc->_M_use_grouping) + __found_grouping.reserve(32); + bool __testfail = false; + bool __testoverflow = false; + const __unsigned_type __max = + (__negative && __num_traits::__is_signed) + ? -static_cast<__unsigned_type>(__num_traits::__min) + : __num_traits::__max; + const __unsigned_type __smax = __max / __base; + __unsigned_type __result = 0; + int __digit = 0; + const char_type* __lit_zero = __lit + __num_base::_S_izero; + + if (!__lc->_M_allocated) + + while (!__testeof) + { + __digit = _M_find(__lit_zero, __len, __c); + if (__digit == -1) + break; + + if (__result > __smax) + __testoverflow = true; + else + { + __result *= __base; + __testoverflow |= __result > __max - __digit; + __result += __digit; + ++__sep_pos; + } + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + else + while (!__testeof) + { + + + if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) + { + + + if (__sep_pos) + { + __found_grouping += static_cast(__sep_pos); + __sep_pos = 0; + } + else + { + __testfail = true; + break; + } + } + else if (__c == __lc->_M_decimal_point) + break; + else + { + const char_type* __q = + __traits_type::find(__lit_zero, __len, __c); + if (!__q) + break; + + __digit = __q - __lit_zero; + if (__digit > 15) + __digit -= 6; + if (__result > __smax) + __testoverflow = true; + else + { + __result *= __base; + __testoverflow |= __result > __max - __digit; + __result += __digit; + ++__sep_pos; + } + } + + if (++__beg != __end) + __c = *__beg; + else + __testeof = true; + } + + + + if (__found_grouping.size()) + { + + __found_grouping += static_cast(__sep_pos); + + if (!std::__verify_grouping(__lc->_M_grouping, + __lc->_M_grouping_size, + __found_grouping)) + __err = ios_base::failbit; + } + + + + if ((!__sep_pos && !__found_zero && !__found_grouping.size()) + || __testfail) + { + __v = 0; + __err = ios_base::failbit; + } + else if (__testoverflow) + { + if (__negative && __num_traits::__is_signed) + __v = __num_traits::__min; + else + __v = __num_traits::__max; + __err = ios_base::failbit; + } + else + __v = __negative ? -__result : __result; + + if (__testeof) + __err |= ios_base::eofbit; + return __beg; + } + + + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, bool& __v) const + { + if (!(__io.flags() & ios_base::boolalpha)) + { + + + + long __l = -1; + __beg = _M_extract_int(__beg, __end, __io, __err, __l); + if (__l == 0 || __l == 1) + __v = bool(__l); + else + { + + + __v = true; + __err = ios_base::failbit; + if (__beg == __end) + __err |= ios_base::eofbit; + } + } + else + { + + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + + bool __testf = true; + bool __testt = true; + bool __donef = __lc->_M_falsename_size == 0; + bool __donet = __lc->_M_truename_size == 0; + bool __testeof = false; + size_t __n = 0; + while (!__donef || !__donet) + { + if (__beg == __end) + { + __testeof = true; + break; + } + + const char_type __c = *__beg; + + if (!__donef) + __testf = __c == __lc->_M_falsename[__n]; + + if (!__testf && __donet) + break; + + if (!__donet) + __testt = __c == __lc->_M_truename[__n]; + + if (!__testt && __donef) + break; + + if (!__testt && !__testf) + break; + + ++__n; + ++__beg; + + __donef = !__testf || __n >= __lc->_M_falsename_size; + __donet = !__testt || __n >= __lc->_M_truename_size; + } + if (__testf && __n == __lc->_M_falsename_size && __n) + { + __v = false; + if (__testt && __n == __lc->_M_truename_size) + __err = ios_base::failbit; + else + __err = __testeof ? ios_base::eofbit : ios_base::goodbit; + } + else if (__testt && __n == __lc->_M_truename_size && __n) + { + __v = true; + __err = __testeof ? ios_base::eofbit : ios_base::goodbit; + } + else + { + + + __v = false; + __err = ios_base::failbit; + if (__testeof) + __err |= ios_base::eofbit; + } + } + return __beg; + } + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, float& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, double& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } +# 735 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, long double& __v) const + { + string __xtrc; + __xtrc.reserve(32); + __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); + std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); + if (__beg == __end) + __err |= ios_base::eofbit; + return __beg; + } + + template + _InIter + num_get<_CharT, _InIter>:: + do_get(iter_type __beg, iter_type __end, ios_base& __io, + ios_base::iostate& __err, void*& __v) const + { + + typedef ios_base::fmtflags fmtflags; + const fmtflags __fmt = __io.flags(); + __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex); + + typedef __gnu_cxx::__conditional_type<(sizeof(void*) + <= sizeof(unsigned long)), + unsigned long, unsigned long long>::__type _UIntPtrType; + + _UIntPtrType __ul; + __beg = _M_extract_int(__beg, __end, __io, __err, __ul); + + + __io.flags(__fmt); + + __v = reinterpret_cast(__ul); + return __beg; + } +# 795 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 + template + void + num_put<_CharT, _OutIter>:: + _M_pad(_CharT __fill, streamsize __w, ios_base& __io, + _CharT* __new, const _CharT* __cs, int& __len) const + { + + + __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, + __cs, __w, __len); + __len = static_cast(__w); + } + + + + template + int + __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit, + ios_base::fmtflags __flags, bool __dec) + { + _CharT* __buf = __bufend; + if (__builtin_expect(__dec, true)) + { + + do + { + *--__buf = __lit[(__v % 10) + __num_base::_S_odigits]; + __v /= 10; + } + while (__v != 0); + } + else if ((__flags & ios_base::basefield) == ios_base::oct) + { + + do + { + *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits]; + __v >>= 3; + } + while (__v != 0); + } + else + { + + const bool __uppercase = __flags & ios_base::uppercase; + const int __case_offset = __uppercase ? __num_base::_S_oudigits + : __num_base::_S_odigits; + do + { + *--__buf = __lit[(__v & 0xf) + __case_offset]; + __v >>= 4; + } + while (__v != 0); + } + return __bufend - __buf; + } + + + + template + void + num_put<_CharT, _OutIter>:: + _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep, + ios_base&, _CharT* __new, _CharT* __cs, int& __len) const + { + _CharT* __p = std::__add_grouping(__new, __sep, __grouping, + __grouping_size, __cs, __cs + __len); + __len = __p - __new; + } + + template + template + _OutIter + num_put<_CharT, _OutIter>:: + _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill, + _ValueT __v) const + { + using __gnu_cxx::__add_unsigned; + typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + const _CharT* __lit = __lc->_M_atoms_out; + const ios_base::fmtflags __flags = __io.flags(); + + + const int __ilen = 5 * sizeof(_ValueT); + _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __ilen)); + + + + const ios_base::fmtflags __basefield = __flags & ios_base::basefield; + const bool __dec = (__basefield != ios_base::oct + && __basefield != ios_base::hex); + const __unsigned_type __u = ((__v > 0 || !__dec) + ? __unsigned_type(__v) + : -__unsigned_type(__v)); + int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec); + __cs += __ilen - __len; + + + if (__lc->_M_use_grouping) + { + + + _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * (__len + 1) + * 2)); + _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size, + __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len); + __cs = __cs2 + 2; + } + + + if (__builtin_expect(__dec, true)) + { + + if (__v >= 0) + { + if (bool(__flags & ios_base::showpos) + && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) + *--__cs = __lit[__num_base::_S_oplus], ++__len; + } + else + *--__cs = __lit[__num_base::_S_ominus], ++__len; + } + else if (bool(__flags & ios_base::showbase) && __v) + { + if (__basefield == ios_base::oct) + *--__cs = __lit[__num_base::_S_odigits], ++__len; + else + { + + const bool __uppercase = __flags & ios_base::uppercase; + *--__cs = __lit[__num_base::_S_ox + __uppercase]; + + *--__cs = __lit[__num_base::_S_odigits]; + __len += 2; + } + } + + + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __cs3, __cs, __len); + __cs = __cs3; + } + __io.width(0); + + + + return std::__write(__s, __cs, __len); + } + + template + void + num_put<_CharT, _OutIter>:: + _M_group_float(const char* __grouping, size_t __grouping_size, + _CharT __sep, const _CharT* __p, _CharT* __new, + _CharT* __cs, int& __len) const + { + + + + const int __declen = __p ? __p - __cs : __len; + _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping, + __grouping_size, + __cs, __cs + __declen); + + + int __newlen = __p2 - __new; + if (__p) + { + char_traits<_CharT>::copy(__p2, __p, __len - __declen); + __newlen += __len - __declen; + } + __len = __newlen; + } +# 989 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 + template + template + _OutIter + num_put<_CharT, _OutIter>:: + _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, + _ValueT __v) const + { + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + + + const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision(); + + const int __max_digits = + __gnu_cxx::__numeric_traits<_ValueT>::__digits10; + + + int __len; + + char __fbuf[16]; + __num_base::_S_format_float(__io, __fbuf, __mod); + + + + const bool __use_prec = + (__io.flags() & ios_base::floatfield) != ios_base::floatfield; + + + + int __cs_size = __max_digits * 3; + char* __cs = static_cast(__builtin_alloca(__cs_size)); + if (__use_prec) + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __prec, __v); + else + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __v); + + + if (__len >= __cs_size) + { + __cs_size = __len + 1; + __cs = static_cast(__builtin_alloca(__cs_size)); + if (__use_prec) + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __prec, __v); + else + __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, + __fbuf, __v); + } +# 1062 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 + const ctype<_CharT>& __ctype = use_facet >(__loc); + + _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len)); + __ctype.widen(__cs, __cs + __len, __ws); + + + _CharT* __wp = 0; + const char* __p = char_traits::find(__cs, __len, '.'); + if (__p) + { + __wp = __ws + (__p - __cs); + *__wp = __lc->_M_decimal_point; + } + + + + + if (__lc->_M_use_grouping + && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9' + && __cs[1] >= '0' && __cs[2] >= '0'))) + { + + + _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __len * 2)); + + streamsize __off = 0; + if (__cs[0] == '-' || __cs[0] == '+') + { + __off = 1; + __ws2[0] = __ws[0]; + __len -= 1; + } + + _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size, + __lc->_M_thousands_sep, __wp, __ws2 + __off, + __ws + __off, __len); + __len += __off; + + __ws = __ws2; + } + + + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __w)); + _M_pad(__fill, __w, __io, __ws3, __ws, __len); + __ws = __ws3; + } + __io.width(0); + + + + return std::__write(__s, __ws, __len); + } + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const + { + const ios_base::fmtflags __flags = __io.flags(); + if ((__flags & ios_base::boolalpha) == 0) + { + const long __l = __v; + __s = _M_insert_int(__s, __io, __fill, __l); + } + else + { + typedef __numpunct_cache<_CharT> __cache_type; + __use_cache<__cache_type> __uc; + const locale& __loc = __io._M_getloc(); + const __cache_type* __lc = __uc(__loc); + + const _CharT* __name = __v ? __lc->_M_truename + : __lc->_M_falsename; + int __len = __v ? __lc->_M_truename_size + : __lc->_M_falsename_size; + + const streamsize __w = __io.width(); + if (__w > static_cast(__len)) + { + const streamsize __plen = __w - __len; + _CharT* __ps + = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) + * __plen)); + + char_traits<_CharT>::assign(__ps, __plen, __fill); + __io.width(0); + + if ((__flags & ios_base::adjustfield) == ios_base::left) + { + __s = std::__write(__s, __name, __len); + __s = std::__write(__s, __ps, __plen); + } + else + { + __s = std::__write(__s, __ps, __plen); + __s = std::__write(__s, __name, __len); + } + return __s; + } + __io.width(0); + __s = std::__write(__s, __name, __len); + } + return __s; + } + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const + { return _M_insert_float(__s, __io, __fill, char(), __v); } +# 1187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, + long double __v) const + { return _M_insert_float(__s, __io, __fill, 'L', __v); } + + template + _OutIter + num_put<_CharT, _OutIter>:: + do_put(iter_type __s, ios_base& __io, char_type __fill, + const void* __v) const + { + const ios_base::fmtflags __flags = __io.flags(); + const ios_base::fmtflags __fmt = ~(ios_base::basefield + | ios_base::uppercase); + __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase)); + + typedef __gnu_cxx::__conditional_type<(sizeof(const void*) + <= sizeof(unsigned long)), + unsigned long, unsigned long long>::__type _UIntPtrType; + + __s = _M_insert_int(__s, __io, __fill, + reinterpret_cast<_UIntPtrType>(__v)); + __io.flags(__flags); + return __s; + } +# 1233 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 + template + void + __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill, + _CharT* __news, const _CharT* __olds, + streamsize __newlen, streamsize __oldlen) + { + const size_t __plen = static_cast(__newlen - __oldlen); + const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield; + + + if (__adjust == ios_base::left) + { + _Traits::copy(__news, __olds, __oldlen); + _Traits::assign(__news + __oldlen, __plen, __fill); + return; + } + + size_t __mod = 0; + if (__adjust == ios_base::internal) + { + + + + const locale& __loc = __io._M_getloc(); + const ctype<_CharT>& __ctype = use_facet >(__loc); + + if (__ctype.widen('-') == __olds[0] + || __ctype.widen('+') == __olds[0]) + { + __news[0] = __olds[0]; + __mod = 1; + ++__news; + } + else if (__ctype.widen('0') == __olds[0] + && __oldlen > 1 + && (__ctype.widen('x') == __olds[1] + || __ctype.widen('X') == __olds[1])) + { + __news[0] = __olds[0]; + __news[1] = __olds[1]; + __mod = 2; + __news += 2; + } + + } + _Traits::assign(__news, __plen, __fill); + _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod); + } + + template + _CharT* + __add_grouping(_CharT* __s, _CharT __sep, + const char* __gbeg, size_t __gsize, + const _CharT* __first, const _CharT* __last) + { + size_t __idx = 0; + size_t __ctr = 0; + + while (__last - __first > __gbeg[__idx] + && static_cast(__gbeg[__idx]) > 0 + && __gbeg[__idx] != __gnu_cxx::__numeric_traits::__max) + { + __last -= __gbeg[__idx]; + __idx < __gsize - 1 ? ++__idx : ++__ctr; + } + + while (__first != __last) + *__s++ = *__first++; + + while (__ctr--) + { + *__s++ = __sep; + for (char __i = __gbeg[__idx]; __i > 0; --__i) + *__s++ = *__first++; + } + + while (__idx--) + { + *__s++ = __sep; + for (char __i = __gbeg[__idx]; __i > 0; --__i) + *__s++ = *__first++; + } + + return __s; + } + + + + + extern template class __cxx11:: numpunct; + extern template class __cxx11:: numpunct_byname; + extern template class num_get; + extern template class num_put; + extern template class ctype_byname; + + extern template + const ctype* + __try_use_facet >(const locale&) noexcept; + + extern template + const numpunct* + __try_use_facet >(const locale&) noexcept; + + extern template + const num_put* + __try_use_facet >(const locale&) noexcept; + + extern template + const num_get* + __try_use_facet >(const locale&) noexcept; + + extern template + const ctype& + use_facet >(const locale&); + + extern template + const numpunct& + use_facet >(const locale&); + + extern template + const num_put& + use_facet >(const locale&); + + extern template + const num_get& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + extern template class __cxx11:: numpunct; + extern template class __cxx11:: numpunct_byname; + extern template class num_get; + extern template class num_put; + extern template class ctype_byname; + + extern template + const ctype* + __try_use_facet >(const locale&) noexcept; + + extern template + const numpunct* + __try_use_facet >(const locale&) noexcept; + + extern template + const num_put* + __try_use_facet >(const locale&) noexcept; + + extern template + const num_get* + __try_use_facet >(const locale&) noexcept; + + extern template + const ctype& + use_facet >(const locale&); + + extern template + const numpunct& + use_facet >(const locale&); + + extern template + const num_put& + use_facet >(const locale&); + + extern template + const num_get& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + + +} +# 2688 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + inline const _Facet& + __check_facet(const _Facet* __f) + { + if (!__f) + __throw_bad_cast(); + return *__f; + } +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + template + class basic_ios : public ios_base + { + public: + + + + + + + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + + + + + + + typedef ctype<_CharT> __ctype_type; + typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > + __num_put_type; + typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > + __num_get_type; + + + + protected: + basic_ostream<_CharT, _Traits>* _M_tie; + mutable char_type _M_fill; + mutable bool _M_fill_init; + basic_streambuf<_CharT, _Traits>* _M_streambuf; + + + const __ctype_type* _M_ctype; + + const __num_put_type* _M_num_put; + + const __num_get_type* _M_num_get; + + public: +# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + explicit operator bool() const + { return !this->fail(); } + + + + + + bool + operator!() const + { return this->fail(); } +# 136 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + iostate + rdstate() const + { return _M_streambuf_state; } +# 147 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + void + clear(iostate __state = goodbit); + + + + + + + + void + setstate(iostate __state) + { this->clear(this->rdstate() | __state); } + + + + + void + _M_setstate(iostate __state) + { + + + _M_streambuf_state |= __state; + if (this->exceptions() & __state) + throw; + } + + + + + + + + bool + good() const + { return this->rdstate() == 0; } + + + + + + + + bool + eof() const + { return (this->rdstate() & eofbit) != 0; } +# 200 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + bool + fail() const + { return (this->rdstate() & (badbit | failbit)) != 0; } + + + + + + + + bool + bad() const + { return (this->rdstate() & badbit) != 0; } +# 221 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + iostate + exceptions() const + { return _M_exception; } +# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + void + exceptions(iostate __except) + { + _M_exception = __except; + this->clear(_M_streambuf_state); + } + + + + + + + + explicit + basic_ios(basic_streambuf<_CharT, _Traits>* __sb) + : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0), + _M_ctype(0), _M_num_put(0), _M_num_get(0) + { this->init(__sb); } + + + + + + + + virtual + ~basic_ios() { } +# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + basic_ostream<_CharT, _Traits>* + tie() const + { return _M_tie; } +# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + basic_ostream<_CharT, _Traits>* + tie(basic_ostream<_CharT, _Traits>* __tiestr) + { + basic_ostream<_CharT, _Traits>* __old = _M_tie; + _M_tie = __tiestr; + return __old; + } + + + + + + + + basic_streambuf<_CharT, _Traits>* + rdbuf() const + { return _M_streambuf; } +# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + basic_streambuf<_CharT, _Traits>* + rdbuf(basic_streambuf<_CharT, _Traits>* __sb); +# 360 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + basic_ios& + copyfmt(const basic_ios& __rhs); + + + + + + + + char_type + fill() const + { + if (!_M_fill_init) + { + _M_fill = this->widen(' '); + _M_fill_init = true; + } + return _M_fill; + } +# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + char_type + fill(char_type __ch) + { + char_type __old = this->fill(); + _M_fill = __ch; + return __old; + } +# 409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + locale + imbue(const locale& __loc); +# 429 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + char + narrow(char_type __c, char __dfault) const + { return __check_facet(_M_ctype).narrow(__c, __dfault); } +# 448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 + char_type + widen(char __c) const + { return __check_facet(_M_ctype).widen(__c); } + + protected: + + + + + + + + basic_ios() + : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), + _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) + { } + + + + + + + + void + init(basic_streambuf<_CharT, _Traits>* __sb); + + + basic_ios(const basic_ios&) = delete; + basic_ios& operator=(const basic_ios&) = delete; + + void + move(basic_ios& __rhs) + { + ios_base::_M_move(__rhs); + _M_cache_locale(_M_ios_locale); + this->tie(__rhs.tie(nullptr)); + _M_fill = __rhs._M_fill; + _M_fill_init = __rhs._M_fill_init; + _M_streambuf = nullptr; + } + + void + move(basic_ios&& __rhs) + { this->move(__rhs); } + + void + swap(basic_ios& __rhs) noexcept + { + ios_base::_M_swap(__rhs); + _M_cache_locale(_M_ios_locale); + __rhs._M_cache_locale(__rhs._M_ios_locale); + std::swap(_M_tie, __rhs._M_tie); + std::swap(_M_fill, __rhs._M_fill); + std::swap(_M_fill_init, __rhs._M_fill_init); + } + + void + set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb) + { _M_streambuf = __sb; } + + + void + _M_cache_locale(const locale& __loc); + }; + + +} + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.tcc" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.tcc" 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + void + basic_ios<_CharT, _Traits>::clear(iostate __state) + { + if (this->rdbuf()) + _M_streambuf_state = __state; + else + _M_streambuf_state = __state | badbit; + if (this->exceptions() & this->rdstate()) + __throw_ios_failure(("basic_ios::clear")); + } + + template + basic_streambuf<_CharT, _Traits>* + basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb) + { + basic_streambuf<_CharT, _Traits>* __old = _M_streambuf; + _M_streambuf = __sb; + this->clear(); + return __old; + } + + template + basic_ios<_CharT, _Traits>& + basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) + { + + + if (this != std::__addressof(__rhs)) + { + + + + + _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ? + _M_local_word : new _Words[__rhs._M_word_size]; + + + _Callback_list* __cb = __rhs._M_callbacks; + if (__cb) + __cb->_M_add_reference(); + _M_call_callbacks(erase_event); + if (_M_word != _M_local_word) + { + delete [] _M_word; + _M_word = 0; + } + _M_dispose_callbacks(); + + + _M_callbacks = __cb; + for (int __i = 0; __i < __rhs._M_word_size; ++__i) + __words[__i] = __rhs._M_word[__i]; + _M_word = __words; + _M_word_size = __rhs._M_word_size; + + this->flags(__rhs.flags()); + this->width(__rhs.width()); + this->precision(__rhs.precision()); + this->tie(__rhs.tie()); + this->fill(__rhs.fill()); + _M_ios_locale = __rhs.getloc(); + _M_cache_locale(_M_ios_locale); + + _M_call_callbacks(copyfmt_event); + + + this->exceptions(__rhs.exceptions()); + } + return *this; + } + + + template + locale + basic_ios<_CharT, _Traits>::imbue(const locale& __loc) + { + locale __old(this->getloc()); + ios_base::imbue(__loc); + _M_cache_locale(__loc); + if (this->rdbuf() != 0) + this->rdbuf()->pubimbue(__loc); + return __old; + } + + template + void + basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) + { + + ios_base::_M_init(); + + + _M_cache_locale(_M_ios_locale); +# 146 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.tcc" 3 + _M_fill = _CharT(); + _M_fill_init = false; + + _M_tie = 0; + _M_exception = goodbit; + _M_streambuf = __sb; + _M_streambuf_state = __sb ? goodbit : badbit; + } + + template + void + basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) + { + _M_ctype = std::__try_use_facet<__ctype_type>(__loc); + _M_num_put = std::__try_use_facet<__num_put_type>(__loc); + _M_num_get = std::__try_use_facet<__num_get_type>(__loc); + } + + + + + extern template class basic_ios; + + + extern template class basic_ios; + + + + +} +# 517 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 2 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + template + class basic_ostream : virtual public basic_ios<_CharT, _Traits> + { + public: + + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + + + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef basic_ios<_CharT, _Traits> __ios_type; + typedef basic_ostream<_CharT, _Traits> __ostream_type; + typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > + __num_put_type; + typedef ctype<_CharT> __ctype_type; +# 85 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + explicit + basic_ostream(__streambuf_type* __sb) + { this->init(__sb); } + + + + + + + virtual + ~basic_ostream() { } + + + class sentry; + friend class sentry; +# 109 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + operator<<(__ostream_type& (*__pf)(__ostream_type&)) + { + + + + return __pf(*this); + } + + __ostream_type& + operator<<(__ios_type& (*__pf)(__ios_type&)) + { + + + + __pf(*this); + return *this; + } + + __ostream_type& + operator<<(ios_base& (*__pf) (ios_base&)) + { + + + + __pf(*this); + return *this; + } +# 167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + operator<<(long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(unsigned long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(bool __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(short __n); + + __ostream_type& + operator<<(unsigned short __n) + { + + + return _M_insert(static_cast(__n)); + } + + __ostream_type& + operator<<(int __n); + + __ostream_type& + operator<<(unsigned int __n) + { + + + return _M_insert(static_cast(__n)); + } + + + __ostream_type& + operator<<(long long __n) + { return _M_insert(__n); } + + __ostream_type& + operator<<(unsigned long long __n) + { return _M_insert(__n); } +# 221 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + operator<<(double __f) + { return _M_insert(__f); } + + __ostream_type& + operator<<(float __f) + { + + + return _M_insert(static_cast(__f)); + } + + __ostream_type& + operator<<(long double __f) + { return _M_insert(__f); } +# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + operator<<(const void* __p) + { return _M_insert(__p); } + + + __ostream_type& + operator<<(nullptr_t) + { return *this << "nullptr"; } +# 329 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + operator<<(__streambuf_type* __sb); +# 362 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + put(char_type __c); +# 381 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + write(const char_type* __s, streamsize __n); +# 394 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + flush(); +# 404 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + pos_type + tellp(); +# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + seekp(pos_type); +# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + __ostream_type& + seekp(off_type, ios_base::seekdir); + + protected: + basic_ostream() + { this->init(0); } + + + + basic_ostream(basic_iostream<_CharT, _Traits>&) { } + + basic_ostream(const basic_ostream&) = delete; + + basic_ostream(basic_ostream&& __rhs) + : __ios_type() + { __ios_type::move(__rhs); } + + + + basic_ostream& operator=(const basic_ostream&) = delete; + + basic_ostream& + operator=(basic_ostream&& __rhs) + { + swap(__rhs); + return *this; + } + + void + swap(basic_ostream& __rhs) + { __ios_type::swap(__rhs); } + + + template + __ostream_type& + _M_insert(_ValueT __v); + + private: + + void + _M_write(const char_type* __s, streamsize __n) + { std::__ostream_insert(*this, __s, __n); } + + }; +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + template + class basic_ostream<_CharT, _Traits>::sentry + { + + bool _M_ok; + basic_ostream<_CharT, _Traits>& _M_os; + + public: +# 498 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + explicit + sentry(basic_ostream<_CharT, _Traits>& __os); + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + + + + + ~sentry() + { + + if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception()) + { + + if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1) + _M_os.setstate(ios_base::badbit); + } + } +#pragma GCC diagnostic pop +# 530 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + explicit + + operator bool() const + { return _M_ok; } + }; +# 552 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) + { + if (__out.width() != 0) + return __ostream_insert(__out, &__c, 1); + __out.put(__c); + return __out; + } + + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) + { return (__out << __out.widen(__c)); } + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, char __c) + { + if (__out.width() != 0) + return __ostream_insert(__out, &__c, 1); + __out.put(__c); + return __out; + } + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, signed char __c) + { return (__out << static_cast(__c)); } + + template + inline basic_ostream& + operator<<(basic_ostream& __out, unsigned char __c) + { return (__out << static_cast(__c)); } +# 643 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) + { + if (!__s) + __out.setstate(ios_base::badbit); + else + __ostream_insert(__out, __s, + static_cast(_Traits::length(__s))); + return __out; + } + + template + basic_ostream<_CharT, _Traits> & + operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, const char* __s) + { + if (!__s) + __out.setstate(ios_base::badbit); + else + __ostream_insert(__out, __s, + static_cast(_Traits::length(__s))); + return __out; + } + + + template + inline basic_ostream& + operator<<(basic_ostream& __out, const signed char* __s) + { return (__out << reinterpret_cast(__s)); } + + template + inline basic_ostream & + operator<<(basic_ostream& __out, const unsigned char* __s) + { return (__out << reinterpret_cast(__s)); } +# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + endl(basic_ostream<_CharT, _Traits>& __os) + { return flush(__os.put(__os.widen('\n'))); } +# 745 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + template + inline basic_ostream<_CharT, _Traits>& + ends(basic_ostream<_CharT, _Traits>& __os) + { return __os.put(_CharT()); } + + + + + + + template + inline basic_ostream<_CharT, _Traits>& + flush(basic_ostream<_CharT, _Traits>& __os) + { return __os.flush(); } +# 777 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + template + using _Require_derived_from_ios_base + = _Require, __not_>, + is_convertible::type, ios_base*>>; + + template, + typename + = decltype(std::declval<_Os&>() << std::declval())> + using __rvalue_stream_insertion_t = _Os&&; +# 799 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 + template + inline __rvalue_stream_insertion_t<_Ostream, _Tp> + operator<<(_Ostream&& __os, const _Tp& __x) + { + __os << __x; + return std::move(__os); + } +# 878 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 +} + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream.tcc" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + basic_ostream<_CharT, _Traits>::sentry:: + sentry(basic_ostream<_CharT, _Traits>& __os) + : _M_ok(false), _M_os(__os) + { + + if (__os.tie() && __os.good()) + __os.tie()->flush(); + + if (__os.good()) + _M_ok = true; + else if (__os.bad()) + __os.setstate(ios_base::failbit); + } + + template + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + _M_insert(_ValueT __v) + { + sentry __cerb(*this); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + + const __num_put_type& __np = __check_facet(this->_M_num_put); + + + + + if (__np.put(*this, *this, this->fill(), __v).failed()) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + operator<<(short __n) + { + + + const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; + if (__fmt == ios_base::oct || __fmt == ios_base::hex) + return _M_insert(static_cast(static_cast(__n))); + else + return _M_insert(static_cast(__n)); + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + operator<<(int __n) + { + + + const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; + if (__fmt == ios_base::oct || __fmt == ios_base::hex) + return _M_insert(static_cast(static_cast(__n))); + else + return _M_insert(static_cast(__n)); + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + operator<<(__streambuf_type* __sbin) + { + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this); + if (__cerb && __sbin) + { + try + { + if (!__copy_streambufs(__sbin, this->rdbuf())) + __err |= ios_base::failbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::failbit); } + } + else if (!__sbin) + __err |= ios_base::badbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + put(char_type __c) + { + + + + + + + sentry __cerb(*this); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __put = this->rdbuf()->sputc(__c); + if (traits_type::eq_int_type(__put, traits_type::eof())) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + write(const _CharT* __s, streamsize __n) + { + + + + + + + + sentry __cerb(*this); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + if (this->rdbuf()->sputn(__s, __n) != __n) + __err = ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(ios_base::badbit); + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + flush() + { + + + + + + if (__streambuf_type* __buf = this->rdbuf()) + { + sentry __cerb(*this); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + if (this->rdbuf()->pubsync() == -1) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + } + return *this; + } + + template + typename basic_ostream<_CharT, _Traits>::pos_type + basic_ostream<_CharT, _Traits>:: + tellp() + { + sentry __cerb(*this); + pos_type __ret = pos_type(-1); + if (!this->fail()) + __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); + return __ret; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + seekp(pos_type __pos) + { + sentry __cerb(*this); + if (!this->fail()) + { + + + const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::out); + + + if (__p == pos_type(off_type(-1))) + this->setstate(ios_base::failbit); + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + basic_ostream<_CharT, _Traits>:: + seekp(off_type __off, ios_base::seekdir __dir) + { + sentry __cerb(*this); + if (!this->fail()) + { + + + const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, + ios_base::out); + + + if (__p == pos_type(off_type(-1))) + this->setstate(ios_base::failbit); + } + return *this; + } + + template + basic_ostream<_CharT, _Traits>& + operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s) + { + if (!__s) + __out.setstate(ios_base::badbit); + else + { + + + const size_t __clen = char_traits::length(__s); + try + { + struct __ptr_guard + { + _CharT *__p; + __ptr_guard (_CharT *__ip): __p(__ip) { } + ~__ptr_guard() { delete[] __p; } + _CharT* __get() { return __p; } + } __pg (new _CharT[__clen]); + + _CharT *__ws = __pg.__get(); + for (size_t __i = 0; __i < __clen; ++__i) + __ws[__i] = __out.widen(__s[__i]); + __ostream_insert(__out, __ws, __clen); + } + catch(__cxxabiv1::__forced_unwind&) + { + __out._M_setstate(ios_base::badbit); + throw; + } + catch(...) + { __out._M_setstate(ios_base::badbit); } + } + return __out; + } + + + + + extern template class basic_ostream; + extern template ostream& endl(ostream&); + extern template ostream& ends(ostream&); + extern template ostream& flush(ostream&); + extern template ostream& operator<<(ostream&, char); + extern template ostream& operator<<(ostream&, unsigned char); + extern template ostream& operator<<(ostream&, signed char); + extern template ostream& operator<<(ostream&, const char*); + extern template ostream& operator<<(ostream&, const unsigned char*); + extern template ostream& operator<<(ostream&, const signed char*); + + extern template ostream& ostream::_M_insert(long); + extern template ostream& ostream::_M_insert(unsigned long); + extern template ostream& ostream::_M_insert(bool); + + extern template ostream& ostream::_M_insert(long long); + extern template ostream& ostream::_M_insert(unsigned long long); + + extern template ostream& ostream::_M_insert(double); + extern template ostream& ostream::_M_insert(long double); + extern template ostream& ostream::_M_insert(const void*); + + + extern template class basic_ostream; + extern template wostream& endl(wostream&); + extern template wostream& ends(wostream&); + extern template wostream& flush(wostream&); + extern template wostream& operator<<(wostream&, wchar_t); + extern template wostream& operator<<(wostream&, char); + extern template wostream& operator<<(wostream&, const wchar_t*); + extern template wostream& operator<<(wostream&, const char*); + + extern template wostream& wostream::_M_insert(long); + extern template wostream& wostream::_M_insert(unsigned long); + extern template wostream& wostream::_M_insert(bool); + + extern template wostream& wostream::_M_insert(long long); + extern template wostream& wostream::_M_insert(unsigned long long); + + extern template wostream& wostream::_M_insert(double); + extern template wostream& wostream::_M_insert(long double); + extern template wostream& wostream::_M_insert(const void*); + + + + +} +# 881 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 2 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + template + class basic_istream : virtual public basic_ios<_CharT, _Traits> + { + public: + + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + + + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef basic_ios<_CharT, _Traits> __ios_type; + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > + __num_get_type; + typedef ctype<_CharT> __ctype_type; + + protected: + + + + + + streamsize _M_gcount; + + public: + + + + + + + + explicit + basic_istream(__streambuf_type* __sb) + : _M_gcount(streamsize(0)) + { this->init(__sb); } + + + + + + + virtual + ~basic_istream() + { _M_gcount = streamsize(0); } + + + class sentry; + friend class sentry; +# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + operator>>(__istream_type& (*__pf)(__istream_type&)) + { return __pf(*this); } + + __istream_type& + operator>>(__ios_type& (*__pf)(__ios_type&)) + { + __pf(*this); + return *this; + } + + __istream_type& + operator>>(ios_base& (*__pf)(ios_base&)) + { + __pf(*this); + return *this; + } +# 169 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + operator>>(bool& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(short& __n); + + __istream_type& + operator>>(unsigned short& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(int& __n); + + __istream_type& + operator>>(unsigned int& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(long& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(unsigned long& __n) + { return _M_extract(__n); } + + + __istream_type& + operator>>(long long& __n) + { return _M_extract(__n); } + + __istream_type& + operator>>(unsigned long long& __n) + { return _M_extract(__n); } +# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + operator>>(float& __f) + { return _M_extract(__f); } + + __istream_type& + operator>>(double& __f) + { return _M_extract(__f); } + + __istream_type& + operator>>(long double& __f) + { return _M_extract(__f); } +# 324 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + operator>>(void*& __p) + { return _M_extract(__p); } +# 348 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + operator>>(__streambuf_type* __sb); +# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + streamsize + gcount() const + { return _M_gcount; } +# 391 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + int_type + get(); +# 405 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + get(char_type& __c); +# 432 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + get(char_type* __s, streamsize __n, char_type __delim); +# 443 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + get(char_type* __s, streamsize __n) + { return this->get(__s, __n, this->widen('\n')); } +# 466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + get(__streambuf_type& __sb, char_type __delim); +# 476 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + get(__streambuf_type& __sb) + { return this->get(__sb, this->widen('\n')); } +# 505 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + getline(char_type* __s, streamsize __n, char_type __delim); +# 516 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + getline(char_type* __s, streamsize __n) + { return this->getline(__s, __n, this->widen('\n')); } +# 540 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + ignore(streamsize __n, int_type __delim); + + __istream_type& + ignore(streamsize __n); + + __istream_type& + ignore(); +# 557 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + int_type + peek(); +# 575 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + read(char_type* __s, streamsize __n); +# 594 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + streamsize + readsome(char_type* __s, streamsize __n); +# 611 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + putback(char_type __c); +# 627 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + unget(); +# 645 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + int + sync(); +# 660 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + pos_type + tellg(); +# 675 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + seekg(pos_type); +# 691 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + __istream_type& + seekg(off_type, ios_base::seekdir); + + + protected: + basic_istream() + : _M_gcount(streamsize(0)) + { this->init(0); } + + + basic_istream(const basic_istream&) = delete; + + basic_istream(basic_istream&& __rhs) + : __ios_type(), _M_gcount(__rhs._M_gcount) + { + __ios_type::move(__rhs); + __rhs._M_gcount = 0; + } + + + + basic_istream& operator=(const basic_istream&) = delete; + + basic_istream& + operator=(basic_istream&& __rhs) + { + swap(__rhs); + return *this; + } + + void + swap(basic_istream& __rhs) + { + __ios_type::swap(__rhs); + std::swap(_M_gcount, __rhs._M_gcount); + } + + + template + __istream_type& + _M_extract(_ValueT& __v); + }; + + + template<> + basic_istream& + basic_istream:: + getline(char_type* __s, streamsize __n, char_type __delim); + + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n); + + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n, int_type __delim); + + + template<> + basic_istream& + basic_istream:: + getline(char_type* __s, streamsize __n, char_type __delim); + + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n); + + template<> + basic_istream& + basic_istream:: + ignore(streamsize __n, int_type __delim); +# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + template + class basic_istream<_CharT, _Traits>::sentry + { + + bool _M_ok; + + public: + + typedef _Traits traits_type; + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::__ctype_type __ctype_type; + typedef typename _Traits::int_type __int_type; +# 811 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + explicit + sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); +# 822 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + explicit + + operator bool() const + { return _M_ok; } + }; +# 840 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); + + template + inline basic_istream& + operator>>(basic_istream& __in, unsigned char& __c) + { return (__in >> reinterpret_cast(__c)); } + + template + inline basic_istream& + operator>>(basic_istream& __in, signed char& __c) + { return (__in >> reinterpret_cast(__c)); } + + + + template + void + __istream_extract(basic_istream<_CharT, _Traits>&, _CharT*, streamsize); + + void __istream_extract(istream&, char*, streamsize); +# 890 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + template + __attribute__((__nonnull__(2), __access__(__write_only__, 2))) + inline basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) + { + + + + size_t __n = __builtin_object_size(__s, 0); + if (__n < sizeof(_CharT)) + { + + do { if (std::__is_constant_evaluated() && !bool(__n >= sizeof(_CharT))) __builtin_unreachable(); } while (false); + + __in.width(0); + __in.setstate(ios_base::failbit); + } + else if (__n != (size_t)-1) + { + __n /= sizeof(_CharT); + streamsize __w = __in.width(); + std::__istream_extract(__in, __s, __n); + if (__in.good() && (__w <= 0 || __n < __w)) + { + + + const typename _Traits::int_type __c = __in.rdbuf()->sgetc(); + const bool __eof = _Traits::eq_int_type(__c, _Traits::eof()); + if (__builtin_expect(__eof, true)) + __in.setstate(ios_base::eofbit); + } + } + else + + { + + streamsize __n = __gnu_cxx::__numeric_traits::__max; + __n /= sizeof(_CharT); + std::__istream_extract(__in, __s, __n); + } + return __in; + } + + template + __attribute__((__nonnull__(2), __access__(__write_only__, 2))) + inline basic_istream& + operator>>(basic_istream& __in, unsigned char* __s) + { return __in >> reinterpret_cast(__s); } + + template + __attribute__((__nonnull__(2), __access__(__write_only__, 2))) + inline basic_istream& + operator>>(basic_istream& __in, signed char* __s) + { return __in >> reinterpret_cast(__s); } +# 979 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + template + class basic_iostream + : public basic_istream<_CharT, _Traits>, + public basic_ostream<_CharT, _Traits> + { + public: + + + + typedef _CharT char_type; + typedef typename _Traits::int_type int_type; + typedef typename _Traits::pos_type pos_type; + typedef typename _Traits::off_type off_type; + typedef _Traits traits_type; + + + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_ostream<_CharT, _Traits> __ostream_type; + + + + + + + + explicit + basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) + : __istream_type(__sb), __ostream_type(__sb) { } + + + + + virtual + ~basic_iostream() { } + + protected: + basic_iostream() + : __istream_type(), __ostream_type() { } + + + basic_iostream(const basic_iostream&) = delete; + + basic_iostream(basic_iostream&& __rhs) + : __istream_type(std::move(__rhs)), __ostream_type(*this) + { } + + + + basic_iostream& operator=(const basic_iostream&) = delete; + + basic_iostream& + operator=(basic_iostream&& __rhs) + { + swap(__rhs); + return *this; + } + + void + swap(basic_iostream& __rhs) + { __istream_type::swap(__rhs); } + + }; +# 1062 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + template + basic_istream<_CharT, _Traits>& + ws(basic_istream<_CharT, _Traits>& __is); +# 1078 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + template, + typename = decltype(std::declval<_Is&>() >> std::declval<_Tp>())> + using __rvalue_stream_extraction_t = _Is&&; +# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 + template + inline __rvalue_stream_extraction_t<_Istream, _Tp> + operator>>(_Istream&& __is, _Tp&& __x) + { + __is >> std::forward<_Tp>(__x); + return std::move(__is); + } + + + +} + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/istream.tcc" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/istream.tcc" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + basic_istream<_CharT, _Traits>::sentry:: + sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) + { + ios_base::iostate __err = ios_base::goodbit; + if (__in.good()) + { + try + { + if (__in.tie()) + __in.tie()->flush(); + if (!__noskip && bool(__in.flags() & ios_base::skipws)) + { + const __int_type __eof = traits_type::eof(); + __streambuf_type* __sb = __in.rdbuf(); + __int_type __c = __sb->sgetc(); + + const __ctype_type& __ct = __check_facet(__in._M_ctype); + while (!traits_type::eq_int_type(__c, __eof) + && __ct.is(ctype_base::space, + traits_type::to_char_type(__c))) + __c = __sb->snextc(); + + + + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(ios_base::badbit); + throw; + } + catch(...) + { __in._M_setstate(ios_base::badbit); } + } + + if (__in.good() && __err == ios_base::goodbit) + _M_ok = true; + else + { + __err |= ios_base::failbit; + __in.setstate(__err); + } + } + + template + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + _M_extract(_ValueT& __v) + { + sentry __cerb(*this, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + + const __num_get_type& __ng = __check_facet(this->_M_num_get); + + + + + __ng.get(*this, 0, *this, __err, __v); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + operator>>(short& __n) + { + + + sentry __cerb(*this, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + long __l; + + const __num_get_type& __ng = __check_facet(this->_M_num_get); + + + + + __ng.get(*this, 0, *this, __err, __l); + + + + if (__l < __gnu_cxx::__numeric_traits::__min) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__min; + } + else if (__l > __gnu_cxx::__numeric_traits::__max) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__max; + } + else + __n = short(__l); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + operator>>(int& __n) + { + + + sentry __cerb(*this, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + long __l; + + const __num_get_type& __ng = __check_facet(this->_M_num_get); + + + + + __ng.get(*this, 0, *this, __err, __l); + + + + if (__l < __gnu_cxx::__numeric_traits::__min) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__min; + } + else if (__l > __gnu_cxx::__numeric_traits::__max) + { + __err |= ios_base::failbit; + __n = __gnu_cxx::__numeric_traits::__max; + } + else + __n = int(__l); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + operator>>(__streambuf_type* __sbout) + { + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, false); + if (__cerb && __sbout) + { + try + { + bool __ineof; + if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) + __err |= ios_base::failbit; + if (__ineof) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::failbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::failbit); } + } + else if (!__sbout) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + typename basic_istream<_CharT, _Traits>::int_type + basic_istream<_CharT, _Traits>:: + get(void) + { + const int_type __eof = traits_type::eof(); + int_type __c = __eof; + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + __c = this->rdbuf()->sbumpc(); + + if (!traits_type::eq_int_type(__c, __eof)) + _M_gcount = 1; + else + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return __c; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + get(char_type& __c) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + const int_type __cb = this->rdbuf()->sbumpc(); + + if (!traits_type::eq_int_type(__cb, traits_type::eof())) + { + _M_gcount = 1; + __c = traits_type::to_char_type(__cb); + } + else + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + get(char_type* __s, streamsize __n, char_type __delim) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + const int_type __idelim = traits_type::to_int_type(__delim); + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + while (_M_gcount + 1 < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim)) + { + *__s++ = traits_type::to_char_type(__c); + ++_M_gcount; + __c = __sb->snextc(); + } + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + + + if (__n > 0) + *__s = char_type(); + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + get(__streambuf_type& __sb, char_type __delim) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + const int_type __idelim = traits_type::to_int_type(__delim); + const int_type __eof = traits_type::eof(); + __streambuf_type* __this_sb = this->rdbuf(); + int_type __c = __this_sb->sgetc(); + char_type __c2 = traits_type::to_char_type(__c); + unsigned long long __gcount = 0; + + while (!traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim) + && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) + { + ++__gcount; + __c = __this_sb->snextc(); + __c2 = traits_type::to_char_type(__c); + } + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + + + if (__gcount <= __gnu_cxx::__numeric_traits::__max) + _M_gcount = __gcount; + else + _M_gcount = __gnu_cxx::__numeric_traits::__max; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + getline(char_type* __s, streamsize __n, char_type __delim) + { + _M_gcount = 0; + ios_base::iostate __err = ios_base::goodbit; + sentry __cerb(*this, true); + if (__cerb) + { + try + { + const int_type __idelim = traits_type::to_int_type(__delim); + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + while (_M_gcount + 1 < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __idelim)) + { + *__s++ = traits_type::to_char_type(__c); + __c = __sb->snextc(); + ++_M_gcount; + } + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + else + { + if (traits_type::eq_int_type(__c, __idelim)) + { + __sb->sbumpc(); + ++_M_gcount; + } + else + __err |= ios_base::failbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + + + if (__n > 0) + *__s = char_type(); + if (!_M_gcount) + __err |= ios_base::failbit; + if (__err) + this->setstate(__err); + return *this; + } + + + + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(void) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + + if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) + __err |= ios_base::eofbit; + else + _M_gcount = 1; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(streamsize __n) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); +# 545 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/istream.tcc" 3 + bool __large_ignore = false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof)) + { + ++_M_gcount; + __c = __sb->snextc(); + } + if (__n == __gnu_cxx::__numeric_traits::__max + && !traits_type::eq_int_type(__c, __eof)) + { + _M_gcount = + __gnu_cxx::__numeric_traits::__min; + __large_ignore = true; + } + else + break; + } + + if (__n == __gnu_cxx::__numeric_traits::__max) + { + if (__large_ignore) + _M_gcount = __gnu_cxx::__numeric_traits::__max; + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + else if (_M_gcount < __n) + { + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + ignore(streamsize __n, int_type __delim) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb && __n > 0) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + int_type __c = __sb->sgetc(); + + + bool __large_ignore = false; + while (true) + { + while (_M_gcount < __n + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __delim)) + { + ++_M_gcount; + __c = __sb->snextc(); + } + if (__n == __gnu_cxx::__numeric_traits::__max + && !traits_type::eq_int_type(__c, __eof) + && !traits_type::eq_int_type(__c, __delim)) + { + _M_gcount = + __gnu_cxx::__numeric_traits::__min; + __large_ignore = true; + } + else + break; + } + + if (__n == __gnu_cxx::__numeric_traits::__max) + { + if (__large_ignore) + _M_gcount = __gnu_cxx::__numeric_traits::__max; + + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + else + { + if (_M_gcount != __n) + ++_M_gcount; + __sb->sbumpc(); + } + } + else if (_M_gcount < __n) + { + if (traits_type::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + else + { + ++_M_gcount; + __sb->sbumpc(); + } + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + typename basic_istream<_CharT, _Traits>::int_type + basic_istream<_CharT, _Traits>:: + peek(void) + { + int_type __c = traits_type::eof(); + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + __c = this->rdbuf()->sgetc(); + if (traits_type::eq_int_type(__c, traits_type::eof())) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return __c; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + read(char_type* __s, streamsize __n) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + _M_gcount = this->rdbuf()->sgetn(__s, __n); + if (_M_gcount != __n) + __err |= (ios_base::eofbit | ios_base::failbit); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + streamsize + basic_istream<_CharT, _Traits>:: + readsome(char_type* __s, streamsize __n) + { + _M_gcount = 0; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + + const streamsize __num = this->rdbuf()->in_avail(); + if (__num > 0) + _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); + else if (__num == -1) + __err |= ios_base::eofbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return _M_gcount; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + putback(char_type __c) + { + + + _M_gcount = 0; + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + if (!__sb + || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + unget(void) + { + + + _M_gcount = 0; + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const int_type __eof = traits_type::eof(); + __streambuf_type* __sb = this->rdbuf(); + if (!__sb + || traits_type::eq_int_type(__sb->sungetc(), __eof)) + __err |= ios_base::badbit; + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + int + basic_istream<_CharT, _Traits>:: + sync(void) + { + + + int __ret = -1; + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + __streambuf_type* __sb = this->rdbuf(); + if (__sb) + { + if (__sb->pubsync() == -1) + __err |= ios_base::badbit; + else + __ret = 0; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return __ret; + } + + template + typename basic_istream<_CharT, _Traits>::pos_type + basic_istream<_CharT, _Traits>:: + tellg(void) + { + + + pos_type __ret = pos_type(-1); + sentry __cerb(*this, true); + if (__cerb) + { + try + { + if (!this->fail()) + __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, + ios_base::in); + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + } + return __ret; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + seekg(pos_type __pos) + { + + + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + if (!this->fail()) + { + + const pos_type __p = this->rdbuf()->pubseekpos(__pos, + ios_base::in); + + + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + template + basic_istream<_CharT, _Traits>& + basic_istream<_CharT, _Traits>:: + seekg(off_type __off, ios_base::seekdir __dir) + { + + + + this->clear(this->rdstate() & ~ios_base::eofbit); + sentry __cerb(*this, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + if (!this->fail()) + { + + const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, + ios_base::in); + + + if (__p == pos_type(off_type(-1))) + __err |= ios_base::failbit; + } + } + catch(__cxxabiv1::__forced_unwind&) + { + this->_M_setstate(ios_base::badbit); + throw; + } + catch(...) + { this->_M_setstate(ios_base::badbit); } + if (__err) + this->setstate(__err); + } + return *this; + } + + + template + basic_istream<_CharT, _Traits>& + operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef typename __istream_type::int_type __int_type; + + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const __int_type __cb = __in.rdbuf()->sbumpc(); + if (!_Traits::eq_int_type(__cb, _Traits::eof())) + __c = _Traits::to_char_type(__cb); + else + __err |= (ios_base::eofbit | ios_base::failbit); + } + catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(ios_base::badbit); + throw; + } + catch(...) + { __in._M_setstate(ios_base::badbit); } + if (__err) + __in.setstate(__err); + } + return __in; + } + + template + void + __istream_extract(basic_istream<_CharT, _Traits>& __in, _CharT* __s, + streamsize __num) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef typename _Traits::int_type int_type; + typedef _CharT char_type; + typedef ctype<_CharT> __ctype_type; + + streamsize __extracted = 0; + ios_base::iostate __err = ios_base::goodbit; + typename __istream_type::sentry __cerb(__in, false); + if (__cerb) + { + try + { + + streamsize __width = __in.width(); + if (0 < __width && __width < __num) + __num = __width; + + const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); + + const int_type __eof = _Traits::eof(); + __streambuf_type* __sb = __in.rdbuf(); + int_type __c = __sb->sgetc(); + + while (__extracted < __num - 1 + && !_Traits::eq_int_type(__c, __eof) + && !__ct.is(ctype_base::space, + _Traits::to_char_type(__c))) + { + *__s++ = _Traits::to_char_type(__c); + ++__extracted; + __c = __sb->snextc(); + } + + if (__extracted < __num - 1 + && _Traits::eq_int_type(__c, __eof)) + __err |= ios_base::eofbit; + + + + *__s = char_type(); + __in.width(0); + } + catch(__cxxabiv1::__forced_unwind&) + { + __in._M_setstate(ios_base::badbit); + throw; + } + catch(...) + { __in._M_setstate(ios_base::badbit); } + } + if (!__extracted) + __err |= ios_base::failbit; + if (__err) + __in.setstate(__err); + } + + + template + basic_istream<_CharT, _Traits>& + ws(basic_istream<_CharT, _Traits>& __in) + { + typedef basic_istream<_CharT, _Traits> __istream_type; + typedef basic_streambuf<_CharT, _Traits> __streambuf_type; + typedef typename __istream_type::int_type __int_type; + typedef ctype<_CharT> __ctype_type; + + + + typename __istream_type::sentry __cerb(__in, true); + if (__cerb) + { + ios_base::iostate __err = ios_base::goodbit; + try + { + const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); + const __int_type __eof = _Traits::eof(); + __streambuf_type* __sb = __in.rdbuf(); + __int_type __c = __sb->sgetc(); + + while (true) + { + if (_Traits::eq_int_type(__c, __eof)) + { + __err = ios_base::eofbit; + break; + } + if (!__ct.is(ctype_base::space, _Traits::to_char_type(__c))) + break; + __c = __sb->snextc(); + } + } + catch(const __cxxabiv1::__forced_unwind&) + { + __in._M_setstate(ios_base::badbit); + throw; + } + catch(...) + { + __in._M_setstate(ios_base::badbit); + } + if (__err) + __in.setstate(__err); + } + return __in; + } + + + + + extern template class basic_istream; + extern template istream& ws(istream&); + extern template istream& operator>>(istream&, char&); + extern template istream& operator>>(istream&, unsigned char&); + extern template istream& operator>>(istream&, signed char&); + + extern template istream& istream::_M_extract(unsigned short&); + extern template istream& istream::_M_extract(unsigned int&); + extern template istream& istream::_M_extract(long&); + extern template istream& istream::_M_extract(unsigned long&); + extern template istream& istream::_M_extract(bool&); + + extern template istream& istream::_M_extract(long long&); + extern template istream& istream::_M_extract(unsigned long long&); + + extern template istream& istream::_M_extract(float&); + extern template istream& istream::_M_extract(double&); + extern template istream& istream::_M_extract(long double&); + extern template istream& istream::_M_extract(void*&); + + extern template class basic_iostream; + + + extern template class basic_istream; + extern template wistream& ws(wistream&); + extern template wistream& operator>>(wistream&, wchar_t&); + extern template void __istream_extract(wistream&, wchar_t*, streamsize); + + extern template wistream& wistream::_M_extract(unsigned short&); + extern template wistream& wistream::_M_extract(unsigned int&); + extern template wistream& wistream::_M_extract(long&); + extern template wistream& wistream::_M_extract(unsigned long&); + extern template wistream& wistream::_M_extract(bool&); + + extern template wistream& wistream::_M_extract(long long&); + extern template wistream& wistream::_M_extract(unsigned long long&); + + extern template wistream& wistream::_M_extract(float&); + extern template wistream& wistream::_M_extract(double&); + extern template wistream& wistream::_M_extract(long double&); + extern template wistream& wistream::_M_extract(void*&); + + extern template class basic_iostream; + + + + +} +# 1107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 2 3 +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + class codecvt_base + { + public: + enum result + { + ok, + partial, + error, + noconv + }; + }; +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 + template + class __codecvt_abstract_base + : public locale::facet, public codecvt_base + { + public: + + typedef codecvt_base::result result; + typedef _InternT intern_type; + typedef _ExternT extern_type; + typedef _StateT state_type; +# 118 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 + result + out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const + { + return this->do_out(__state, __from, __from_end, __from_next, + __to, __to_end, __to_next); + } +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 + result + unshift(state_type& __state, extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const + { return this->do_unshift(__state, __to,__to_end,__to_next); } +# 198 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 + result + in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const + { + return this->do_in(__state, __from, __from_end, __from_next, + __to, __to_end, __to_next); + } + + int + encoding() const throw() + { return this->do_encoding(); } + + bool + always_noconv() const throw() + { return this->do_always_noconv(); } + + int + length(state_type& __state, const extern_type* __from, + const extern_type* __end, size_t __max) const + { return this->do_length(__state, __from, __end, __max); } + + int + max_length() const throw() + { return this->do_max_length(); } + + protected: + explicit + __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { } + + virtual + ~__codecvt_abstract_base() { } +# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const = 0; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const = 0; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const = 0; + + virtual int + do_encoding() const throw() = 0; + + virtual bool + do_always_noconv() const throw() = 0; + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const = 0; + + virtual int + do_max_length() const throw() = 0; + }; +# 276 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 + template + class codecvt + : public __codecvt_abstract_base<_InternT, _ExternT, _StateT> + { + public: + + typedef codecvt_base::result result; + typedef _InternT intern_type; + typedef _ExternT extern_type; + typedef _StateT state_type; + + protected: + __c_locale _M_c_locale_codecvt; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs = 0) + : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs), + _M_c_locale_codecvt(0) + { } + + explicit + codecvt(__c_locale __cloc, size_t __refs = 0); + + protected: + virtual + ~codecvt() { } + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual int + do_encoding() const throw(); + + virtual bool + do_always_noconv() const throw(); + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + template + locale::id codecvt<_InternT, _ExternT, _StateT>::id; + + + template<> + class codecvt + : public __codecvt_abstract_base + { + friend class messages; + + public: + + typedef char intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + protected: + __c_locale _M_c_locale_codecvt; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs = 0); + + explicit + codecvt(__c_locale __cloc, size_t __refs = 0); + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, extern_type* __to, + extern_type* __to_end, extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, const extern_type* __from, + const extern_type* __from_end, const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual int + do_encoding() const throw(); + + virtual bool + do_always_noconv() const throw(); + + virtual int + do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + + + + + + template<> + class codecvt + : public __codecvt_abstract_base + { + friend class messages; + + public: + + typedef wchar_t intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + protected: + __c_locale _M_c_locale_codecvt; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs = 0); + + explicit + codecvt(__c_locale __cloc, size_t __refs = 0); + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, + const extern_type* __from, const extern_type* __from_end, + const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual + int do_encoding() const throw(); + + virtual + bool do_always_noconv() const throw(); + + virtual + int do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + + + + + + + template<> + class codecvt + : public __codecvt_abstract_base + { + public: + + typedef char16_t intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs = 0) + : __codecvt_abstract_base(__refs) { } + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, + const extern_type* __from, const extern_type* __from_end, + const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual + int do_encoding() const throw(); + + virtual + bool do_always_noconv() const throw(); + + virtual + int do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; + + + + + + template<> + class codecvt + : public __codecvt_abstract_base + { + public: + + typedef char32_t intern_type; + typedef char extern_type; + typedef mbstate_t state_type; + + public: + static locale::id id; + + explicit + codecvt(size_t __refs = 0) + : __codecvt_abstract_base(__refs) { } + + protected: + virtual + ~codecvt(); + + virtual result + do_out(state_type& __state, const intern_type* __from, + const intern_type* __from_end, const intern_type*& __from_next, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_unshift(state_type& __state, + extern_type* __to, extern_type* __to_end, + extern_type*& __to_next) const; + + virtual result + do_in(state_type& __state, + const extern_type* __from, const extern_type* __from_end, + const extern_type*& __from_next, + intern_type* __to, intern_type* __to_end, + intern_type*& __to_next) const; + + virtual + int do_encoding() const throw(); + + virtual + bool do_always_noconv() const throw(); + + virtual + int do_length(state_type&, const extern_type* __from, + const extern_type* __end, size_t __max) const; + + virtual int + do_max_length() const throw(); + }; +# 698 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 + template + class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> + { + public: + explicit + codecvt_byname(const char* __s, size_t __refs = 0) + : codecvt<_InternT, _ExternT, _StateT>(__refs) + { + if (__builtin_strcmp(__s, "C") != 0 + && __builtin_strcmp(__s, "POSIX") != 0) + { + this->_S_destroy_c_locale(this->_M_c_locale_codecvt); + this->_S_create_c_locale(this->_M_c_locale_codecvt, __s); + } + } + + + explicit + codecvt_byname(const string& __s, size_t __refs = 0) + : codecvt_byname(__s.c_str(), __refs) { } + + + protected: + virtual + ~codecvt_byname() { } + }; + + + template<> + class codecvt_byname + : public codecvt + { + public: + explicit + codecvt_byname(const char*, size_t __refs = 0) + : codecvt(__refs) { } + + explicit + codecvt_byname(const string& __s, size_t __refs = 0) + : codecvt_byname(__s.c_str(), __refs) { } + + protected: + virtual + ~codecvt_byname() { } + }; + + template<> + class codecvt_byname + : public codecvt + { + public: + explicit + codecvt_byname(const char*, size_t __refs = 0) + : codecvt(__refs) { } + + explicit + codecvt_byname(const string& __s, size_t __refs = 0) + : codecvt_byname(__s.c_str(), __refs) { } + + protected: + virtual + ~codecvt_byname() { } + }; +# 805 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 + extern template class codecvt_byname; + + extern template + const codecvt& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + extern template class codecvt_byname; + + extern template + const codecvt& + use_facet >(const locale&); + + extern template + bool + has_facet >(const locale&); + + + + extern template class codecvt_byname; + extern template class codecvt_byname; +# 841 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 +# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/basic_file.h" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/basic_file.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++io.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++io.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++io.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++io.h" 3 + typedef __gthread_mutex_t __c_lock; + + + + typedef FILE __c_file; + + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/basic_file.h" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + class __basic_file; + + + template<> + class __basic_file + { + + __c_file* _M_cfile; + + + bool _M_cfile_created; + + public: + __basic_file(__c_lock* __lock = 0) throw (); + + + __basic_file(__basic_file&& __rv, __c_lock* = 0) noexcept + : _M_cfile(__rv._M_cfile), _M_cfile_created(__rv._M_cfile_created) + { + __rv._M_cfile = nullptr; + __rv._M_cfile_created = false; + } + + __basic_file& operator=(const __basic_file&) = delete; + __basic_file& operator=(__basic_file&&) = delete; + + void + swap(__basic_file& __f) noexcept + { + std::swap(_M_cfile, __f._M_cfile); + std::swap(_M_cfile_created, __f._M_cfile_created); + } + + + __basic_file* + open(const char* __name, ios_base::openmode __mode, int __prot = 0664); + + + + + + + __basic_file* + sys_open(__c_file* __file, ios_base::openmode); + + __basic_file* + sys_open(int __fd, ios_base::openmode __mode) throw (); + + __basic_file* + close(); + + __attribute__ ((__pure__)) bool + is_open() const throw (); + + __attribute__ ((__pure__)) int + fd() throw (); + + __attribute__ ((__pure__)) __c_file* + file() throw (); + + ~__basic_file(); + + streamsize + xsputn(const char* __s, streamsize __n); + + streamsize + xsputn_2(const char* __s1, streamsize __n1, + const char* __s2, streamsize __n2); + + streamsize + xsgetn(char* __s, streamsize __n); + + streamoff + seekoff(streamoff __off, ios_base::seekdir __way) throw (); + + int + sync(); + + streamsize + showmanyc(); + }; + + +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 +# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template().make_preferred().filename())> + using _If_fs_path = enable_if_t, _Result>; +# 86 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template + class basic_filebuf : public basic_streambuf<_CharT, _Traits> + { + + template + using __chk_state = __and_, + is_copy_constructible<_Tp>, + is_default_constructible<_Tp>>; + + static_assert(__chk_state::value, + "state_type must be CopyAssignable, CopyConstructible" + " and DefaultConstructible"); + + static_assert(is_same>::value, + "pos_type must be fpos"); + + public: + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + typedef basic_streambuf __streambuf_type; + typedef basic_filebuf __filebuf_type; + typedef __basic_file __file_type; + typedef typename traits_type::state_type __state_type; + typedef codecvt __codecvt_type; + + friend class ios_base; + + protected: + + + __c_lock _M_lock; + + + __file_type _M_file; + + + ios_base::openmode _M_mode; + + + __state_type _M_state_beg; + + + + + __state_type _M_state_cur; + + + + __state_type _M_state_last; + + + char_type* _M_buf; + + + + + + + size_t _M_buf_size; + + + bool _M_buf_allocated; +# 162 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + bool _M_reading; + bool _M_writing; + + + + + + + + char_type _M_pback; + char_type* _M_pback_cur_save; + char_type* _M_pback_end_save; + bool _M_pback_init; + + + + const __codecvt_type* _M_codecvt; + + + + + + + char* _M_ext_buf; + + + + + streamsize _M_ext_buf_size; + + + + + + + const char* _M_ext_next; + char* _M_ext_end; + + + + + + + void + _M_create_pback() + { + if (!_M_pback_init) + { + _M_pback_cur_save = this->gptr(); + _M_pback_end_save = this->egptr(); + this->setg(&_M_pback, &_M_pback, &_M_pback + 1); + _M_pback_init = true; + } + } + + + + + + + void + _M_destroy_pback() throw() + { + if (_M_pback_init) + { + + _M_pback_cur_save += this->gptr() != this->eback(); + this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save); + _M_pback_init = false; + } + } + + public: + + + + + + + + basic_filebuf(); + + + basic_filebuf(const basic_filebuf&) = delete; + basic_filebuf(basic_filebuf&&); + + + + + + virtual + ~basic_filebuf() + { + try + { this->close(); } + catch(...) + { } + } + + + basic_filebuf& operator=(const basic_filebuf&) = delete; + basic_filebuf& operator=(basic_filebuf&&); + void swap(basic_filebuf&); + + + + + + + bool + is_open() const throw() + { return _M_file.is_open(); } +# 316 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + __filebuf_type* + open(const char* __s, ios_base::openmode __mode); +# 337 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + __filebuf_type* + open(const std::string& __s, ios_base::openmode __mode) + { return open(__s.c_str(), __mode); } +# 348 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template + _If_fs_path<_Path, __filebuf_type*> + open(const _Path& __s, ios_base::openmode __mode) + { return open(__s.c_str(), __mode); } +# 367 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + __filebuf_type* + close(); + + protected: + void + _M_allocate_internal_buffer(); + + void + _M_destroy_internal_buffer() throw(); + + + virtual streamsize + showmanyc(); + + + + + + + virtual int_type + underflow(); + + virtual int_type + pbackfail(int_type __c = _Traits::eof()); +# 399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + virtual int_type + overflow(int_type __c = _Traits::eof()); + + + + bool + _M_convert_to_external(char_type*, streamsize); +# 419 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + virtual __streambuf_type* + setbuf(char_type* __s, streamsize __n); + + virtual pos_type + seekoff(off_type __off, ios_base::seekdir __way, + ios_base::openmode __mode = ios_base::in | ios_base::out); + + virtual pos_type + seekpos(pos_type __pos, + ios_base::openmode __mode = ios_base::in | ios_base::out); + + + pos_type + _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); + + int + _M_get_ext_pos(__state_type &__state); + + virtual int + sync(); + + virtual void + imbue(const locale& __loc); + + virtual streamsize + xsgetn(char_type* __s, streamsize __n); + + virtual streamsize + xsputn(const char_type* __s, streamsize __n); + + + bool + _M_terminate_output(); +# 465 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + _M_set_buffer(streamsize __off) + { + const bool __testin = _M_mode & ios_base::in; + const bool __testout = (_M_mode & ios_base::out + || _M_mode & ios_base::app); + + if (__testin && __off > 0) + this->setg(_M_buf, _M_buf, _M_buf + __off); + else + this->setg(_M_buf, _M_buf, _M_buf); + + if (__testout && __off == 0 && _M_buf_size > 1 ) + this->setp(_M_buf, _M_buf + _M_buf_size - 1); + else + this->setp(0, 0); + } + }; +# 498 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template + class basic_ifstream : public basic_istream<_CharT, _Traits> + { + public: + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + + typedef basic_filebuf __filebuf_type; + typedef basic_istream __istream_type; + + private: + __filebuf_type _M_filebuf; + + public: +# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + basic_ifstream() : __istream_type(), _M_filebuf() + { this->init(&_M_filebuf); } +# 535 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + explicit + basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in) + : __istream_type(), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } +# 568 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + explicit + basic_ifstream(const std::string& __s, + ios_base::openmode __mode = ios_base::in) + : __istream_type(), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } +# 585 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template> + basic_ifstream(const _Path& __s, + ios_base::openmode __mode = ios_base::in) + : basic_ifstream(__s.c_str(), __mode) + { } + + + basic_ifstream(const basic_ifstream&) = delete; + + basic_ifstream(basic_ifstream&& __rhs) + : __istream_type(std::move(__rhs)), + _M_filebuf(std::move(__rhs._M_filebuf)) + { __istream_type::set_rdbuf(&_M_filebuf); } +# 606 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + ~basic_ifstream() + { } + + + + + basic_ifstream& + operator=(const basic_ifstream&) = delete; + + basic_ifstream& + operator=(basic_ifstream&& __rhs) + { + __istream_type::operator=(std::move(__rhs)); + _M_filebuf = std::move(__rhs._M_filebuf); + return *this; + } + + void + swap(basic_ifstream& __rhs) + { + __istream_type::swap(__rhs); + _M_filebuf.swap(__rhs._M_filebuf); + } +# 638 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + __filebuf_type* + rdbuf() const + { return const_cast<__filebuf_type*>(&_M_filebuf); } + + + + + + bool + is_open() + { return _M_filebuf.is_open(); } + + + + bool + is_open() const + { return _M_filebuf.is_open(); } +# 664 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + open(const char* __s, ios_base::openmode __mode = ios_base::in) + { + if (!_M_filebuf.open(__s, __mode | ios_base::in)) + this->setstate(ios_base::failbit); + else + + + this->clear(); + } +# 703 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + open(const std::string& __s, ios_base::openmode __mode = ios_base::in) + { + if (!_M_filebuf.open(__s, __mode | ios_base::in)) + this->setstate(ios_base::failbit); + else + + + this->clear(); + } +# 723 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template + _If_fs_path<_Path, void> + open(const _Path& __s, ios_base::openmode __mode = ios_base::in) + { open(__s.c_str(), __mode); } +# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + close() + { + if (!_M_filebuf.close()) + this->setstate(ios_base::failbit); + } + }; +# 759 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template + class basic_ofstream : public basic_ostream<_CharT,_Traits> + { + public: + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + + typedef basic_filebuf __filebuf_type; + typedef basic_ostream __ostream_type; + + private: + __filebuf_type _M_filebuf; + + public: +# 786 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + basic_ofstream(): __ostream_type(), _M_filebuf() + { this->init(&_M_filebuf); } +# 796 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + explicit + basic_ofstream(const char* __s, + ios_base::openmode __mode = ios_base::out) + : __ostream_type(), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } +# 831 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + explicit + basic_ofstream(const std::string& __s, + ios_base::openmode __mode = ios_base::out) + : __ostream_type(), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } +# 848 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template> + basic_ofstream(const _Path& __s, + ios_base::openmode __mode = ios_base::out) + : basic_ofstream(__s.c_str(), __mode) + { } + + + basic_ofstream(const basic_ofstream&) = delete; + + basic_ofstream(basic_ofstream&& __rhs) + : __ostream_type(std::move(__rhs)), + _M_filebuf(std::move(__rhs._M_filebuf)) + { __ostream_type::set_rdbuf(&_M_filebuf); } +# 869 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + ~basic_ofstream() + { } + + + + + basic_ofstream& + operator=(const basic_ofstream&) = delete; + + basic_ofstream& + operator=(basic_ofstream&& __rhs) + { + __ostream_type::operator=(std::move(__rhs)); + _M_filebuf = std::move(__rhs._M_filebuf); + return *this; + } + + void + swap(basic_ofstream& __rhs) + { + __ostream_type::swap(__rhs); + _M_filebuf.swap(__rhs._M_filebuf); + } +# 901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + __filebuf_type* + rdbuf() const + { return const_cast<__filebuf_type*>(&_M_filebuf); } + + + + + + bool + is_open() + { return _M_filebuf.is_open(); } + + + + bool + is_open() const + { return _M_filebuf.is_open(); } +# 927 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + open(const char* __s, ios_base::openmode __mode = ios_base::out) + { + if (!_M_filebuf.open(__s, __mode | ios_base::out)) + this->setstate(ios_base::failbit); + else + + + this->clear(); + } +# 966 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + open(const std::string& __s, ios_base::openmode __mode = ios_base::out) + { + if (!_M_filebuf.open(__s, __mode | ios_base::out)) + this->setstate(ios_base::failbit); + else + + + this->clear(); + } +# 986 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template + _If_fs_path<_Path, void> + open(const _Path& __s, ios_base::openmode __mode = ios_base::out) + { open(__s.c_str(), __mode); } +# 999 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + close() + { + if (!_M_filebuf.close()) + this->setstate(ios_base::failbit); + } + }; +# 1022 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template + class basic_fstream : public basic_iostream<_CharT, _Traits> + { + public: + + typedef _CharT char_type; + typedef _Traits traits_type; + typedef typename traits_type::int_type int_type; + typedef typename traits_type::pos_type pos_type; + typedef typename traits_type::off_type off_type; + + + typedef basic_filebuf __filebuf_type; + typedef basic_ios __ios_type; + typedef basic_iostream __iostream_type; + + private: + __filebuf_type _M_filebuf; + + public: +# 1050 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + basic_fstream() + : __iostream_type(), _M_filebuf() + { this->init(&_M_filebuf); } + + + + + + + explicit + basic_fstream(const char* __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + : __iostream_type(0), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } +# 1089 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + explicit + basic_fstream(const std::string& __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + : __iostream_type(0), _M_filebuf() + { + this->init(&_M_filebuf); + this->open(__s, __mode); + } + + + + + + + + template> + basic_fstream(const _Path& __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + : basic_fstream(__s.c_str(), __mode) + { } + + + basic_fstream(const basic_fstream&) = delete; + + basic_fstream(basic_fstream&& __rhs) + : __iostream_type(std::move(__rhs)), + _M_filebuf(std::move(__rhs._M_filebuf)) + { __iostream_type::set_rdbuf(&_M_filebuf); } +# 1125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + ~basic_fstream() + { } + + + + + basic_fstream& + operator=(const basic_fstream&) = delete; + + basic_fstream& + operator=(basic_fstream&& __rhs) + { + __iostream_type::operator=(std::move(__rhs)); + _M_filebuf = std::move(__rhs._M_filebuf); + return *this; + } + + void + swap(basic_fstream& __rhs) + { + __iostream_type::swap(__rhs); + _M_filebuf.swap(__rhs._M_filebuf); + } +# 1157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + __filebuf_type* + rdbuf() const + { return const_cast<__filebuf_type*>(&_M_filebuf); } + + + + + + bool + is_open() + { return _M_filebuf.is_open(); } + + + + bool + is_open() const + { return _M_filebuf.is_open(); } +# 1183 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + open(const char* __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { + if (!_M_filebuf.open(__s, __mode)) + this->setstate(ios_base::failbit); + else + + + this->clear(); + } +# 1224 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + open(const std::string& __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { + if (!_M_filebuf.open(__s, __mode)) + this->setstate(ios_base::failbit); + else + + + this->clear(); + } +# 1245 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + template + _If_fs_path<_Path, void> + open(const _Path& __s, + ios_base::openmode __mode = ios_base::in | ios_base::out) + { open(__s.c_str(), __mode); } +# 1259 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 + void + close() + { + if (!_M_filebuf.close()) + this->setstate(ios_base::failbit); + } + }; + + + + template + inline void + swap(basic_filebuf<_CharT, _Traits>& __x, + basic_filebuf<_CharT, _Traits>& __y) + { __x.swap(__y); } + + + template + inline void + swap(basic_ifstream<_CharT, _Traits>& __x, + basic_ifstream<_CharT, _Traits>& __y) + { __x.swap(__y); } + + + template + inline void + swap(basic_ofstream<_CharT, _Traits>& __x, + basic_ofstream<_CharT, _Traits>& __y) + { __x.swap(__y); } + + + template + inline void + swap(basic_fstream<_CharT, _Traits>& __x, + basic_fstream<_CharT, _Traits>& __y) + { __x.swap(__y); } + + + +} + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/fstream.tcc" 1 3 +# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/fstream.tcc" 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/fstream.tcc" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + void + basic_filebuf<_CharT, _Traits>:: + _M_allocate_internal_buffer() + { + + + if (!_M_buf_allocated && !_M_buf) + { + _M_buf = new char_type[_M_buf_size]; + _M_buf_allocated = true; + } + } + + template + void + basic_filebuf<_CharT, _Traits>:: + _M_destroy_internal_buffer() throw() + { + if (_M_buf_allocated) + { + delete [] _M_buf; + _M_buf = 0; + _M_buf_allocated = false; + } + delete [] _M_ext_buf; + _M_ext_buf = 0; + _M_ext_buf_size = 0; + _M_ext_next = 0; + _M_ext_end = 0; + } + + template + basic_filebuf<_CharT, _Traits>:: + basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock), + _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(), + _M_state_last(), _M_buf(0), _M_buf_size(8192), + _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(), + _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false), + _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0), + _M_ext_end(0) + { + _M_codecvt = std::__try_use_facet<__codecvt_type>(this->_M_buf_locale); + } + + + template + basic_filebuf<_CharT, _Traits>:: + basic_filebuf(basic_filebuf&& __rhs) + : __streambuf_type(__rhs), + _M_lock(), _M_file(std::move(__rhs._M_file), &_M_lock), + _M_mode(std::__exchange(__rhs._M_mode, ios_base::openmode(0))), + _M_state_beg(std::move(__rhs._M_state_beg)), + _M_state_cur(std::move(__rhs._M_state_cur)), + _M_state_last(std::move(__rhs._M_state_last)), + _M_buf(std::__exchange(__rhs._M_buf, nullptr)), + _M_buf_size(std::__exchange(__rhs._M_buf_size, 1)), + _M_buf_allocated(std::__exchange(__rhs._M_buf_allocated, false)), + _M_reading(std::__exchange(__rhs._M_reading, false)), + _M_writing(std::__exchange(__rhs._M_writing, false)), + _M_pback(__rhs._M_pback), + _M_pback_cur_save(std::__exchange(__rhs._M_pback_cur_save, nullptr)), + _M_pback_end_save(std::__exchange(__rhs._M_pback_end_save, nullptr)), + _M_pback_init(std::__exchange(__rhs._M_pback_init, false)), + _M_codecvt(__rhs._M_codecvt), + _M_ext_buf(std::__exchange(__rhs._M_ext_buf, nullptr)), + _M_ext_buf_size(std::__exchange(__rhs._M_ext_buf_size, 0)), + _M_ext_next(std::__exchange(__rhs._M_ext_next, nullptr)), + _M_ext_end(std::__exchange(__rhs._M_ext_end, nullptr)) + { + __rhs._M_set_buffer(-1); + __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg; + } + + template + basic_filebuf<_CharT, _Traits>& + basic_filebuf<_CharT, _Traits>:: + operator=(basic_filebuf&& __rhs) + { + this->close(); + __streambuf_type::operator=(__rhs); + _M_file.swap(__rhs._M_file); + _M_mode = std::__exchange(__rhs._M_mode, ios_base::openmode(0)); + _M_state_beg = std::move(__rhs._M_state_beg); + _M_state_cur = std::move(__rhs._M_state_cur); + _M_state_last = std::move(__rhs._M_state_last); + _M_buf = std::__exchange(__rhs._M_buf, nullptr); + _M_buf_size = std::__exchange(__rhs._M_buf_size, 1); + _M_buf_allocated = std::__exchange(__rhs._M_buf_allocated, false); + _M_ext_buf = std::__exchange(__rhs._M_ext_buf, nullptr); + _M_ext_buf_size = std::__exchange(__rhs._M_ext_buf_size, 0); + _M_ext_next = std::__exchange(__rhs._M_ext_next, nullptr); + _M_ext_end = std::__exchange(__rhs._M_ext_end, nullptr); + _M_reading = std::__exchange(__rhs._M_reading, false); + _M_writing = std::__exchange(__rhs._M_writing, false); + _M_pback_cur_save = std::__exchange(__rhs._M_pback_cur_save, nullptr); + _M_pback_end_save = std::__exchange(__rhs._M_pback_end_save, nullptr); + _M_pback_init = std::__exchange(__rhs._M_pback_init, false); + __rhs._M_set_buffer(-1); + __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg; + return *this; + } + + template + void + basic_filebuf<_CharT, _Traits>:: + swap(basic_filebuf& __rhs) + { + __streambuf_type::swap(__rhs); + _M_file.swap(__rhs._M_file); + std::swap(_M_mode, __rhs._M_mode); + std::swap(_M_state_beg, __rhs._M_state_beg); + std::swap(_M_state_cur, __rhs._M_state_cur); + std::swap(_M_state_last, __rhs._M_state_last); + std::swap(_M_buf, __rhs._M_buf); + std::swap(_M_buf_size, __rhs._M_buf_size); + std::swap(_M_buf_allocated, __rhs._M_buf_allocated); + std::swap(_M_ext_buf, __rhs._M_ext_buf); + std::swap(_M_ext_buf_size, __rhs._M_ext_buf_size); + std::swap(_M_ext_next, __rhs._M_ext_next); + std::swap(_M_ext_end, __rhs._M_ext_end); + std::swap(_M_reading, __rhs._M_reading); + std::swap(_M_writing, __rhs._M_writing); + std::swap(_M_pback_cur_save, __rhs._M_pback_cur_save); + std::swap(_M_pback_end_save, __rhs._M_pback_end_save); + std::swap(_M_pback_init, __rhs._M_pback_init); + } + + + template + typename basic_filebuf<_CharT, _Traits>::__filebuf_type* + basic_filebuf<_CharT, _Traits>:: + open(const char* __s, ios_base::openmode __mode) + { + __filebuf_type *__ret = 0; + if (!this->is_open()) + { + _M_file.open(__s, __mode); + if (this->is_open()) + { + _M_allocate_internal_buffer(); + _M_mode = __mode; + + + _M_reading = false; + _M_writing = false; + _M_set_buffer(-1); + + + _M_state_last = _M_state_cur = _M_state_beg; + + + if ((__mode & ios_base::ate) + && this->seekoff(0, ios_base::end, __mode) + == pos_type(off_type(-1))) + this->close(); + else + __ret = this; + } + } + return __ret; + } +# 246 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/fstream.tcc" 3 + template + typename basic_filebuf<_CharT, _Traits>::__filebuf_type* + basic_filebuf<_CharT, _Traits>:: + close() + { + if (!this->is_open()) + return 0; + + bool __testfail = false; + { + + struct __close_sentry + { + basic_filebuf *__fb; + __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { } + ~__close_sentry () + { + __fb->_M_mode = ios_base::openmode(0); + __fb->_M_pback_init = false; + __fb->_M_destroy_internal_buffer(); + __fb->_M_reading = false; + __fb->_M_writing = false; + __fb->_M_set_buffer(-1); + __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg; + } + } __cs (this); + + try + { + if (!_M_terminate_output()) + __testfail = true; + } + catch(...) + { + _M_file.close(); + throw; + } + } + + if (!_M_file.close()) + __testfail = true; + + if (__testfail) + return 0; + else + return this; + } + + template + streamsize + basic_filebuf<_CharT, _Traits>:: + showmanyc() + { + streamsize __ret = -1; + const bool __testin = _M_mode & ios_base::in; + if (__testin && this->is_open()) + { + + + __ret = this->egptr() - this->gptr(); + + + + + + + + if (__check_facet(_M_codecvt).encoding() >= 0) + + __ret += _M_file.showmanyc() / _M_codecvt->max_length(); + } + return __ret; + } + + template + typename basic_filebuf<_CharT, _Traits>::int_type + basic_filebuf<_CharT, _Traits>:: + underflow() + { + int_type __ret = traits_type::eof(); + const bool __testin = _M_mode & ios_base::in; + if (__testin) + { + if (_M_writing) + { + if (overflow() == traits_type::eof()) + return __ret; + _M_set_buffer(-1); + _M_writing = false; + } + + + + _M_destroy_pback(); + + if (this->gptr() < this->egptr()) + return traits_type::to_int_type(*this->gptr()); + + + const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; + + + bool __got_eof = false; + + streamsize __ilen = 0; + codecvt_base::result __r = codecvt_base::ok; + if (__check_facet(_M_codecvt).always_noconv()) + { + __ilen = _M_file.xsg \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/descriptors/__cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/descriptors/__cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp new file mode 100644 index 0000000..dc239d3 --- /dev/null +++ b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/descriptors/__cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp @@ -0,0 +1,34132 @@ +# 1 "src/renderer/descriptors/vk_descriptor_set.cpp" +# 1 "" 1 +# 1 "" 3 +# 433 "" 3 +# 1 "" 1 +# 1 "" 2 +# 1 "src/renderer/descriptors/vk_descriptor_set.cpp" 2 +# 13 "src/renderer/descriptors/vk_descriptor_set.cpp" +# 1 "src/renderer/descriptors/vk_descriptor_set.h" 1 +# 16 "src/renderer/descriptors/vk_descriptor_set.h" +# 1 "third_party/volk.h" 1 +# 50 "third_party/volk.h" +# 1 "/usr/include/vulkan/vulkan.h" 1 3 4 +# 10 "/usr/include/vulkan/vulkan.h" 3 4 +# 1 "/usr/include/vulkan/vk_platform.h" 1 3 4 +# 15 "/usr/include/vulkan/vk_platform.h" 3 4 +extern "C" +{ +# 62 "/usr/include/vulkan/vk_platform.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 35 "/usr/lib/clang/16/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 109 "/usr/lib/clang/16/include/stddef.h" 3 4 +# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 4 +# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 4 +typedef struct { + long long __clang_max_align_nonce1 + __attribute__((__aligned__(__alignof__(long long)))); + long double __clang_max_align_nonce2 + __attribute__((__aligned__(__alignof__(long double)))); +} max_align_t; +# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 4 +# 63 "/usr/include/vulkan/vk_platform.h" 2 3 4 +# 76 "/usr/include/vulkan/vk_platform.h" 3 4 +# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 4 +# 52 "/usr/lib/clang/16/include/stdint.h" 3 4 +# 1 "/usr/include/stdint.h" 1 3 4 +# 26 "/usr/include/stdint.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 33 "/usr/include/bits/libc-header-start.h" 3 4 +# 1 "/usr/include/features.h" 1 3 4 +# 394 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 395 "/usr/include/features.h" 2 3 4 +# 481 "/usr/include/features.h" 3 4 +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 482 "/usr/include/features.h" 2 3 4 +# 503 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 576 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 577 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 578 "/usr/include/sys/cdefs.h" 2 3 4 +# 504 "/usr/include/features.h" 2 3 4 +# 527 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 528 "/usr/include/features.h" 2 3 4 +# 34 "/usr/include/bits/libc-header-start.h" 2 3 4 +# 27 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 28 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/wchar.h" 1 3 4 +# 29 "/usr/include/stdint.h" 2 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 30 "/usr/include/stdint.h" 2 3 4 + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 35 "/usr/include/stdint.h" 2 3 4 + + +# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-uintn.h" 3 4 +typedef __uint8_t uint8_t; +typedef __uint16_t uint16_t; +typedef __uint32_t uint32_t; +typedef __uint64_t uint64_t; +# 38 "/usr/include/stdint.h" 2 3 4 + + + + + +typedef __int_least8_t int_least8_t; +typedef __int_least16_t int_least16_t; +typedef __int_least32_t int_least32_t; +typedef __int_least64_t int_least64_t; + + +typedef __uint_least8_t uint_least8_t; +typedef __uint_least16_t uint_least16_t; +typedef __uint_least32_t uint_least32_t; +typedef __uint_least64_t uint_least64_t; + + + + + +typedef signed char int_fast8_t; + +typedef long int int_fast16_t; +typedef long int int_fast32_t; +typedef long int int_fast64_t; +# 71 "/usr/include/stdint.h" 3 4 +typedef unsigned char uint_fast8_t; + +typedef unsigned long int uint_fast16_t; +typedef unsigned long int uint_fast32_t; +typedef unsigned long int uint_fast64_t; +# 87 "/usr/include/stdint.h" 3 4 +typedef long int intptr_t; + + +typedef unsigned long int uintptr_t; +# 101 "/usr/include/stdint.h" 3 4 +typedef __intmax_t intmax_t; +typedef __uintmax_t uintmax_t; +# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 4 +# 77 "/usr/include/vulkan/vk_platform.h" 2 3 4 + + + + +} +# 11 "/usr/include/vulkan/vulkan.h" 2 3 4 +# 1 "/usr/include/vulkan/vulkan_core.h" 1 3 4 +# 17 "/usr/include/vulkan/vulkan_core.h" 3 4 +extern "C" { +# 94 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef uint32_t VkBool32; +typedef uint64_t VkDeviceAddress; +typedef uint64_t VkDeviceSize; +typedef uint32_t VkFlags; +typedef uint32_t VkSampleMask; +typedef struct VkBuffer_T *VkBuffer; +typedef struct VkImage_T *VkImage; +typedef struct VkInstance_T* VkInstance; +typedef struct VkPhysicalDevice_T* VkPhysicalDevice; +typedef struct VkDevice_T* VkDevice; +typedef struct VkQueue_T* VkQueue; +typedef struct VkSemaphore_T *VkSemaphore; +typedef struct VkCommandBuffer_T* VkCommandBuffer; +typedef struct VkFence_T *VkFence; +typedef struct VkDeviceMemory_T *VkDeviceMemory; +typedef struct VkEvent_T *VkEvent; +typedef struct VkQueryPool_T *VkQueryPool; +typedef struct VkBufferView_T *VkBufferView; +typedef struct VkImageView_T *VkImageView; +typedef struct VkShaderModule_T *VkShaderModule; +typedef struct VkPipelineCache_T *VkPipelineCache; +typedef struct VkPipelineLayout_T *VkPipelineLayout; +typedef struct VkPipeline_T *VkPipeline; +typedef struct VkRenderPass_T *VkRenderPass; +typedef struct VkDescriptorSetLayout_T *VkDescriptorSetLayout; +typedef struct VkSampler_T *VkSampler; +typedef struct VkDescriptorSet_T *VkDescriptorSet; +typedef struct VkDescriptorPool_T *VkDescriptorPool; +typedef struct VkFramebuffer_T *VkFramebuffer; +typedef struct VkCommandPool_T *VkCommandPool; +# 140 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkResult { + VK_SUCCESS = 0, + VK_NOT_READY = 1, + VK_TIMEOUT = 2, + VK_EVENT_SET = 3, + VK_EVENT_RESET = 4, + VK_INCOMPLETE = 5, + VK_ERROR_OUT_OF_HOST_MEMORY = -1, + VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, + VK_ERROR_INITIALIZATION_FAILED = -3, + VK_ERROR_DEVICE_LOST = -4, + VK_ERROR_MEMORY_MAP_FAILED = -5, + VK_ERROR_LAYER_NOT_PRESENT = -6, + VK_ERROR_EXTENSION_NOT_PRESENT = -7, + VK_ERROR_FEATURE_NOT_PRESENT = -8, + VK_ERROR_INCOMPATIBLE_DRIVER = -9, + VK_ERROR_TOO_MANY_OBJECTS = -10, + VK_ERROR_FORMAT_NOT_SUPPORTED = -11, + VK_ERROR_FRAGMENTED_POOL = -12, + VK_ERROR_UNKNOWN = -13, + VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, + VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, + VK_ERROR_FRAGMENTATION = -1000161000, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, + VK_PIPELINE_COMPILE_REQUIRED = 1000297000, + VK_ERROR_SURFACE_LOST_KHR = -1000000000, + VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, + VK_SUBOPTIMAL_KHR = 1000001003, + VK_ERROR_OUT_OF_DATE_KHR = -1000001004, + VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, + VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, + VK_ERROR_INVALID_SHADER_NV = -1000012000, + VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, + VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, + VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002, + VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003, + VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004, + VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, + VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, + VK_ERROR_NOT_PERMITTED_KHR = -1000174001, + VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, + VK_THREAD_IDLE_KHR = 1000268000, + VK_THREAD_DONE_KHR = 1000268001, + VK_OPERATION_DEFERRED_KHR = 1000268002, + VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, + + + + VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, + VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, + VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, + VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, + VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, + VK_ERROR_NOT_PERMITTED_EXT = VK_ERROR_NOT_PERMITTED_KHR, + VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, + VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, + VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, + VK_RESULT_MAX_ENUM = 0x7FFFFFFF +} VkResult; + +typedef enum VkStructureType { + VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, + VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, + VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, + VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, + VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, + VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, + VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, + VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, + VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, + VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, + VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, + VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, + VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, + VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, + VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, + VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, + VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, + VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, + VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, + VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, + VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, + VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, + VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, + VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, + VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, + VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, + VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, + VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, + VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, + VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, + VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002, + VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003, + VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004, + VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005, + VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006, + VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, + VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001, + VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, + VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, + VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, + VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, + VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, + VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, + VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, + VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, + VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, + VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, + VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, + VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, + VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, + VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, + VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, + VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, + VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, + VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000, + VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001, + VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002, + VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003, + VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004, + VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, + VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, + VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, + VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, + VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009, + VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, + VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012, + VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, + VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016, + VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, + VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, + VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000, + VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001, + VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, + VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, +# 554 "/usr/include/vulkan/vulkan_core.h" 3 4 + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006, + VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, + VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, + VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, + VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, + VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, + VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, + VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, + VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, + VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = 1000068000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = 1000068001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = 1000068002, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, + VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, + VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, + VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, + VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, + VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, + VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, + VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, + VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, + VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, + VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, + VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, + VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, + VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, + VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, + VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, + VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, + VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, + VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, + VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, + VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, + VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, + VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, + VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, + VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, + VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, + VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, + VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, + VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, + VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, + VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, + VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, + VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, + VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, + VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, + VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, +# 664 "/usr/include/vulkan/vulkan_core.h" 3 4 + VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, + VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, + VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, + VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, + VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, + VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, + VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, + VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, + VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, + VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, + + + + + + + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, + VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, + VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, + VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, + VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, + VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, + VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, + VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, + VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, + VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, + VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, + VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004, + VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, + VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, + VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, + VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, + VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, + VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, + VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, + VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, + VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, + VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, + VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, + VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, + VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, + VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, + VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, + VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, + VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, + VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, + VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, + VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, + VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, + VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, + VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, + VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, + VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT = 1000270000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT = 1000270001, + VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT = 1000270002, + VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT = 1000270003, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT = 1000270004, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT = 1000270005, + VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT = 1000270006, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT = 1000270007, + VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT = 1000270008, + VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = 1000270009, + VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000, + VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001, + VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = 1000274002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = 1000275000, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = 1000275001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = 1000275002, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = 1000275003, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004, + VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = 1000275005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, + VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, + VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005, + VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, + VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT = 1000283000, + VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT = 1000283001, + VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT = 1000283002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, + VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, + VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, + VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001, + VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002, + VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, +# 903 "/usr/include/vulkan/vulkan_core.h" 3 4 + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, + VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, + VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000, + VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV = 1000307001, + VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV = 1000307002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV = 1000307003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV = 1000307004, + VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, + VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000, + VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001, + VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002, + VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003, + VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT = 1000311004, + VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT = 1000311005, + VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006, + VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007, + VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008, + VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009, + VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010, + VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, + VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002, + VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003, + VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004, + VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005, + VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006, + VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007, + VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008, + VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, + VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, + VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, + VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, + VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000, + VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001, + VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000, + VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001, + VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, + VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, + VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, + VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000, + VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000, + VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, + VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, + VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, + VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, + VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, + VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, + VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, + VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, + VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, + VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, + VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, + VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, + VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT = 1000375000, + VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT = 1000375001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000, + VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001, + VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, + VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, + VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001, + VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000, + VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001, + VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002, + VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003, + VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006, + VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007, + VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008, + VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009, +# 1037 "/usr/include/vulkan/vulkan_core.h" 3 4 + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, + VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, + VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001, + VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000, + VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001, + VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, + VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT = 1000451000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT = 1000451001, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002, + VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003, + VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000, + VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002, + VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005, + VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID = 1000468000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468001, + VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = 1000470000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = 1000470001, + VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR = 1000470003, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR = 1000470004, + VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR = 1000338002, + VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR = 1000338003, + VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR = 1000470005, + VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR = 1000470006, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR = 1000481000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, + VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, + VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000, + VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV = 1000492000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000, + VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000, + VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV = 1000505000, + VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV = 1000505001, + VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV = 1000505002, + VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV = 1000505003, + VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV = 1000505004, + VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV = 1000505005, + VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV = 1000505006, + VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV = 1000505007, + VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV = 1000505008, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000, + VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, + VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001, + VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002, + VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM = 1000519000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM = 1000519001, + VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM = 1000519002, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM = 1000520000, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, + VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000, + VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001, + VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002, + VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, + VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, + VK_STRUCTURE_TYPE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INFO, + VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, + VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, + VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, + VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, + VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, + VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, + VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, + VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, + VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, + VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, + VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, + VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, + VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, + VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, + VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, + VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, + VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, + VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, + VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, + VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, + VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, + VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, + VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, + VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, + VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, + VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, + VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, + VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, + VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, + VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, + VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, + VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, + VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, + VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, + VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, + VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, + VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, + VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, + VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, + VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, + VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, + VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, + VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, + VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, + VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, + VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, + VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, + VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, + VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, + VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, + VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, + VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, + VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, + VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, + VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, + VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, + VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2, + VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2, + VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, + VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, + VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, + VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR, + VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, + VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, + VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, + VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, + VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, + VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, + VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, + VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, + VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkStructureType; + +typedef enum VkPipelineCacheHeaderVersion { + VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, + VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheHeaderVersion; + +typedef enum VkImageLayout { + VK_IMAGE_LAYOUT_UNDEFINED = 0, + VK_IMAGE_LAYOUT_GENERAL = 1, + VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, + VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, + VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, + VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, + VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, + VK_IMAGE_LAYOUT_PREINITIALIZED = 8, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, + VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, + VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000, + VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001, + VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002, + VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, + VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, + VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, +# 1372 "/usr/include/vulkan/vulkan_core.h" 3 4 + VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, + VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, + VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, + VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF +} VkImageLayout; + +typedef enum VkObjectType { + VK_OBJECT_TYPE_UNKNOWN = 0, + VK_OBJECT_TYPE_INSTANCE = 1, + VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, + VK_OBJECT_TYPE_DEVICE = 3, + VK_OBJECT_TYPE_QUEUE = 4, + VK_OBJECT_TYPE_SEMAPHORE = 5, + VK_OBJECT_TYPE_COMMAND_BUFFER = 6, + VK_OBJECT_TYPE_FENCE = 7, + VK_OBJECT_TYPE_DEVICE_MEMORY = 8, + VK_OBJECT_TYPE_BUFFER = 9, + VK_OBJECT_TYPE_IMAGE = 10, + VK_OBJECT_TYPE_EVENT = 11, + VK_OBJECT_TYPE_QUERY_POOL = 12, + VK_OBJECT_TYPE_BUFFER_VIEW = 13, + VK_OBJECT_TYPE_IMAGE_VIEW = 14, + VK_OBJECT_TYPE_SHADER_MODULE = 15, + VK_OBJECT_TYPE_PIPELINE_CACHE = 16, + VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, + VK_OBJECT_TYPE_RENDER_PASS = 18, + VK_OBJECT_TYPE_PIPELINE = 19, + VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, + VK_OBJECT_TYPE_SAMPLER = 21, + VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, + VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, + VK_OBJECT_TYPE_FRAMEBUFFER = 24, + VK_OBJECT_TYPE_COMMAND_POOL = 25, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, + VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, + VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, + VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, + VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, + VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, + VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000, + VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001, + VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, + VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, + VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, + VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000, + VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, + VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, + VK_OBJECT_TYPE_CUDA_MODULE_NV = 1000307000, + VK_OBJECT_TYPE_CUDA_FUNCTION_NV = 1000307001, + VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, + VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, + VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, + VK_OBJECT_TYPE_SHADER_EXT = 1000482000, + VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, + VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, + VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, + VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkObjectType; + +typedef enum VkVendorId { + VK_VENDOR_ID_VIV = 0x10001, + VK_VENDOR_ID_VSI = 0x10002, + VK_VENDOR_ID_KAZAN = 0x10003, + VK_VENDOR_ID_CODEPLAY = 0x10004, + VK_VENDOR_ID_MESA = 0x10005, + VK_VENDOR_ID_POCL = 0x10006, + VK_VENDOR_ID_MOBILEYE = 0x10007, + VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF +} VkVendorId; + +typedef enum VkSystemAllocationScope { + VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, + VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, + VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, + VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, + VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, + VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF +} VkSystemAllocationScope; + +typedef enum VkInternalAllocationType { + VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, + VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkInternalAllocationType; + +typedef enum VkFormat { + VK_FORMAT_UNDEFINED = 0, + VK_FORMAT_R4G4_UNORM_PACK8 = 1, + VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, + VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, + VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, + VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, + VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, + VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, + VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, + VK_FORMAT_R8_UNORM = 9, + VK_FORMAT_R8_SNORM = 10, + VK_FORMAT_R8_USCALED = 11, + VK_FORMAT_R8_SSCALED = 12, + VK_FORMAT_R8_UINT = 13, + VK_FORMAT_R8_SINT = 14, + VK_FORMAT_R8_SRGB = 15, + VK_FORMAT_R8G8_UNORM = 16, + VK_FORMAT_R8G8_SNORM = 17, + VK_FORMAT_R8G8_USCALED = 18, + VK_FORMAT_R8G8_SSCALED = 19, + VK_FORMAT_R8G8_UINT = 20, + VK_FORMAT_R8G8_SINT = 21, + VK_FORMAT_R8G8_SRGB = 22, + VK_FORMAT_R8G8B8_UNORM = 23, + VK_FORMAT_R8G8B8_SNORM = 24, + VK_FORMAT_R8G8B8_USCALED = 25, + VK_FORMAT_R8G8B8_SSCALED = 26, + VK_FORMAT_R8G8B8_UINT = 27, + VK_FORMAT_R8G8B8_SINT = 28, + VK_FORMAT_R8G8B8_SRGB = 29, + VK_FORMAT_B8G8R8_UNORM = 30, + VK_FORMAT_B8G8R8_SNORM = 31, + VK_FORMAT_B8G8R8_USCALED = 32, + VK_FORMAT_B8G8R8_SSCALED = 33, + VK_FORMAT_B8G8R8_UINT = 34, + VK_FORMAT_B8G8R8_SINT = 35, + VK_FORMAT_B8G8R8_SRGB = 36, + VK_FORMAT_R8G8B8A8_UNORM = 37, + VK_FORMAT_R8G8B8A8_SNORM = 38, + VK_FORMAT_R8G8B8A8_USCALED = 39, + VK_FORMAT_R8G8B8A8_SSCALED = 40, + VK_FORMAT_R8G8B8A8_UINT = 41, + VK_FORMAT_R8G8B8A8_SINT = 42, + VK_FORMAT_R8G8B8A8_SRGB = 43, + VK_FORMAT_B8G8R8A8_UNORM = 44, + VK_FORMAT_B8G8R8A8_SNORM = 45, + VK_FORMAT_B8G8R8A8_USCALED = 46, + VK_FORMAT_B8G8R8A8_SSCALED = 47, + VK_FORMAT_B8G8R8A8_UINT = 48, + VK_FORMAT_B8G8R8A8_SINT = 49, + VK_FORMAT_B8G8R8A8_SRGB = 50, + VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, + VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, + VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, + VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, + VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, + VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, + VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, + VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, + VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, + VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, + VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, + VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, + VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, + VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, + VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, + VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, + VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, + VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, + VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, + VK_FORMAT_R16_UNORM = 70, + VK_FORMAT_R16_SNORM = 71, + VK_FORMAT_R16_USCALED = 72, + VK_FORMAT_R16_SSCALED = 73, + VK_FORMAT_R16_UINT = 74, + VK_FORMAT_R16_SINT = 75, + VK_FORMAT_R16_SFLOAT = 76, + VK_FORMAT_R16G16_UNORM = 77, + VK_FORMAT_R16G16_SNORM = 78, + VK_FORMAT_R16G16_USCALED = 79, + VK_FORMAT_R16G16_SSCALED = 80, + VK_FORMAT_R16G16_UINT = 81, + VK_FORMAT_R16G16_SINT = 82, + VK_FORMAT_R16G16_SFLOAT = 83, + VK_FORMAT_R16G16B16_UNORM = 84, + VK_FORMAT_R16G16B16_SNORM = 85, + VK_FORMAT_R16G16B16_USCALED = 86, + VK_FORMAT_R16G16B16_SSCALED = 87, + VK_FORMAT_R16G16B16_UINT = 88, + VK_FORMAT_R16G16B16_SINT = 89, + VK_FORMAT_R16G16B16_SFLOAT = 90, + VK_FORMAT_R16G16B16A16_UNORM = 91, + VK_FORMAT_R16G16B16A16_SNORM = 92, + VK_FORMAT_R16G16B16A16_USCALED = 93, + VK_FORMAT_R16G16B16A16_SSCALED = 94, + VK_FORMAT_R16G16B16A16_UINT = 95, + VK_FORMAT_R16G16B16A16_SINT = 96, + VK_FORMAT_R16G16B16A16_SFLOAT = 97, + VK_FORMAT_R32_UINT = 98, + VK_FORMAT_R32_SINT = 99, + VK_FORMAT_R32_SFLOAT = 100, + VK_FORMAT_R32G32_UINT = 101, + VK_FORMAT_R32G32_SINT = 102, + VK_FORMAT_R32G32_SFLOAT = 103, + VK_FORMAT_R32G32B32_UINT = 104, + VK_FORMAT_R32G32B32_SINT = 105, + VK_FORMAT_R32G32B32_SFLOAT = 106, + VK_FORMAT_R32G32B32A32_UINT = 107, + VK_FORMAT_R32G32B32A32_SINT = 108, + VK_FORMAT_R32G32B32A32_SFLOAT = 109, + VK_FORMAT_R64_UINT = 110, + VK_FORMAT_R64_SINT = 111, + VK_FORMAT_R64_SFLOAT = 112, + VK_FORMAT_R64G64_UINT = 113, + VK_FORMAT_R64G64_SINT = 114, + VK_FORMAT_R64G64_SFLOAT = 115, + VK_FORMAT_R64G64B64_UINT = 116, + VK_FORMAT_R64G64B64_SINT = 117, + VK_FORMAT_R64G64B64_SFLOAT = 118, + VK_FORMAT_R64G64B64A64_UINT = 119, + VK_FORMAT_R64G64B64A64_SINT = 120, + VK_FORMAT_R64G64B64A64_SFLOAT = 121, + VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, + VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, + VK_FORMAT_D16_UNORM = 124, + VK_FORMAT_X8_D24_UNORM_PACK32 = 125, + VK_FORMAT_D32_SFLOAT = 126, + VK_FORMAT_S8_UINT = 127, + VK_FORMAT_D16_UNORM_S8_UINT = 128, + VK_FORMAT_D24_UNORM_S8_UINT = 129, + VK_FORMAT_D32_SFLOAT_S8_UINT = 130, + VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, + VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, + VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, + VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, + VK_FORMAT_BC2_UNORM_BLOCK = 135, + VK_FORMAT_BC2_SRGB_BLOCK = 136, + VK_FORMAT_BC3_UNORM_BLOCK = 137, + VK_FORMAT_BC3_SRGB_BLOCK = 138, + VK_FORMAT_BC4_UNORM_BLOCK = 139, + VK_FORMAT_BC4_SNORM_BLOCK = 140, + VK_FORMAT_BC5_UNORM_BLOCK = 141, + VK_FORMAT_BC5_SNORM_BLOCK = 142, + VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, + VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, + VK_FORMAT_BC7_UNORM_BLOCK = 145, + VK_FORMAT_BC7_SRGB_BLOCK = 146, + VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, + VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, + VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, + VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, + VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, + VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, + VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, + VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, + VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, + VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, + VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, + VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, + VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, + VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, + VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, + VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, + VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, + VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, + VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, + VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, + VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, + VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, + VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, + VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, + VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, + VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, + VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, + VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, + VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, + VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, + VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, + VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, + VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, + VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, + VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, + VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, + VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, + VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, + VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, + VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, + VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, + VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, + VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, + VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002, + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003, + VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000, + VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001, + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000, + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001, + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002, + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003, + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004, + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005, + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006, + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007, + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008, + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009, + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010, + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011, + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012, + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013, + VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, + VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, + VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, + VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, + VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, + VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, + VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, + VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, + VK_FORMAT_R16G16_S10_5_NV = 1000464000, + VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = 1000470000, + VK_FORMAT_A8_UNORM_KHR = 1000470001, + VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, + VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, + VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, + VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, + VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, + VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, + VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, + VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, + VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, + VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, + VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, + VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, + VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, + VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, + VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, + VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, + VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, + VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, + VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, + VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, + VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, + VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, + VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, + VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, + VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, + VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, + VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, + VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16, + VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16, + VK_FORMAT_MAX_ENUM = 0x7FFFFFFF +} VkFormat; + +typedef enum VkImageTiling { + VK_IMAGE_TILING_OPTIMAL = 0, + VK_IMAGE_TILING_LINEAR = 1, + VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, + VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF +} VkImageTiling; + +typedef enum VkImageType { + VK_IMAGE_TYPE_1D = 0, + VK_IMAGE_TYPE_2D = 1, + VK_IMAGE_TYPE_3D = 2, + VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageType; + +typedef enum VkPhysicalDeviceType { + VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, + VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, + VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, + VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, + VK_PHYSICAL_DEVICE_TYPE_CPU = 4, + VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkPhysicalDeviceType; + +typedef enum VkQueryType { + VK_QUERY_TYPE_OCCLUSION = 0, + VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, + VK_QUERY_TYPE_TIMESTAMP = 2, + VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000, + VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, + VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, + VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, + + + + VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, + VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000, + VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001, + VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000, + VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001, + VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkQueryType; + +typedef enum VkSharingMode { + VK_SHARING_MODE_EXCLUSIVE = 0, + VK_SHARING_MODE_CONCURRENT = 1, + VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSharingMode; + +typedef enum VkComponentSwizzle { + VK_COMPONENT_SWIZZLE_IDENTITY = 0, + VK_COMPONENT_SWIZZLE_ZERO = 1, + VK_COMPONENT_SWIZZLE_ONE = 2, + VK_COMPONENT_SWIZZLE_R = 3, + VK_COMPONENT_SWIZZLE_G = 4, + VK_COMPONENT_SWIZZLE_B = 5, + VK_COMPONENT_SWIZZLE_A = 6, + VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF +} VkComponentSwizzle; + +typedef enum VkImageViewType { + VK_IMAGE_VIEW_TYPE_1D = 0, + VK_IMAGE_VIEW_TYPE_2D = 1, + VK_IMAGE_VIEW_TYPE_3D = 2, + VK_IMAGE_VIEW_TYPE_CUBE = 3, + VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, + VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, + VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, + VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkImageViewType; + +typedef enum VkBlendFactor { + VK_BLEND_FACTOR_ZERO = 0, + VK_BLEND_FACTOR_ONE = 1, + VK_BLEND_FACTOR_SRC_COLOR = 2, + VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, + VK_BLEND_FACTOR_DST_COLOR = 4, + VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, + VK_BLEND_FACTOR_SRC_ALPHA = 6, + VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, + VK_BLEND_FACTOR_DST_ALPHA = 8, + VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, + VK_BLEND_FACTOR_CONSTANT_COLOR = 10, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, + VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, + VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, + VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, + VK_BLEND_FACTOR_SRC1_COLOR = 15, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, + VK_BLEND_FACTOR_SRC1_ALPHA = 17, + VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, + VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF +} VkBlendFactor; + +typedef enum VkBlendOp { + VK_BLEND_OP_ADD = 0, + VK_BLEND_OP_SUBTRACT = 1, + VK_BLEND_OP_REVERSE_SUBTRACT = 2, + VK_BLEND_OP_MIN = 3, + VK_BLEND_OP_MAX = 4, + VK_BLEND_OP_ZERO_EXT = 1000148000, + VK_BLEND_OP_SRC_EXT = 1000148001, + VK_BLEND_OP_DST_EXT = 1000148002, + VK_BLEND_OP_SRC_OVER_EXT = 1000148003, + VK_BLEND_OP_DST_OVER_EXT = 1000148004, + VK_BLEND_OP_SRC_IN_EXT = 1000148005, + VK_BLEND_OP_DST_IN_EXT = 1000148006, + VK_BLEND_OP_SRC_OUT_EXT = 1000148007, + VK_BLEND_OP_DST_OUT_EXT = 1000148008, + VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, + VK_BLEND_OP_DST_ATOP_EXT = 1000148010, + VK_BLEND_OP_XOR_EXT = 1000148011, + VK_BLEND_OP_MULTIPLY_EXT = 1000148012, + VK_BLEND_OP_SCREEN_EXT = 1000148013, + VK_BLEND_OP_OVERLAY_EXT = 1000148014, + VK_BLEND_OP_DARKEN_EXT = 1000148015, + VK_BLEND_OP_LIGHTEN_EXT = 1000148016, + VK_BLEND_OP_COLORDODGE_EXT = 1000148017, + VK_BLEND_OP_COLORBURN_EXT = 1000148018, + VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, + VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, + VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, + VK_BLEND_OP_EXCLUSION_EXT = 1000148022, + VK_BLEND_OP_INVERT_EXT = 1000148023, + VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, + VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, + VK_BLEND_OP_LINEARBURN_EXT = 1000148026, + VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, + VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, + VK_BLEND_OP_PINLIGHT_EXT = 1000148029, + VK_BLEND_OP_HARDMIX_EXT = 1000148030, + VK_BLEND_OP_HSL_HUE_EXT = 1000148031, + VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, + VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, + VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, + VK_BLEND_OP_PLUS_EXT = 1000148035, + VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, + VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, + VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, + VK_BLEND_OP_MINUS_EXT = 1000148039, + VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, + VK_BLEND_OP_CONTRAST_EXT = 1000148041, + VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, + VK_BLEND_OP_RED_EXT = 1000148043, + VK_BLEND_OP_GREEN_EXT = 1000148044, + VK_BLEND_OP_BLUE_EXT = 1000148045, + VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF +} VkBlendOp; + +typedef enum VkCompareOp { + VK_COMPARE_OP_NEVER = 0, + VK_COMPARE_OP_LESS = 1, + VK_COMPARE_OP_EQUAL = 2, + VK_COMPARE_OP_LESS_OR_EQUAL = 3, + VK_COMPARE_OP_GREATER = 4, + VK_COMPARE_OP_NOT_EQUAL = 5, + VK_COMPARE_OP_GREATER_OR_EQUAL = 6, + VK_COMPARE_OP_ALWAYS = 7, + VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF +} VkCompareOp; + +typedef enum VkDynamicState { + VK_DYNAMIC_STATE_VIEWPORT = 0, + VK_DYNAMIC_STATE_SCISSOR = 1, + VK_DYNAMIC_STATE_LINE_WIDTH = 2, + VK_DYNAMIC_STATE_DEPTH_BIAS = 3, + VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, + VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, + VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, + VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, + VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, + VK_DYNAMIC_STATE_CULL_MODE = 1000267000, + VK_DYNAMIC_STATE_FRONT_FACE = 1000267001, + VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002, + VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003, + VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004, + VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005, + VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006, + VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007, + VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008, + VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009, + VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010, + VK_DYNAMIC_STATE_STENCIL_OP = 1000267011, + VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001, + VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002, + VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001, + VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, + VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, + VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, + VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, + VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, + VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, + VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, + VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, + VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, + VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, + VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, + VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, + VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003, + VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004, + VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005, + VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006, + VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007, + VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008, + VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009, + VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010, + VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011, + VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012, + VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013, + VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014, + VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, + VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016, + VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017, + VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018, + VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019, + VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020, + VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021, + VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022, + VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023, + VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024, + VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025, + VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028, + VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029, + VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030, + VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, + VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, + VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, + VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, + VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, + VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, + VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, + VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, + VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, + VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, + VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, + VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, + VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, + VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, + VK_DYNAMIC_STATE_STENCIL_OP_EXT = VK_DYNAMIC_STATE_STENCIL_OP, + VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, + VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, + VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, + VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF +} VkDynamicState; + +typedef enum VkFrontFace { + VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, + VK_FRONT_FACE_CLOCKWISE = 1, + VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF +} VkFrontFace; + +typedef enum VkVertexInputRate { + VK_VERTEX_INPUT_RATE_VERTEX = 0, + VK_VERTEX_INPUT_RATE_INSTANCE = 1, + VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF +} VkVertexInputRate; + +typedef enum VkPrimitiveTopology { + VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, + VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, + VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, + VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, + VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, + VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF +} VkPrimitiveTopology; + +typedef enum VkPolygonMode { + VK_POLYGON_MODE_FILL = 0, + VK_POLYGON_MODE_LINE = 1, + VK_POLYGON_MODE_POINT = 2, + VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, + VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF +} VkPolygonMode; + +typedef enum VkStencilOp { + VK_STENCIL_OP_KEEP = 0, + VK_STENCIL_OP_ZERO = 1, + VK_STENCIL_OP_REPLACE = 2, + VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, + VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, + VK_STENCIL_OP_INVERT = 5, + VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, + VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, + VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF +} VkStencilOp; + +typedef enum VkLogicOp { + VK_LOGIC_OP_CLEAR = 0, + VK_LOGIC_OP_AND = 1, + VK_LOGIC_OP_AND_REVERSE = 2, + VK_LOGIC_OP_COPY = 3, + VK_LOGIC_OP_AND_INVERTED = 4, + VK_LOGIC_OP_NO_OP = 5, + VK_LOGIC_OP_XOR = 6, + VK_LOGIC_OP_OR = 7, + VK_LOGIC_OP_NOR = 8, + VK_LOGIC_OP_EQUIVALENT = 9, + VK_LOGIC_OP_INVERT = 10, + VK_LOGIC_OP_OR_REVERSE = 11, + VK_LOGIC_OP_COPY_INVERTED = 12, + VK_LOGIC_OP_OR_INVERTED = 13, + VK_LOGIC_OP_NAND = 14, + VK_LOGIC_OP_SET = 15, + VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF +} VkLogicOp; + +typedef enum VkBorderColor { + VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, + VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, + VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, + VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, + VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, + VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, + VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, + VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, + VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF +} VkBorderColor; + +typedef enum VkFilter { + VK_FILTER_NEAREST = 0, + VK_FILTER_LINEAR = 1, + VK_FILTER_CUBIC_EXT = 1000015000, + VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, + VK_FILTER_MAX_ENUM = 0x7FFFFFFF +} VkFilter; + +typedef enum VkSamplerAddressMode { + VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, + VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, + VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, + VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, + VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerAddressMode; + +typedef enum VkSamplerMipmapMode { + VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, + VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, + VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerMipmapMode; + +typedef enum VkDescriptorType { + VK_DESCRIPTOR_TYPE_SAMPLER = 0, + VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, + VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, + VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, + VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, + VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, + VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, + VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, + VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, + VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, + VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, + VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, + VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, + VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, + VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, + VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorType; + +typedef enum VkAttachmentLoadOp { + VK_ATTACHMENT_LOAD_OP_LOAD = 0, + VK_ATTACHMENT_LOAD_OP_CLEAR = 1, + VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, + VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000, + VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentLoadOp; + +typedef enum VkAttachmentStoreOp { + VK_ATTACHMENT_STORE_OP_STORE = 0, + VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, + VK_ATTACHMENT_STORE_OP_NONE = 1000301000, + VK_ATTACHMENT_STORE_OP_NONE_KHR = VK_ATTACHMENT_STORE_OP_NONE, + VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE, + VK_ATTACHMENT_STORE_OP_NONE_EXT = VK_ATTACHMENT_STORE_OP_NONE, + VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentStoreOp; + +typedef enum VkPipelineBindPoint { + VK_PIPELINE_BIND_POINT_GRAPHICS = 0, + VK_PIPELINE_BIND_POINT_COMPUTE = 1, + + + + VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, + VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, + VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, + VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF +} VkPipelineBindPoint; + +typedef enum VkCommandBufferLevel { + VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, + VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, + VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferLevel; + +typedef enum VkIndexType { + VK_INDEX_TYPE_UINT16 = 0, + VK_INDEX_TYPE_UINT32 = 1, + VK_INDEX_TYPE_NONE_KHR = 1000165000, + VK_INDEX_TYPE_UINT8_EXT = 1000265000, + VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, + VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkIndexType; + +typedef enum VkSubpassContents { + VK_SUBPASS_CONTENTS_INLINE = 0, + VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, + VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = 1000451000, + VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassContents; + +typedef enum VkAccessFlagBits { + VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, + VK_ACCESS_INDEX_READ_BIT = 0x00000002, + VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, + VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, + VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, + VK_ACCESS_SHADER_READ_BIT = 0x00000020, + VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, + VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, + VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, + VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, + VK_ACCESS_HOST_READ_BIT = 0x00002000, + VK_ACCESS_HOST_WRITE_BIT = 0x00004000, + VK_ACCESS_MEMORY_READ_BIT = 0x00008000, + VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, + VK_ACCESS_NONE = 0, + VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, + VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, + VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, + VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000, + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000, + VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, + VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000, + VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000, + VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000, + VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, + VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, + VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, + VK_ACCESS_NONE_KHR = VK_ACCESS_NONE, + VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAccessFlagBits; +typedef VkFlags VkAccessFlags; + +typedef enum VkImageAspectFlagBits { + VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, + VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, + VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, + VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, + VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, + VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, + VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, + VK_IMAGE_ASPECT_NONE = 0, + VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, + VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, + VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, + VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, + VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, + VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, + VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, + VK_IMAGE_ASPECT_NONE_KHR = VK_IMAGE_ASPECT_NONE, + VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageAspectFlagBits; +typedef VkFlags VkImageAspectFlags; + +typedef enum VkFormatFeatureFlagBits { + VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, + VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, + VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, + VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, + VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, + VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, + VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, + VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, + VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, + VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, + VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000, + VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000, + VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000, + VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000, + VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, + VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000, + + + + + + + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, + VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, + VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, + VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, + VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, + VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, + VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, + VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFormatFeatureFlagBits; +typedef VkFlags VkFormatFeatureFlags; + +typedef enum VkImageCreateFlagBits { + VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, + VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, + VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, + VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, + VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, + VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, + VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, + VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, + VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000, + VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000, + VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, + VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000, + VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, + VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, + VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, + VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, + VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, + VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, + VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageCreateFlagBits; +typedef VkFlags VkImageCreateFlags; + +typedef enum VkSampleCountFlagBits { + VK_SAMPLE_COUNT_1_BIT = 0x00000001, + VK_SAMPLE_COUNT_2_BIT = 0x00000002, + VK_SAMPLE_COUNT_4_BIT = 0x00000004, + VK_SAMPLE_COUNT_8_BIT = 0x00000008, + VK_SAMPLE_COUNT_16_BIT = 0x00000010, + VK_SAMPLE_COUNT_32_BIT = 0x00000020, + VK_SAMPLE_COUNT_64_BIT = 0x00000040, + VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSampleCountFlagBits; +typedef VkFlags VkSampleCountFlags; + +typedef enum VkImageUsageFlagBits { + VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, + VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, + VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400, + VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800, + VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000, + VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, + VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, + VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = 0x00400000, +# 2385 "/usr/include/vulkan/vulkan_core.h" 3 4 + VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000, + VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, + VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, + VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, + VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageUsageFlagBits; +typedef VkFlags VkImageUsageFlags; + +typedef enum VkInstanceCreateFlagBits { + VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 0x00000001, + VK_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkInstanceCreateFlagBits; +typedef VkFlags VkInstanceCreateFlags; + +typedef enum VkMemoryHeapFlagBits { + VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, + VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, + VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryHeapFlagBits; +typedef VkFlags VkMemoryHeapFlags; + +typedef enum VkMemoryPropertyFlagBits { + VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, + VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, + VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, + VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, + VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, + VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, + VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040, + VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080, + VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100, + VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryPropertyFlagBits; +typedef VkFlags VkMemoryPropertyFlags; + +typedef enum VkQueueFlagBits { + VK_QUEUE_GRAPHICS_BIT = 0x00000001, + VK_QUEUE_COMPUTE_BIT = 0x00000002, + VK_QUEUE_TRANSFER_BIT = 0x00000004, + VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, + VK_QUEUE_PROTECTED_BIT = 0x00000010, + VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, + + + + VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, + VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueueFlagBits; +typedef VkFlags VkQueueFlags; +typedef VkFlags VkDeviceCreateFlags; + +typedef enum VkDeviceQueueCreateFlagBits { + VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, + VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDeviceQueueCreateFlagBits; +typedef VkFlags VkDeviceQueueCreateFlags; + +typedef enum VkPipelineStageFlagBits { + VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, + VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, + VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, + VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, + VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, + VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, + VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, + VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, + VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, + VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, + VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, + VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, + VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, + VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, + VK_PIPELINE_STAGE_NONE = 0, + VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, + VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, + VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, + VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, + VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0x00080000, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0x00100000, + VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, + VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, + VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, + VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, + VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, + VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineStageFlagBits; +typedef VkFlags VkPipelineStageFlags; +typedef VkFlags VkMemoryMapFlags; + +typedef enum VkSparseMemoryBindFlagBits { + VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, + VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseMemoryBindFlagBits; +typedef VkFlags VkSparseMemoryBindFlags; + +typedef enum VkSparseImageFormatFlagBits { + VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, + VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, + VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, + VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSparseImageFormatFlagBits; +typedef VkFlags VkSparseImageFormatFlags; + +typedef enum VkFenceCreateFlagBits { + VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, + VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceCreateFlagBits; +typedef VkFlags VkFenceCreateFlags; +typedef VkFlags VkSemaphoreCreateFlags; + +typedef enum VkEventCreateFlagBits { + VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0x00000001, + VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT, + VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkEventCreateFlagBits; +typedef VkFlags VkEventCreateFlags; + +typedef enum VkQueryPipelineStatisticFlagBits { + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, + VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, + VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, + VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, + VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, + VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, + VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, + VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, + VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT = 0x00000800, + VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT = 0x00001000, + VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI = 0x00002000, + VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryPipelineStatisticFlagBits; +typedef VkFlags VkQueryPipelineStatisticFlags; +typedef VkFlags VkQueryPoolCreateFlags; + +typedef enum VkQueryResultFlagBits { + VK_QUERY_RESULT_64_BIT = 0x00000001, + VK_QUERY_RESULT_WAIT_BIT = 0x00000002, + VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, + VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, + VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010, + VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryResultFlagBits; +typedef VkFlags VkQueryResultFlags; + +typedef enum VkBufferCreateFlagBits { + VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, + VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, + VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, + VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, + VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferCreateFlagBits; +typedef VkFlags VkBufferCreateFlags; + +typedef enum VkBufferUsageFlagBits { + VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, + VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, + VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, + VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, + VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, + VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, + VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, + VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, + VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, + VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000, + VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000, + VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, + VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, + VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, + + + + VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000, + VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000, + VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400, + + + + + + + VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000, + VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000, + VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, + VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000, + VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000, + VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, + VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkBufferUsageFlagBits; +typedef VkFlags VkBufferUsageFlags; +typedef VkFlags VkBufferViewCreateFlags; + +typedef enum VkImageViewCreateFlagBits { + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, + VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000004, + VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002, + VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkImageViewCreateFlagBits; +typedef VkFlags VkImageViewCreateFlags; +typedef VkFlags VkShaderModuleCreateFlags; + +typedef enum VkPipelineCacheCreateFlagBits { + VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001, + VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, + VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCacheCreateFlagBits; +typedef VkFlags VkPipelineCacheCreateFlags; + +typedef enum VkColorComponentFlagBits { + VK_COLOR_COMPONENT_R_BIT = 0x00000001, + VK_COLOR_COMPONENT_G_BIT = 0x00000002, + VK_COLOR_COMPONENT_B_BIT = 0x00000004, + VK_COLOR_COMPONENT_A_BIT = 0x00000008, + VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkColorComponentFlagBits; +typedef VkFlags VkColorComponentFlags; + +typedef enum VkPipelineCreateFlagBits { + VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, + VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, + VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, + VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, + VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100, + VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200, + VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000, + VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000, + VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000, + VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000, + VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000, + VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000, + VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, + VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040, + VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080, + VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000, + VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800, + VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000, + VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000, + VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400, + VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000, + VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, + VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, + VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000, + + + + VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000, + VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000, + VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, + VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, + VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, + VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, + VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, + VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, + VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, + VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreateFlagBits; +typedef VkFlags VkPipelineCreateFlags; + +typedef enum VkPipelineShaderStageCreateFlagBits { + VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0x00000001, + VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0x00000002, + VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, + VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, + VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineShaderStageCreateFlagBits; +typedef VkFlags VkPipelineShaderStageCreateFlags; + +typedef enum VkShaderStageFlagBits { + VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, + VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, + VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, + VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, + VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, + VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, + VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, + VK_SHADER_STAGE_ALL = 0x7FFFFFFF, + VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100, + VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200, + VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400, + VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800, + VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000, + VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000, + VK_SHADER_STAGE_TASK_BIT_EXT = 0x00000040, + VK_SHADER_STAGE_MESH_BIT_EXT = 0x00000080, + VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000, + VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0x00080000, + VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR, + VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, + VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, + VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR, + VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, + VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR, + VK_SHADER_STAGE_TASK_BIT_NV = VK_SHADER_STAGE_TASK_BIT_EXT, + VK_SHADER_STAGE_MESH_BIT_NV = VK_SHADER_STAGE_MESH_BIT_EXT, + VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkShaderStageFlagBits; + +typedef enum VkCullModeFlagBits { + VK_CULL_MODE_NONE = 0, + VK_CULL_MODE_FRONT_BIT = 0x00000001, + VK_CULL_MODE_BACK_BIT = 0x00000002, + VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, + VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCullModeFlagBits; +typedef VkFlags VkCullModeFlags; +typedef VkFlags VkPipelineVertexInputStateCreateFlags; +typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; +typedef VkFlags VkPipelineTessellationStateCreateFlags; +typedef VkFlags VkPipelineViewportStateCreateFlags; +typedef VkFlags VkPipelineRasterizationStateCreateFlags; +typedef VkFlags VkPipelineMultisampleStateCreateFlags; + +typedef enum VkPipelineDepthStencilStateCreateFlagBits { + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000001, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000002, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineDepthStencilStateCreateFlagBits; +typedef VkFlags VkPipelineDepthStencilStateCreateFlags; + +typedef enum VkPipelineColorBlendStateCreateFlagBits { + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 0x00000001, + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT, + VK_PIPELINE_COLOR_BLEND_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineColorBlendStateCreateFlagBits; +typedef VkFlags VkPipelineColorBlendStateCreateFlags; +typedef VkFlags VkPipelineDynamicStateCreateFlags; + +typedef enum VkPipelineLayoutCreateFlagBits { + VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0x00000002, + VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineLayoutCreateFlagBits; +typedef VkFlags VkPipelineLayoutCreateFlags; +typedef VkFlags VkShaderStageFlags; + +typedef enum VkSamplerCreateFlagBits { + VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, + VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, + VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, + VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 0x00000004, + VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 0x00000010, + VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSamplerCreateFlagBits; +typedef VkFlags VkSamplerCreateFlags; + +typedef enum VkDescriptorPoolCreateFlagBits { + VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002, + VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV = 0x00000008, + VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV = 0x00000010, + VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, + VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, + VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorPoolCreateFlagBits; +typedef VkFlags VkDescriptorPoolCreateFlags; +typedef VkFlags VkDescriptorPoolResetFlags; + +typedef enum VkDescriptorSetLayoutCreateFlagBits { + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00000010, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00000080, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, + VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorSetLayoutCreateFlagBits; +typedef VkFlags VkDescriptorSetLayoutCreateFlags; + +typedef enum VkAttachmentDescriptionFlagBits { + VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, + VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkAttachmentDescriptionFlagBits; +typedef VkFlags VkAttachmentDescriptionFlags; + +typedef enum VkDependencyFlagBits { + VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, + VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, + VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, + VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008, + VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, + VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, + VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDependencyFlagBits; +typedef VkFlags VkDependencyFlags; + +typedef enum VkFramebufferCreateFlagBits { + VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001, + VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, + VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFramebufferCreateFlagBits; +typedef VkFlags VkFramebufferCreateFlags; + +typedef enum VkRenderPassCreateFlagBits { + VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002, + VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkRenderPassCreateFlagBits; +typedef VkFlags VkRenderPassCreateFlags; + +typedef enum VkSubpassDescriptionFlagBits { + VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, + VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, + VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004, + VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0x00000010, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000020, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000040, + VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000080, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, + VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubpassDescriptionFlagBits; +typedef VkFlags VkSubpassDescriptionFlags; + +typedef enum VkCommandPoolCreateFlagBits { + VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, + VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, + VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, + VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolCreateFlagBits; +typedef VkFlags VkCommandPoolCreateFlags; + +typedef enum VkCommandPoolResetFlagBits { + VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandPoolResetFlagBits; +typedef VkFlags VkCommandPoolResetFlags; + +typedef enum VkCommandBufferUsageFlagBits { + VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, + VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, + VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, + VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferUsageFlagBits; +typedef VkFlags VkCommandBufferUsageFlags; + +typedef enum VkQueryControlFlagBits { + VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, + VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkQueryControlFlagBits; +typedef VkFlags VkQueryControlFlags; + +typedef enum VkCommandBufferResetFlagBits { + VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, + VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkCommandBufferResetFlagBits; +typedef VkFlags VkCommandBufferResetFlags; + +typedef enum VkStencilFaceFlagBits { + VK_STENCIL_FACE_FRONT_BIT = 0x00000001, + VK_STENCIL_FACE_BACK_BIT = 0x00000002, + VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, + VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, + VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkStencilFaceFlagBits; +typedef VkFlags VkStencilFaceFlags; +typedef struct VkExtent2D { + uint32_t width; + uint32_t height; +} VkExtent2D; + +typedef struct VkExtent3D { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkExtent3D; + +typedef struct VkOffset2D { + int32_t x; + int32_t y; +} VkOffset2D; + +typedef struct VkOffset3D { + int32_t x; + int32_t y; + int32_t z; +} VkOffset3D; + +typedef struct VkRect2D { + VkOffset2D offset; + VkExtent2D extent; +} VkRect2D; + +typedef struct VkBaseInStructure { + VkStructureType sType; + const struct VkBaseInStructure* pNext; +} VkBaseInStructure; + +typedef struct VkBaseOutStructure { + VkStructureType sType; + struct VkBaseOutStructure* pNext; +} VkBaseOutStructure; + +typedef struct VkBufferMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier; + +typedef struct VkDispatchIndirectCommand { + uint32_t x; + uint32_t y; + uint32_t z; +} VkDispatchIndirectCommand; + +typedef struct VkDrawIndexedIndirectCommand { + uint32_t indexCount; + uint32_t instanceCount; + uint32_t firstIndex; + int32_t vertexOffset; + uint32_t firstInstance; +} VkDrawIndexedIndirectCommand; + +typedef struct VkDrawIndirectCommand { + uint32_t vertexCount; + uint32_t instanceCount; + uint32_t firstVertex; + uint32_t firstInstance; +} VkDrawIndirectCommand; + +typedef struct VkImageSubresourceRange { + VkImageAspectFlags aspectMask; + uint32_t baseMipLevel; + uint32_t levelCount; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceRange; + +typedef struct VkImageMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier; + +typedef struct VkMemoryBarrier { + VkStructureType sType; + const void* pNext; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; +} VkMemoryBarrier; + +typedef struct VkPipelineCacheHeaderVersionOne { + uint32_t headerSize; + VkPipelineCacheHeaderVersion headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint8_t pipelineCacheUUID[16U]; +} VkPipelineCacheHeaderVersionOne; + +typedef void* ( *PFN_vkAllocationFunction)( + void* pUserData, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void ( *PFN_vkFreeFunction)( + void* pUserData, + void* pMemory); + +typedef void ( *PFN_vkInternalAllocationNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void ( *PFN_vkInternalFreeNotification)( + void* pUserData, + size_t size, + VkInternalAllocationType allocationType, + VkSystemAllocationScope allocationScope); + +typedef void* ( *PFN_vkReallocationFunction)( + void* pUserData, + void* pOriginal, + size_t size, + size_t alignment, + VkSystemAllocationScope allocationScope); + +typedef void ( *PFN_vkVoidFunction)(void); +typedef struct VkAllocationCallbacks { + void* pUserData; + PFN_vkAllocationFunction pfnAllocation; + PFN_vkReallocationFunction pfnReallocation; + PFN_vkFreeFunction pfnFree; + PFN_vkInternalAllocationNotification pfnInternalAllocation; + PFN_vkInternalFreeNotification pfnInternalFree; +} VkAllocationCallbacks; + +typedef struct VkApplicationInfo { + VkStructureType sType; + const void* pNext; + const char* pApplicationName; + uint32_t applicationVersion; + const char* pEngineName; + uint32_t engineVersion; + uint32_t apiVersion; +} VkApplicationInfo; + +typedef struct VkFormatProperties { + VkFormatFeatureFlags linearTilingFeatures; + VkFormatFeatureFlags optimalTilingFeatures; + VkFormatFeatureFlags bufferFeatures; +} VkFormatProperties; + +typedef struct VkImageFormatProperties { + VkExtent3D maxExtent; + uint32_t maxMipLevels; + uint32_t maxArrayLayers; + VkSampleCountFlags sampleCounts; + VkDeviceSize maxResourceSize; +} VkImageFormatProperties; + +typedef struct VkInstanceCreateInfo { + VkStructureType sType; + const void* pNext; + VkInstanceCreateFlags flags; + const VkApplicationInfo* pApplicationInfo; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; +} VkInstanceCreateInfo; + +typedef struct VkMemoryHeap { + VkDeviceSize size; + VkMemoryHeapFlags flags; +} VkMemoryHeap; + +typedef struct VkMemoryType { + VkMemoryPropertyFlags propertyFlags; + uint32_t heapIndex; +} VkMemoryType; + +typedef struct VkPhysicalDeviceFeatures { + VkBool32 robustBufferAccess; + VkBool32 fullDrawIndexUint32; + VkBool32 imageCubeArray; + VkBool32 independentBlend; + VkBool32 geometryShader; + VkBool32 tessellationShader; + VkBool32 sampleRateShading; + VkBool32 dualSrcBlend; + VkBool32 logicOp; + VkBool32 multiDrawIndirect; + VkBool32 drawIndirectFirstInstance; + VkBool32 depthClamp; + VkBool32 depthBiasClamp; + VkBool32 fillModeNonSolid; + VkBool32 depthBounds; + VkBool32 wideLines; + VkBool32 largePoints; + VkBool32 alphaToOne; + VkBool32 multiViewport; + VkBool32 samplerAnisotropy; + VkBool32 textureCompressionETC2; + VkBool32 textureCompressionASTC_LDR; + VkBool32 textureCompressionBC; + VkBool32 occlusionQueryPrecise; + VkBool32 pipelineStatisticsQuery; + VkBool32 vertexPipelineStoresAndAtomics; + VkBool32 fragmentStoresAndAtomics; + VkBool32 shaderTessellationAndGeometryPointSize; + VkBool32 shaderImageGatherExtended; + VkBool32 shaderStorageImageExtendedFormats; + VkBool32 shaderStorageImageMultisample; + VkBool32 shaderStorageImageReadWithoutFormat; + VkBool32 shaderStorageImageWriteWithoutFormat; + VkBool32 shaderUniformBufferArrayDynamicIndexing; + VkBool32 shaderSampledImageArrayDynamicIndexing; + VkBool32 shaderStorageBufferArrayDynamicIndexing; + VkBool32 shaderStorageImageArrayDynamicIndexing; + VkBool32 shaderClipDistance; + VkBool32 shaderCullDistance; + VkBool32 shaderFloat64; + VkBool32 shaderInt64; + VkBool32 shaderInt16; + VkBool32 shaderResourceResidency; + VkBool32 shaderResourceMinLod; + VkBool32 sparseBinding; + VkBool32 sparseResidencyBuffer; + VkBool32 sparseResidencyImage2D; + VkBool32 sparseResidencyImage3D; + VkBool32 sparseResidency2Samples; + VkBool32 sparseResidency4Samples; + VkBool32 sparseResidency8Samples; + VkBool32 sparseResidency16Samples; + VkBool32 sparseResidencyAliased; + VkBool32 variableMultisampleRate; + VkBool32 inheritedQueries; +} VkPhysicalDeviceFeatures; + +typedef struct VkPhysicalDeviceLimits { + uint32_t maxImageDimension1D; + uint32_t maxImageDimension2D; + uint32_t maxImageDimension3D; + uint32_t maxImageDimensionCube; + uint32_t maxImageArrayLayers; + uint32_t maxTexelBufferElements; + uint32_t maxUniformBufferRange; + uint32_t maxStorageBufferRange; + uint32_t maxPushConstantsSize; + uint32_t maxMemoryAllocationCount; + uint32_t maxSamplerAllocationCount; + VkDeviceSize bufferImageGranularity; + VkDeviceSize sparseAddressSpaceSize; + uint32_t maxBoundDescriptorSets; + uint32_t maxPerStageDescriptorSamplers; + uint32_t maxPerStageDescriptorUniformBuffers; + uint32_t maxPerStageDescriptorStorageBuffers; + uint32_t maxPerStageDescriptorSampledImages; + uint32_t maxPerStageDescriptorStorageImages; + uint32_t maxPerStageDescriptorInputAttachments; + uint32_t maxPerStageResources; + uint32_t maxDescriptorSetSamplers; + uint32_t maxDescriptorSetUniformBuffers; + uint32_t maxDescriptorSetUniformBuffersDynamic; + uint32_t maxDescriptorSetStorageBuffers; + uint32_t maxDescriptorSetStorageBuffersDynamic; + uint32_t maxDescriptorSetSampledImages; + uint32_t maxDescriptorSetStorageImages; + uint32_t maxDescriptorSetInputAttachments; + uint32_t maxVertexInputAttributes; + uint32_t maxVertexInputBindings; + uint32_t maxVertexInputAttributeOffset; + uint32_t maxVertexInputBindingStride; + uint32_t maxVertexOutputComponents; + uint32_t maxTessellationGenerationLevel; + uint32_t maxTessellationPatchSize; + uint32_t maxTessellationControlPerVertexInputComponents; + uint32_t maxTessellationControlPerVertexOutputComponents; + uint32_t maxTessellationControlPerPatchOutputComponents; + uint32_t maxTessellationControlTotalOutputComponents; + uint32_t maxTessellationEvaluationInputComponents; + uint32_t maxTessellationEvaluationOutputComponents; + uint32_t maxGeometryShaderInvocations; + uint32_t maxGeometryInputComponents; + uint32_t maxGeometryOutputComponents; + uint32_t maxGeometryOutputVertices; + uint32_t maxGeometryTotalOutputComponents; + uint32_t maxFragmentInputComponents; + uint32_t maxFragmentOutputAttachments; + uint32_t maxFragmentDualSrcAttachments; + uint32_t maxFragmentCombinedOutputResources; + uint32_t maxComputeSharedMemorySize; + uint32_t maxComputeWorkGroupCount[3]; + uint32_t maxComputeWorkGroupInvocations; + uint32_t maxComputeWorkGroupSize[3]; + uint32_t subPixelPrecisionBits; + uint32_t subTexelPrecisionBits; + uint32_t mipmapPrecisionBits; + uint32_t maxDrawIndexedIndexValue; + uint32_t maxDrawIndirectCount; + float maxSamplerLodBias; + float maxSamplerAnisotropy; + uint32_t maxViewports; + uint32_t maxViewportDimensions[2]; + float viewportBoundsRange[2]; + uint32_t viewportSubPixelBits; + size_t minMemoryMapAlignment; + VkDeviceSize minTexelBufferOffsetAlignment; + VkDeviceSize minUniformBufferOffsetAlignment; + VkDeviceSize minStorageBufferOffsetAlignment; + int32_t minTexelOffset; + uint32_t maxTexelOffset; + int32_t minTexelGatherOffset; + uint32_t maxTexelGatherOffset; + float minInterpolationOffset; + float maxInterpolationOffset; + uint32_t subPixelInterpolationOffsetBits; + uint32_t maxFramebufferWidth; + uint32_t maxFramebufferHeight; + uint32_t maxFramebufferLayers; + VkSampleCountFlags framebufferColorSampleCounts; + VkSampleCountFlags framebufferDepthSampleCounts; + VkSampleCountFlags framebufferStencilSampleCounts; + VkSampleCountFlags framebufferNoAttachmentsSampleCounts; + uint32_t maxColorAttachments; + VkSampleCountFlags sampledImageColorSampleCounts; + VkSampleCountFlags sampledImageIntegerSampleCounts; + VkSampleCountFlags sampledImageDepthSampleCounts; + VkSampleCountFlags sampledImageStencilSampleCounts; + VkSampleCountFlags storageImageSampleCounts; + uint32_t maxSampleMaskWords; + VkBool32 timestampComputeAndGraphics; + float timestampPeriod; + uint32_t maxClipDistances; + uint32_t maxCullDistances; + uint32_t maxCombinedClipAndCullDistances; + uint32_t discreteQueuePriorities; + float pointSizeRange[2]; + float lineWidthRange[2]; + float pointSizeGranularity; + float lineWidthGranularity; + VkBool32 strictLines; + VkBool32 standardSampleLocations; + VkDeviceSize optimalBufferCopyOffsetAlignment; + VkDeviceSize optimalBufferCopyRowPitchAlignment; + VkDeviceSize nonCoherentAtomSize; +} VkPhysicalDeviceLimits; + +typedef struct VkPhysicalDeviceMemoryProperties { + uint32_t memoryTypeCount; + VkMemoryType memoryTypes[32U]; + uint32_t memoryHeapCount; + VkMemoryHeap memoryHeaps[16U]; +} VkPhysicalDeviceMemoryProperties; + +typedef struct VkPhysicalDeviceSparseProperties { + VkBool32 residencyStandard2DBlockShape; + VkBool32 residencyStandard2DMultisampleBlockShape; + VkBool32 residencyStandard3DBlockShape; + VkBool32 residencyAlignedMipSize; + VkBool32 residencyNonResidentStrict; +} VkPhysicalDeviceSparseProperties; + +typedef struct VkPhysicalDeviceProperties { + uint32_t apiVersion; + uint32_t driverVersion; + uint32_t vendorID; + uint32_t deviceID; + VkPhysicalDeviceType deviceType; + char deviceName[256U]; + uint8_t pipelineCacheUUID[16U]; + VkPhysicalDeviceLimits limits; + VkPhysicalDeviceSparseProperties sparseProperties; +} VkPhysicalDeviceProperties; + +typedef struct VkQueueFamilyProperties { + VkQueueFlags queueFlags; + uint32_t queueCount; + uint32_t timestampValidBits; + VkExtent3D minImageTransferGranularity; +} VkQueueFamilyProperties; + +typedef struct VkDeviceQueueCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueCount; + const float* pQueuePriorities; +} VkDeviceQueueCreateInfo; + +typedef struct VkDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceCreateFlags flags; + uint32_t queueCreateInfoCount; + const VkDeviceQueueCreateInfo* pQueueCreateInfos; + uint32_t enabledLayerCount; + const char* const* ppEnabledLayerNames; + uint32_t enabledExtensionCount; + const char* const* ppEnabledExtensionNames; + const VkPhysicalDeviceFeatures* pEnabledFeatures; +} VkDeviceCreateInfo; + +typedef struct VkExtensionProperties { + char extensionName[256U]; + uint32_t specVersion; +} VkExtensionProperties; + +typedef struct VkLayerProperties { + char layerName[256U]; + uint32_t specVersion; + uint32_t implementationVersion; + char description[256U]; +} VkLayerProperties; + +typedef struct VkSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + const VkPipelineStageFlags* pWaitDstStageMask; + uint32_t commandBufferCount; + const VkCommandBuffer* pCommandBuffers; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkSubmitInfo; + +typedef struct VkMappedMemoryRange { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMappedMemoryRange; + +typedef struct VkMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDeviceSize allocationSize; + uint32_t memoryTypeIndex; +} VkMemoryAllocateInfo; + +typedef struct VkMemoryRequirements { + VkDeviceSize size; + VkDeviceSize alignment; + uint32_t memoryTypeBits; +} VkMemoryRequirements; + +typedef struct VkSparseMemoryBind { + VkDeviceSize resourceOffset; + VkDeviceSize size; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseMemoryBind; + +typedef struct VkSparseBufferMemoryBindInfo { + VkBuffer buffer; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseBufferMemoryBindInfo; + +typedef struct VkSparseImageOpaqueMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseMemoryBind* pBinds; +} VkSparseImageOpaqueMemoryBindInfo; + +typedef struct VkImageSubresource { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t arrayLayer; +} VkImageSubresource; + +typedef struct VkSparseImageMemoryBind { + VkImageSubresource subresource; + VkOffset3D offset; + VkExtent3D extent; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkSparseMemoryBindFlags flags; +} VkSparseImageMemoryBind; + +typedef struct VkSparseImageMemoryBindInfo { + VkImage image; + uint32_t bindCount; + const VkSparseImageMemoryBind* pBinds; +} VkSparseImageMemoryBindInfo; + +typedef struct VkBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t bufferBindCount; + const VkSparseBufferMemoryBindInfo* pBufferBinds; + uint32_t imageOpaqueBindCount; + const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; + uint32_t imageBindCount; + const VkSparseImageMemoryBindInfo* pImageBinds; + uint32_t signalSemaphoreCount; + const VkSemaphore* pSignalSemaphores; +} VkBindSparseInfo; + +typedef struct VkSparseImageFormatProperties { + VkImageAspectFlags aspectMask; + VkExtent3D imageGranularity; + VkSparseImageFormatFlags flags; +} VkSparseImageFormatProperties; + +typedef struct VkSparseImageMemoryRequirements { + VkSparseImageFormatProperties formatProperties; + uint32_t imageMipTailFirstLod; + VkDeviceSize imageMipTailSize; + VkDeviceSize imageMipTailOffset; + VkDeviceSize imageMipTailStride; +} VkSparseImageMemoryRequirements; + +typedef struct VkFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkFenceCreateFlags flags; +} VkFenceCreateInfo; + +typedef struct VkSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreCreateFlags flags; +} VkSemaphoreCreateInfo; + +typedef struct VkEventCreateInfo { + VkStructureType sType; + const void* pNext; + VkEventCreateFlags flags; +} VkEventCreateInfo; + +typedef struct VkQueryPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkQueryPoolCreateFlags flags; + VkQueryType queryType; + uint32_t queryCount; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkQueryPoolCreateInfo; + +typedef struct VkBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkDeviceSize size; + VkBufferUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkBufferCreateInfo; + +typedef struct VkBufferViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkBufferViewCreateFlags flags; + VkBuffer buffer; + VkFormat format; + VkDeviceSize offset; + VkDeviceSize range; +} VkBufferViewCreateInfo; + +typedef struct VkImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageType imageType; + VkFormat format; + VkExtent3D extent; + uint32_t mipLevels; + uint32_t arrayLayers; + VkSampleCountFlagBits samples; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkImageLayout initialLayout; +} VkImageCreateInfo; + +typedef struct VkSubresourceLayout { + VkDeviceSize offset; + VkDeviceSize size; + VkDeviceSize rowPitch; + VkDeviceSize arrayPitch; + VkDeviceSize depthPitch; +} VkSubresourceLayout; + +typedef struct VkComponentMapping { + VkComponentSwizzle r; + VkComponentSwizzle g; + VkComponentSwizzle b; + VkComponentSwizzle a; +} VkComponentMapping; + +typedef struct VkImageViewCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageViewCreateFlags flags; + VkImage image; + VkImageViewType viewType; + VkFormat format; + VkComponentMapping components; + VkImageSubresourceRange subresourceRange; +} VkImageViewCreateInfo; + +typedef struct VkShaderModuleCreateInfo { + VkStructureType sType; + const void* pNext; + VkShaderModuleCreateFlags flags; + size_t codeSize; + const uint32_t* pCode; +} VkShaderModuleCreateInfo; + +typedef struct VkPipelineCacheCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCacheCreateFlags flags; + size_t initialDataSize; + const void* pInitialData; +} VkPipelineCacheCreateInfo; + +typedef struct VkSpecializationMapEntry { + uint32_t constantID; + uint32_t offset; + size_t size; +} VkSpecializationMapEntry; + +typedef struct VkSpecializationInfo { + uint32_t mapEntryCount; + const VkSpecializationMapEntry* pMapEntries; + size_t dataSize; + const void* pData; +} VkSpecializationInfo; + +typedef struct VkPipelineShaderStageCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineShaderStageCreateFlags flags; + VkShaderStageFlagBits stage; + VkShaderModule module; + const char* pName; + const VkSpecializationInfo* pSpecializationInfo; +} VkPipelineShaderStageCreateInfo; + +typedef struct VkComputePipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + VkPipelineShaderStageCreateInfo stage; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkComputePipelineCreateInfo; + +typedef struct VkVertexInputBindingDescription { + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; +} VkVertexInputBindingDescription; + +typedef struct VkVertexInputAttributeDescription { + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription; + +typedef struct VkPipelineVertexInputStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineVertexInputStateCreateFlags flags; + uint32_t vertexBindingDescriptionCount; + const VkVertexInputBindingDescription* pVertexBindingDescriptions; + uint32_t vertexAttributeDescriptionCount; + const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; +} VkPipelineVertexInputStateCreateInfo; + +typedef struct VkPipelineInputAssemblyStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineInputAssemblyStateCreateFlags flags; + VkPrimitiveTopology topology; + VkBool32 primitiveRestartEnable; +} VkPipelineInputAssemblyStateCreateInfo; + +typedef struct VkPipelineTessellationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineTessellationStateCreateFlags flags; + uint32_t patchControlPoints; +} VkPipelineTessellationStateCreateInfo; + +typedef struct VkViewport { + float x; + float y; + float width; + float height; + float minDepth; + float maxDepth; +} VkViewport; + +typedef struct VkPipelineViewportStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineViewportStateCreateFlags flags; + uint32_t viewportCount; + const VkViewport* pViewports; + uint32_t scissorCount; + const VkRect2D* pScissors; +} VkPipelineViewportStateCreateInfo; + +typedef struct VkPipelineRasterizationStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateCreateFlags flags; + VkBool32 depthClampEnable; + VkBool32 rasterizerDiscardEnable; + VkPolygonMode polygonMode; + VkCullModeFlags cullMode; + VkFrontFace frontFace; + VkBool32 depthBiasEnable; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; + float lineWidth; +} VkPipelineRasterizationStateCreateInfo; + +typedef struct VkPipelineMultisampleStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineMultisampleStateCreateFlags flags; + VkSampleCountFlagBits rasterizationSamples; + VkBool32 sampleShadingEnable; + float minSampleShading; + const VkSampleMask* pSampleMask; + VkBool32 alphaToCoverageEnable; + VkBool32 alphaToOneEnable; +} VkPipelineMultisampleStateCreateInfo; + +typedef struct VkStencilOpState { + VkStencilOp failOp; + VkStencilOp passOp; + VkStencilOp depthFailOp; + VkCompareOp compareOp; + uint32_t compareMask; + uint32_t writeMask; + uint32_t reference; +} VkStencilOpState; + +typedef struct VkPipelineDepthStencilStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDepthStencilStateCreateFlags flags; + VkBool32 depthTestEnable; + VkBool32 depthWriteEnable; + VkCompareOp depthCompareOp; + VkBool32 depthBoundsTestEnable; + VkBool32 stencilTestEnable; + VkStencilOpState front; + VkStencilOpState back; + float minDepthBounds; + float maxDepthBounds; +} VkPipelineDepthStencilStateCreateInfo; + +typedef struct VkPipelineColorBlendAttachmentState { + VkBool32 blendEnable; + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; + VkColorComponentFlags colorWriteMask; +} VkPipelineColorBlendAttachmentState; + +typedef struct VkPipelineColorBlendStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineColorBlendStateCreateFlags flags; + VkBool32 logicOpEnable; + VkLogicOp logicOp; + uint32_t attachmentCount; + const VkPipelineColorBlendAttachmentState* pAttachments; + float blendConstants[4]; +} VkPipelineColorBlendStateCreateInfo; + +typedef struct VkPipelineDynamicStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineDynamicStateCreateFlags flags; + uint32_t dynamicStateCount; + const VkDynamicState* pDynamicStates; +} VkPipelineDynamicStateCreateInfo; + +typedef struct VkGraphicsPipelineCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; + const VkPipelineViewportStateCreateInfo* pViewportState; + const VkPipelineRasterizationStateCreateInfo* pRasterizationState; + const VkPipelineMultisampleStateCreateInfo* pMultisampleState; + const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; + const VkPipelineColorBlendStateCreateInfo* pColorBlendState; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkRenderPass renderPass; + uint32_t subpass; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkGraphicsPipelineCreateInfo; + +typedef struct VkPushConstantRange { + VkShaderStageFlags stageFlags; + uint32_t offset; + uint32_t size; +} VkPushConstantRange; + +typedef struct VkPipelineLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineLayoutCreateFlags flags; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; +} VkPipelineLayoutCreateInfo; + +typedef struct VkSamplerCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerCreateFlags flags; + VkFilter magFilter; + VkFilter minFilter; + VkSamplerMipmapMode mipmapMode; + VkSamplerAddressMode addressModeU; + VkSamplerAddressMode addressModeV; + VkSamplerAddressMode addressModeW; + float mipLodBias; + VkBool32 anisotropyEnable; + float maxAnisotropy; + VkBool32 compareEnable; + VkCompareOp compareOp; + float minLod; + float maxLod; + VkBorderColor borderColor; + VkBool32 unnormalizedCoordinates; +} VkSamplerCreateInfo; + +typedef struct VkCopyDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet srcSet; + uint32_t srcBinding; + uint32_t srcArrayElement; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; +} VkCopyDescriptorSet; + +typedef struct VkDescriptorBufferInfo { + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize range; +} VkDescriptorBufferInfo; + +typedef struct VkDescriptorImageInfo { + VkSampler sampler; + VkImageView imageView; + VkImageLayout imageLayout; +} VkDescriptorImageInfo; + +typedef struct VkDescriptorPoolSize { + VkDescriptorType type; + uint32_t descriptorCount; +} VkDescriptorPoolSize; + +typedef struct VkDescriptorPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPoolCreateFlags flags; + uint32_t maxSets; + uint32_t poolSizeCount; + const VkDescriptorPoolSize* pPoolSizes; +} VkDescriptorPoolCreateInfo; + +typedef struct VkDescriptorSetAllocateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorPool descriptorPool; + uint32_t descriptorSetCount; + const VkDescriptorSetLayout* pSetLayouts; +} VkDescriptorSetAllocateInfo; + +typedef struct VkDescriptorSetLayoutBinding { + uint32_t binding; + VkDescriptorType descriptorType; + uint32_t descriptorCount; + VkShaderStageFlags stageFlags; + const VkSampler* pImmutableSamplers; +} VkDescriptorSetLayoutBinding; + +typedef struct VkDescriptorSetLayoutCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayoutCreateFlags flags; + uint32_t bindingCount; + const VkDescriptorSetLayoutBinding* pBindings; +} VkDescriptorSetLayoutCreateInfo; + +typedef struct VkWriteDescriptorSet { + VkStructureType sType; + const void* pNext; + VkDescriptorSet dstSet; + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + const VkDescriptorImageInfo* pImageInfo; + const VkDescriptorBufferInfo* pBufferInfo; + const VkBufferView* pTexelBufferView; +} VkWriteDescriptorSet; + +typedef struct VkAttachmentDescription { + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription; + +typedef struct VkAttachmentReference { + uint32_t attachment; + VkImageLayout layout; +} VkAttachmentReference; + +typedef struct VkFramebufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkFramebufferCreateFlags flags; + VkRenderPass renderPass; + uint32_t attachmentCount; + const VkImageView* pAttachments; + uint32_t width; + uint32_t height; + uint32_t layers; +} VkFramebufferCreateInfo; + +typedef struct VkSubpassDescription { + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t inputAttachmentCount; + const VkAttachmentReference* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference* pColorAttachments; + const VkAttachmentReference* pResolveAttachments; + const VkAttachmentReference* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription; + +typedef struct VkSubpassDependency { + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; +} VkSubpassDependency; + +typedef struct VkRenderPassCreateInfo { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency* pDependencies; +} VkRenderPassCreateInfo; + +typedef struct VkCommandPoolCreateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPoolCreateFlags flags; + uint32_t queueFamilyIndex; +} VkCommandPoolCreateInfo; + +typedef struct VkCommandBufferAllocateInfo { + VkStructureType sType; + const void* pNext; + VkCommandPool commandPool; + VkCommandBufferLevel level; + uint32_t commandBufferCount; +} VkCommandBufferAllocateInfo; + +typedef struct VkCommandBufferInheritanceInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + uint32_t subpass; + VkFramebuffer framebuffer; + VkBool32 occlusionQueryEnable; + VkQueryControlFlags queryFlags; + VkQueryPipelineStatisticFlags pipelineStatistics; +} VkCommandBufferInheritanceInfo; + +typedef struct VkCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + VkCommandBufferUsageFlags flags; + const VkCommandBufferInheritanceInfo* pInheritanceInfo; +} VkCommandBufferBeginInfo; + +typedef struct VkBufferCopy { + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy; + +typedef struct VkImageSubresourceLayers { + VkImageAspectFlags aspectMask; + uint32_t mipLevel; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkImageSubresourceLayers; + +typedef struct VkBufferImageCopy { + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy; + +typedef union VkClearColorValue { + float float32[4]; + int32_t int32[4]; + uint32_t uint32[4]; +} VkClearColorValue; + +typedef struct VkClearDepthStencilValue { + float depth; + uint32_t stencil; +} VkClearDepthStencilValue; + +typedef union VkClearValue { + VkClearColorValue color; + VkClearDepthStencilValue depthStencil; +} VkClearValue; + +typedef struct VkClearAttachment { + VkImageAspectFlags aspectMask; + uint32_t colorAttachment; + VkClearValue clearValue; +} VkClearAttachment; + +typedef struct VkClearRect { + VkRect2D rect; + uint32_t baseArrayLayer; + uint32_t layerCount; +} VkClearRect; + +typedef struct VkImageBlit { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit; + +typedef struct VkImageCopy { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy; + +typedef struct VkImageResolve { + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve; + +typedef struct VkRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + VkRenderPass renderPass; + VkFramebuffer framebuffer; + VkRect2D renderArea; + uint32_t clearValueCount; + const VkClearValue* pClearValues; +} VkRenderPassBeginInfo; + +typedef VkResult ( *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); +typedef void ( *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); +typedef void ( *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); +typedef void ( *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); +typedef VkResult ( *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); +typedef void ( *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); +typedef void ( *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); +typedef void ( *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); +typedef PFN_vkVoidFunction ( *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); +typedef PFN_vkVoidFunction ( *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); +typedef VkResult ( *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); +typedef void ( *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult ( *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); +typedef VkResult ( *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef VkResult ( *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); +typedef void ( *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); +typedef VkResult ( *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); +typedef VkResult ( *PFN_vkQueueWaitIdle)(VkQueue queue); +typedef VkResult ( *PFN_vkDeviceWaitIdle)(VkDevice device); +typedef VkResult ( *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); +typedef void ( *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); +typedef void ( *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); +typedef VkResult ( *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef VkResult ( *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); +typedef void ( *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); +typedef VkResult ( *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef VkResult ( *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); +typedef void ( *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); +typedef void ( *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); +typedef void ( *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); +typedef void ( *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); +typedef VkResult ( *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); +typedef VkResult ( *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef void ( *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); +typedef VkResult ( *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); +typedef VkResult ( *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); +typedef VkResult ( *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); +typedef void ( *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); +typedef void ( *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); +typedef VkResult ( *PFN_vkSetEvent)(VkDevice device, VkEvent event); +typedef VkResult ( *PFN_vkResetEvent)(VkDevice device, VkEvent event); +typedef VkResult ( *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); +typedef void ( *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); +typedef VkResult ( *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); +typedef void ( *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); +typedef void ( *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); +typedef void ( *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); +typedef VkResult ( *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); +typedef void ( *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); +typedef void ( *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); +typedef void ( *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); +typedef VkResult ( *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); +typedef VkResult ( *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult ( *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef void ( *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); +typedef void ( *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); +typedef void ( *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); +typedef void ( *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); +typedef void ( *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); +typedef VkResult ( *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); +typedef VkResult ( *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); +typedef void ( *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); +typedef VkResult ( *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); +typedef void ( *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void ( *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); +typedef VkResult ( *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); +typedef void ( *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); +typedef VkResult ( *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); +typedef void ( *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +typedef VkResult ( *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); +typedef VkResult ( *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); +typedef VkResult ( *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); +typedef void ( *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef void ( *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); +typedef void ( *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void ( *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); +typedef void ( *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); +typedef void ( *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); +typedef void ( *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); +typedef void ( *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); +typedef void ( *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); +typedef void ( *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); +typedef void ( *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); +typedef void ( *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); +typedef void ( *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); +typedef void ( *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); +typedef void ( *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); +typedef void ( *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void ( *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void ( *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void ( *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +typedef void ( *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); +typedef void ( *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); +typedef void ( *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); +typedef void ( *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void ( *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); +typedef void ( *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); +typedef void ( *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); +typedef void ( *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void ( *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); +typedef void ( *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); +typedef void ( *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); +typedef void ( *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void ( *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); +typedef void ( *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void ( *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); +typedef void ( *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); +typedef void ( *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); +typedef void ( *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef void ( *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); +typedef void ( *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); +typedef void ( *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); +typedef void ( *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); +typedef void ( *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); +typedef void ( *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); +typedef void ( *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); +# 4933 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkSamplerYcbcrConversion_T *VkSamplerYcbcrConversion; +typedef struct VkDescriptorUpdateTemplate_T *VkDescriptorUpdateTemplate; + + + + +typedef enum VkPointClippingBehavior { + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, + VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, + VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, + VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF +} VkPointClippingBehavior; + +typedef enum VkTessellationDomainOrigin { + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, + VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, + VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF +} VkTessellationDomainOrigin; + +typedef enum VkSamplerYcbcrModelConversion { + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, + VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrModelConversion; + +typedef enum VkSamplerYcbcrRange { + VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, + VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, + VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, + VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerYcbcrRange; + +typedef enum VkChromaLocation { + VK_CHROMA_LOCATION_COSITED_EVEN = 0, + VK_CHROMA_LOCATION_MIDPOINT = 1, + VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, + VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, + VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF +} VkChromaLocation; + +typedef enum VkDescriptorUpdateTemplateType { + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, + VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorUpdateTemplateType; + +typedef enum VkSubgroupFeatureFlagBits { + VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, + VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, + VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, + VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, + VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, + VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, + VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, + VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, + VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, + VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubgroupFeatureFlagBits; +typedef VkFlags VkSubgroupFeatureFlags; + +typedef enum VkPeerMemoryFeatureFlagBits { + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, + VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, + VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, + VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, + VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPeerMemoryFeatureFlagBits; +typedef VkFlags VkPeerMemoryFeatureFlags; + +typedef enum VkMemoryAllocateFlagBits { + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004, + VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, + VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, + VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkMemoryAllocateFlagBits; +typedef VkFlags VkMemoryAllocateFlags; +typedef VkFlags VkCommandPoolTrimFlags; +typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; + +typedef enum VkExternalMemoryHandleTypeFlagBits { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX = 0x00004000, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBits; +typedef VkFlags VkExternalMemoryHandleTypeFlags; + +typedef enum VkExternalMemoryFeatureFlagBits { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBits; +typedef VkFlags VkExternalMemoryFeatureFlags; + +typedef enum VkExternalFenceHandleTypeFlagBits { + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceHandleTypeFlagBits; +typedef VkFlags VkExternalFenceHandleTypeFlags; + +typedef enum VkExternalFenceFeatureFlagBits { + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalFenceFeatureFlagBits; +typedef VkFlags VkExternalFenceFeatureFlags; + +typedef enum VkFenceImportFlagBits { + VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, + VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkFenceImportFlagBits; +typedef VkFlags VkFenceImportFlags; + +typedef enum VkSemaphoreImportFlagBits { + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, + VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, + VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreImportFlagBits; +typedef VkFlags VkSemaphoreImportFlags; + +typedef enum VkExternalSemaphoreHandleTypeFlagBits { + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, + VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreHandleTypeFlagBits; +typedef VkFlags VkExternalSemaphoreHandleTypeFlags; + +typedef enum VkExternalSemaphoreFeatureFlagBits { + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, + VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, + VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkExternalSemaphoreFeatureFlagBits; +typedef VkFlags VkExternalSemaphoreFeatureFlags; +typedef struct VkPhysicalDeviceSubgroupProperties { + VkStructureType sType; + void* pNext; + uint32_t subgroupSize; + VkShaderStageFlags supportedStages; + VkSubgroupFeatureFlags supportedOperations; + VkBool32 quadOperationsInAllStages; +} VkPhysicalDeviceSubgroupProperties; + +typedef struct VkBindBufferMemoryInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindBufferMemoryInfo; + +typedef struct VkBindImageMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; +} VkBindImageMemoryInfo; + +typedef struct VkPhysicalDevice16BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; +} VkPhysicalDevice16BitStorageFeatures; + +typedef struct VkMemoryDedicatedRequirements { + VkStructureType sType; + void* pNext; + VkBool32 prefersDedicatedAllocation; + VkBool32 requiresDedicatedAllocation; +} VkMemoryDedicatedRequirements; + +typedef struct VkMemoryDedicatedAllocateInfo { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkMemoryDedicatedAllocateInfo; + +typedef struct VkMemoryAllocateFlagsInfo { + VkStructureType sType; + const void* pNext; + VkMemoryAllocateFlags flags; + uint32_t deviceMask; +} VkMemoryAllocateFlagsInfo; + +typedef struct VkDeviceGroupRenderPassBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; + uint32_t deviceRenderAreaCount; + const VkRect2D* pDeviceRenderAreas; +} VkDeviceGroupRenderPassBeginInfo; + +typedef struct VkDeviceGroupCommandBufferBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceMask; +} VkDeviceGroupCommandBufferBeginInfo; + +typedef struct VkDeviceGroupSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const uint32_t* pWaitSemaphoreDeviceIndices; + uint32_t commandBufferCount; + const uint32_t* pCommandBufferDeviceMasks; + uint32_t signalSemaphoreCount; + const uint32_t* pSignalSemaphoreDeviceIndices; +} VkDeviceGroupSubmitInfo; + +typedef struct VkDeviceGroupBindSparseInfo { + VkStructureType sType; + const void* pNext; + uint32_t resourceDeviceIndex; + uint32_t memoryDeviceIndex; +} VkDeviceGroupBindSparseInfo; + +typedef struct VkBindBufferMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindBufferMemoryDeviceGroupInfo; + +typedef struct VkBindImageMemoryDeviceGroupInfo { + VkStructureType sType; + const void* pNext; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; + uint32_t splitInstanceBindRegionCount; + const VkRect2D* pSplitInstanceBindRegions; +} VkBindImageMemoryDeviceGroupInfo; + +typedef struct VkPhysicalDeviceGroupProperties { + VkStructureType sType; + void* pNext; + uint32_t physicalDeviceCount; + VkPhysicalDevice physicalDevices[32U]; + VkBool32 subsetAllocation; +} VkPhysicalDeviceGroupProperties; + +typedef struct VkDeviceGroupDeviceCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t physicalDeviceCount; + const VkPhysicalDevice* pPhysicalDevices; +} VkDeviceGroupDeviceCreateInfo; + +typedef struct VkBufferMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferMemoryRequirementsInfo2; + +typedef struct VkImageMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageMemoryRequirementsInfo2; + +typedef struct VkImageSparseMemoryRequirementsInfo2 { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageSparseMemoryRequirementsInfo2; + +typedef struct VkMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkMemoryRequirements memoryRequirements; +} VkMemoryRequirements2; + +typedef struct VkSparseImageMemoryRequirements2 { + VkStructureType sType; + void* pNext; + VkSparseImageMemoryRequirements memoryRequirements; +} VkSparseImageMemoryRequirements2; + +typedef struct VkPhysicalDeviceFeatures2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceFeatures features; +} VkPhysicalDeviceFeatures2; + +typedef struct VkPhysicalDeviceProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceProperties properties; +} VkPhysicalDeviceProperties2; + +typedef struct VkFormatProperties2 { + VkStructureType sType; + void* pNext; + VkFormatProperties formatProperties; +} VkFormatProperties2; + +typedef struct VkImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkImageFormatProperties imageFormatProperties; +} VkImageFormatProperties2; + +typedef struct VkPhysicalDeviceImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkImageTiling tiling; + VkImageUsageFlags usage; + VkImageCreateFlags flags; +} VkPhysicalDeviceImageFormatInfo2; + +typedef struct VkQueueFamilyProperties2 { + VkStructureType sType; + void* pNext; + VkQueueFamilyProperties queueFamilyProperties; +} VkQueueFamilyProperties2; + +typedef struct VkPhysicalDeviceMemoryProperties2 { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceMemoryProperties memoryProperties; +} VkPhysicalDeviceMemoryProperties2; + +typedef struct VkSparseImageFormatProperties2 { + VkStructureType sType; + void* pNext; + VkSparseImageFormatProperties properties; +} VkSparseImageFormatProperties2; + +typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkImageType type; + VkSampleCountFlagBits samples; + VkImageUsageFlags usage; + VkImageTiling tiling; +} VkPhysicalDeviceSparseImageFormatInfo2; + +typedef struct VkPhysicalDevicePointClippingProperties { + VkStructureType sType; + void* pNext; + VkPointClippingBehavior pointClippingBehavior; +} VkPhysicalDevicePointClippingProperties; + +typedef struct VkInputAttachmentAspectReference { + uint32_t subpass; + uint32_t inputAttachmentIndex; + VkImageAspectFlags aspectMask; +} VkInputAttachmentAspectReference; + +typedef struct VkRenderPassInputAttachmentAspectCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t aspectReferenceCount; + const VkInputAttachmentAspectReference* pAspectReferences; +} VkRenderPassInputAttachmentAspectCreateInfo; + +typedef struct VkImageViewUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags usage; +} VkImageViewUsageCreateInfo; + +typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { + VkStructureType sType; + const void* pNext; + VkTessellationDomainOrigin domainOrigin; +} VkPipelineTessellationDomainOriginStateCreateInfo; + +typedef struct VkRenderPassMultiviewCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t subpassCount; + const uint32_t* pViewMasks; + uint32_t dependencyCount; + const int32_t* pViewOffsets; + uint32_t correlationMaskCount; + const uint32_t* pCorrelationMasks; +} VkRenderPassMultiviewCreateInfo; + +typedef struct VkPhysicalDeviceMultiviewFeatures { + VkStructureType sType; + void* pNext; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; +} VkPhysicalDeviceMultiviewFeatures; + +typedef struct VkPhysicalDeviceMultiviewProperties { + VkStructureType sType; + void* pNext; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; +} VkPhysicalDeviceMultiviewProperties; + +typedef struct VkPhysicalDeviceVariablePointersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; +} VkPhysicalDeviceVariablePointersFeatures; + +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 protectedMemory; +} VkPhysicalDeviceProtectedMemoryFeatures; + +typedef struct VkPhysicalDeviceProtectedMemoryProperties { + VkStructureType sType; + void* pNext; + VkBool32 protectedNoFault; +} VkPhysicalDeviceProtectedMemoryProperties; + +typedef struct VkDeviceQueueInfo2 { + VkStructureType sType; + const void* pNext; + VkDeviceQueueCreateFlags flags; + uint32_t queueFamilyIndex; + uint32_t queueIndex; +} VkDeviceQueueInfo2; + +typedef struct VkProtectedSubmitInfo { + VkStructureType sType; + const void* pNext; + VkBool32 protectedSubmit; +} VkProtectedSubmitInfo; + +typedef struct VkSamplerYcbcrConversionCreateInfo { + VkStructureType sType; + const void* pNext; + VkFormat format; + VkSamplerYcbcrModelConversion ycbcrModel; + VkSamplerYcbcrRange ycbcrRange; + VkComponentMapping components; + VkChromaLocation xChromaOffset; + VkChromaLocation yChromaOffset; + VkFilter chromaFilter; + VkBool32 forceExplicitReconstruction; +} VkSamplerYcbcrConversionCreateInfo; + +typedef struct VkSamplerYcbcrConversionInfo { + VkStructureType sType; + const void* pNext; + VkSamplerYcbcrConversion conversion; +} VkSamplerYcbcrConversionInfo; + +typedef struct VkBindImagePlaneMemoryInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkBindImagePlaneMemoryInfo; + +typedef struct VkImagePlaneMemoryRequirementsInfo { + VkStructureType sType; + const void* pNext; + VkImageAspectFlagBits planeAspect; +} VkImagePlaneMemoryRequirementsInfo; + +typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { + VkStructureType sType; + void* pNext; + VkBool32 samplerYcbcrConversion; +} VkPhysicalDeviceSamplerYcbcrConversionFeatures; + +typedef struct VkSamplerYcbcrConversionImageFormatProperties { + VkStructureType sType; + void* pNext; + uint32_t combinedImageSamplerDescriptorCount; +} VkSamplerYcbcrConversionImageFormatProperties; + +typedef struct VkDescriptorUpdateTemplateEntry { + uint32_t dstBinding; + uint32_t dstArrayElement; + uint32_t descriptorCount; + VkDescriptorType descriptorType; + size_t offset; + size_t stride; +} VkDescriptorUpdateTemplateEntry; + +typedef struct VkDescriptorUpdateTemplateCreateInfo { + VkStructureType sType; + const void* pNext; + VkDescriptorUpdateTemplateCreateFlags flags; + uint32_t descriptorUpdateEntryCount; + const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; + VkDescriptorUpdateTemplateType templateType; + VkDescriptorSetLayout descriptorSetLayout; + VkPipelineBindPoint pipelineBindPoint; + VkPipelineLayout pipelineLayout; + uint32_t set; +} VkDescriptorUpdateTemplateCreateInfo; + +typedef struct VkExternalMemoryProperties { + VkExternalMemoryFeatureFlags externalMemoryFeatures; + VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlags compatibleHandleTypes; +} VkExternalMemoryProperties; + +typedef struct VkPhysicalDeviceExternalImageFormatInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalImageFormatInfo; + +typedef struct VkExternalImageFormatProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalImageFormatProperties; + +typedef struct VkPhysicalDeviceExternalBufferInfo { + VkStructureType sType; + const void* pNext; + VkBufferCreateFlags flags; + VkBufferUsageFlags usage; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalBufferInfo; + +typedef struct VkExternalBufferProperties { + VkStructureType sType; + void* pNext; + VkExternalMemoryProperties externalMemoryProperties; +} VkExternalBufferProperties; + +typedef struct VkPhysicalDeviceIDProperties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[16U]; + uint8_t driverUUID[16U]; + uint8_t deviceLUID[8U]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; +} VkPhysicalDeviceIDProperties; + +typedef struct VkExternalMemoryImageCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryImageCreateInfo; + +typedef struct VkExternalMemoryBufferCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExternalMemoryBufferCreateInfo; + +typedef struct VkExportMemoryAllocateInfo { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlags handleTypes; +} VkExportMemoryAllocateInfo; + +typedef struct VkPhysicalDeviceExternalFenceInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalFenceInfo; + +typedef struct VkExternalFenceProperties { + VkStructureType sType; + void* pNext; + VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; + VkExternalFenceHandleTypeFlags compatibleHandleTypes; + VkExternalFenceFeatureFlags externalFenceFeatures; +} VkExternalFenceProperties; + +typedef struct VkExportFenceCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalFenceHandleTypeFlags handleTypes; +} VkExportFenceCreateInfo; + +typedef struct VkExportSemaphoreCreateInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlags handleTypes; +} VkExportSemaphoreCreateInfo; + +typedef struct VkPhysicalDeviceExternalSemaphoreInfo { + VkStructureType sType; + const void* pNext; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkPhysicalDeviceExternalSemaphoreInfo; + +typedef struct VkExternalSemaphoreProperties { + VkStructureType sType; + void* pNext; + VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; + VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; + VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; +} VkExternalSemaphoreProperties; + +typedef struct VkPhysicalDeviceMaintenance3Properties { + VkStructureType sType; + void* pNext; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceMaintenance3Properties; + +typedef struct VkDescriptorSetLayoutSupport { + VkStructureType sType; + void* pNext; + VkBool32 supported; +} VkDescriptorSetLayoutSupport; + +typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceShaderDrawParametersFeatures; + +typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; + +typedef VkResult ( *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); +typedef VkResult ( *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult ( *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +typedef void ( *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void ( *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void ( *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef VkResult ( *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +typedef void ( *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +typedef void ( *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void ( *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void ( *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult ( *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void ( *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void ( *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void ( *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +typedef void ( *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +typedef void ( *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); +typedef VkResult ( *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void ( *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void ( *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +typedef void ( *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +typedef void ( *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +typedef void ( *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +typedef void ( *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +# 5803 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkDriverId { + VK_DRIVER_ID_AMD_PROPRIETARY = 1, + VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, + VK_DRIVER_ID_MESA_RADV = 3, + VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, + VK_DRIVER_ID_ARM_PROPRIETARY = 9, + VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, + VK_DRIVER_ID_GGP_PROPRIETARY = 11, + VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, + VK_DRIVER_ID_MESA_LLVMPIPE = 13, + VK_DRIVER_ID_MOLTENVK = 14, + VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, + VK_DRIVER_ID_JUICE_PROPRIETARY = 16, + VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, + VK_DRIVER_ID_MESA_TURNIP = 18, + VK_DRIVER_ID_MESA_V3DV = 19, + VK_DRIVER_ID_MESA_PANVK = 20, + VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, + VK_DRIVER_ID_MESA_VENUS = 22, + VK_DRIVER_ID_MESA_DOZEN = 23, + VK_DRIVER_ID_MESA_NVK = 24, + VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, + VK_DRIVER_ID_MESA_AGXV = 26, + VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, + VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, + VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, + VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY, + VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, + VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, + VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, + VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, + VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY, + VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, + VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY, + VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY, + VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF +} VkDriverId; + +typedef enum VkShaderFloatControlsIndependence { + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, + VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF +} VkShaderFloatControlsIndependence; + +typedef enum VkSamplerReductionMode { + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, + VK_SAMPLER_REDUCTION_MODE_MIN = 1, + VK_SAMPLER_REDUCTION_MODE_MAX = 2, + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM = 1000521000, + VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, + VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN, + VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX, + VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF +} VkSamplerReductionMode; + +typedef enum VkSemaphoreType { + VK_SEMAPHORE_TYPE_BINARY = 0, + VK_SEMAPHORE_TYPE_TIMELINE = 1, + VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY, + VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE, + VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreType; + +typedef enum VkResolveModeFlagBits { + VK_RESOLVE_MODE_NONE = 0, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001, + VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002, + VK_RESOLVE_MODE_MIN_BIT = 0x00000004, + VK_RESOLVE_MODE_MAX_BIT = 0x00000008, + VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID = 0x00000010, + VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE, + VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, + VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT, + VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT, + VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT, + VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkResolveModeFlagBits; +typedef VkFlags VkResolveModeFlags; + +typedef enum VkDescriptorBindingFlagBits { + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001, + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002, + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004, + VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008, + VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, + VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, + VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, + VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, + VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkDescriptorBindingFlagBits; +typedef VkFlags VkDescriptorBindingFlags; + +typedef enum VkSemaphoreWaitFlagBits { + VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001, + VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT, + VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSemaphoreWaitFlagBits; +typedef VkFlags VkSemaphoreWaitFlags; +typedef struct VkPhysicalDeviceVulkan11Features { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer16BitAccess; + VkBool32 uniformAndStorageBuffer16BitAccess; + VkBool32 storagePushConstant16; + VkBool32 storageInputOutput16; + VkBool32 multiview; + VkBool32 multiviewGeometryShader; + VkBool32 multiviewTessellationShader; + VkBool32 variablePointersStorageBuffer; + VkBool32 variablePointers; + VkBool32 protectedMemory; + VkBool32 samplerYcbcrConversion; + VkBool32 shaderDrawParameters; +} VkPhysicalDeviceVulkan11Features; + +typedef struct VkPhysicalDeviceVulkan11Properties { + VkStructureType sType; + void* pNext; + uint8_t deviceUUID[16U]; + uint8_t driverUUID[16U]; + uint8_t deviceLUID[8U]; + uint32_t deviceNodeMask; + VkBool32 deviceLUIDValid; + uint32_t subgroupSize; + VkShaderStageFlags subgroupSupportedStages; + VkSubgroupFeatureFlags subgroupSupportedOperations; + VkBool32 subgroupQuadOperationsInAllStages; + VkPointClippingBehavior pointClippingBehavior; + uint32_t maxMultiviewViewCount; + uint32_t maxMultiviewInstanceIndex; + VkBool32 protectedNoFault; + uint32_t maxPerSetDescriptors; + VkDeviceSize maxMemoryAllocationSize; +} VkPhysicalDeviceVulkan11Properties; + +typedef struct VkPhysicalDeviceVulkan12Features { + VkStructureType sType; + void* pNext; + VkBool32 samplerMirrorClampToEdge; + VkBool32 drawIndirectCount; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; + VkBool32 descriptorIndexing; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; + VkBool32 samplerFilterMinmax; + VkBool32 scalarBlockLayout; + VkBool32 imagelessFramebuffer; + VkBool32 uniformBufferStandardLayout; + VkBool32 shaderSubgroupExtendedTypes; + VkBool32 separateDepthStencilLayouts; + VkBool32 hostQueryReset; + VkBool32 timelineSemaphore; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; + VkBool32 shaderOutputViewportIndex; + VkBool32 shaderOutputLayer; + VkBool32 subgroupBroadcastDynamicId; +} VkPhysicalDeviceVulkan12Features; + +typedef struct VkConformanceVersion { + uint8_t major; + uint8_t minor; + uint8_t subminor; + uint8_t patch; +} VkConformanceVersion; + +typedef struct VkPhysicalDeviceVulkan12Properties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[256U]; + char driverInfo[256U]; + VkConformanceVersion conformanceVersion; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; + uint64_t maxTimelineSemaphoreValueDifference; + VkSampleCountFlags framebufferIntegerColorSampleCounts; +} VkPhysicalDeviceVulkan12Properties; + +typedef struct VkImageFormatListCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkImageFormatListCreateInfo; + +typedef struct VkAttachmentDescription2 { + VkStructureType sType; + const void* pNext; + VkAttachmentDescriptionFlags flags; + VkFormat format; + VkSampleCountFlagBits samples; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkAttachmentLoadOp stencilLoadOp; + VkAttachmentStoreOp stencilStoreOp; + VkImageLayout initialLayout; + VkImageLayout finalLayout; +} VkAttachmentDescription2; + +typedef struct VkAttachmentReference2 { + VkStructureType sType; + const void* pNext; + uint32_t attachment; + VkImageLayout layout; + VkImageAspectFlags aspectMask; +} VkAttachmentReference2; + +typedef struct VkSubpassDescription2 { + VkStructureType sType; + const void* pNext; + VkSubpassDescriptionFlags flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t viewMask; + uint32_t inputAttachmentCount; + const VkAttachmentReference2* pInputAttachments; + uint32_t colorAttachmentCount; + const VkAttachmentReference2* pColorAttachments; + const VkAttachmentReference2* pResolveAttachments; + const VkAttachmentReference2* pDepthStencilAttachment; + uint32_t preserveAttachmentCount; + const uint32_t* pPreserveAttachments; +} VkSubpassDescription2; + +typedef struct VkSubpassDependency2 { + VkStructureType sType; + const void* pNext; + uint32_t srcSubpass; + uint32_t dstSubpass; + VkPipelineStageFlags srcStageMask; + VkPipelineStageFlags dstStageMask; + VkAccessFlags srcAccessMask; + VkAccessFlags dstAccessMask; + VkDependencyFlags dependencyFlags; + int32_t viewOffset; +} VkSubpassDependency2; + +typedef struct VkRenderPassCreateInfo2 { + VkStructureType sType; + const void* pNext; + VkRenderPassCreateFlags flags; + uint32_t attachmentCount; + const VkAttachmentDescription2* pAttachments; + uint32_t subpassCount; + const VkSubpassDescription2* pSubpasses; + uint32_t dependencyCount; + const VkSubpassDependency2* pDependencies; + uint32_t correlatedViewMaskCount; + const uint32_t* pCorrelatedViewMasks; +} VkRenderPassCreateInfo2; + +typedef struct VkSubpassBeginInfo { + VkStructureType sType; + const void* pNext; + VkSubpassContents contents; +} VkSubpassBeginInfo; + +typedef struct VkSubpassEndInfo { + VkStructureType sType; + const void* pNext; +} VkSubpassEndInfo; + +typedef struct VkPhysicalDevice8BitStorageFeatures { + VkStructureType sType; + void* pNext; + VkBool32 storageBuffer8BitAccess; + VkBool32 uniformAndStorageBuffer8BitAccess; + VkBool32 storagePushConstant8; +} VkPhysicalDevice8BitStorageFeatures; + +typedef struct VkPhysicalDeviceDriverProperties { + VkStructureType sType; + void* pNext; + VkDriverId driverID; + char driverName[256U]; + char driverInfo[256U]; + VkConformanceVersion conformanceVersion; +} VkPhysicalDeviceDriverProperties; + +typedef struct VkPhysicalDeviceShaderAtomicInt64Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferInt64Atomics; + VkBool32 shaderSharedInt64Atomics; +} VkPhysicalDeviceShaderAtomicInt64Features; + +typedef struct VkPhysicalDeviceShaderFloat16Int8Features { + VkStructureType sType; + void* pNext; + VkBool32 shaderFloat16; + VkBool32 shaderInt8; +} VkPhysicalDeviceShaderFloat16Int8Features; + +typedef struct VkPhysicalDeviceFloatControlsProperties { + VkStructureType sType; + void* pNext; + VkShaderFloatControlsIndependence denormBehaviorIndependence; + VkShaderFloatControlsIndependence roundingModeIndependence; + VkBool32 shaderSignedZeroInfNanPreserveFloat16; + VkBool32 shaderSignedZeroInfNanPreserveFloat32; + VkBool32 shaderSignedZeroInfNanPreserveFloat64; + VkBool32 shaderDenormPreserveFloat16; + VkBool32 shaderDenormPreserveFloat32; + VkBool32 shaderDenormPreserveFloat64; + VkBool32 shaderDenormFlushToZeroFloat16; + VkBool32 shaderDenormFlushToZeroFloat32; + VkBool32 shaderDenormFlushToZeroFloat64; + VkBool32 shaderRoundingModeRTEFloat16; + VkBool32 shaderRoundingModeRTEFloat32; + VkBool32 shaderRoundingModeRTEFloat64; + VkBool32 shaderRoundingModeRTZFloat16; + VkBool32 shaderRoundingModeRTZFloat32; + VkBool32 shaderRoundingModeRTZFloat64; +} VkPhysicalDeviceFloatControlsProperties; + +typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t bindingCount; + const VkDescriptorBindingFlags* pBindingFlags; +} VkDescriptorSetLayoutBindingFlagsCreateInfo; + +typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderInputAttachmentArrayDynamicIndexing; + VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; + VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; + VkBool32 shaderUniformBufferArrayNonUniformIndexing; + VkBool32 shaderSampledImageArrayNonUniformIndexing; + VkBool32 shaderStorageBufferArrayNonUniformIndexing; + VkBool32 shaderStorageImageArrayNonUniformIndexing; + VkBool32 shaderInputAttachmentArrayNonUniformIndexing; + VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; + VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; + VkBool32 descriptorBindingUniformBufferUpdateAfterBind; + VkBool32 descriptorBindingSampledImageUpdateAfterBind; + VkBool32 descriptorBindingStorageImageUpdateAfterBind; + VkBool32 descriptorBindingStorageBufferUpdateAfterBind; + VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; + VkBool32 descriptorBindingUpdateUnusedWhilePending; + VkBool32 descriptorBindingPartiallyBound; + VkBool32 descriptorBindingVariableDescriptorCount; + VkBool32 runtimeDescriptorArray; +} VkPhysicalDeviceDescriptorIndexingFeatures; + +typedef struct VkPhysicalDeviceDescriptorIndexingProperties { + VkStructureType sType; + void* pNext; + uint32_t maxUpdateAfterBindDescriptorsInAllPools; + VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; + VkBool32 shaderSampledImageArrayNonUniformIndexingNative; + VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; + VkBool32 shaderStorageImageArrayNonUniformIndexingNative; + VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; + VkBool32 robustBufferAccessUpdateAfterBind; + VkBool32 quadDivergentImplicitLod; + uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; + uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; + uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; + uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; + uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; + uint32_t maxPerStageUpdateAfterBindResources; + uint32_t maxDescriptorSetUpdateAfterBindSamplers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; + uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; + uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; + uint32_t maxDescriptorSetUpdateAfterBindSampledImages; + uint32_t maxDescriptorSetUpdateAfterBindStorageImages; + uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; +} VkPhysicalDeviceDescriptorIndexingProperties; + +typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo { + VkStructureType sType; + const void* pNext; + uint32_t descriptorSetCount; + const uint32_t* pDescriptorCounts; +} VkDescriptorSetVariableDescriptorCountAllocateInfo; + +typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { + VkStructureType sType; + void* pNext; + uint32_t maxVariableDescriptorCount; +} VkDescriptorSetVariableDescriptorCountLayoutSupport; + +typedef struct VkSubpassDescriptionDepthStencilResolve { + VkStructureType sType; + const void* pNext; + VkResolveModeFlagBits depthResolveMode; + VkResolveModeFlagBits stencilResolveMode; + const VkAttachmentReference2* pDepthStencilResolveAttachment; +} VkSubpassDescriptionDepthStencilResolve; + +typedef struct VkPhysicalDeviceDepthStencilResolveProperties { + VkStructureType sType; + void* pNext; + VkResolveModeFlags supportedDepthResolveModes; + VkResolveModeFlags supportedStencilResolveModes; + VkBool32 independentResolveNone; + VkBool32 independentResolve; +} VkPhysicalDeviceDepthStencilResolveProperties; + +typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 scalarBlockLayout; +} VkPhysicalDeviceScalarBlockLayoutFeatures; + +typedef struct VkImageStencilUsageCreateInfo { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags stencilUsage; +} VkImageStencilUsageCreateInfo; + +typedef struct VkSamplerReductionModeCreateInfo { + VkStructureType sType; + const void* pNext; + VkSamplerReductionMode reductionMode; +} VkSamplerReductionModeCreateInfo; + +typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { + VkStructureType sType; + void* pNext; + VkBool32 filterMinmaxSingleComponentFormats; + VkBool32 filterMinmaxImageComponentMapping; +} VkPhysicalDeviceSamplerFilterMinmaxProperties; + +typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { + VkStructureType sType; + void* pNext; + VkBool32 vulkanMemoryModel; + VkBool32 vulkanMemoryModelDeviceScope; + VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; +} VkPhysicalDeviceVulkanMemoryModelFeatures; + +typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { + VkStructureType sType; + void* pNext; + VkBool32 imagelessFramebuffer; +} VkPhysicalDeviceImagelessFramebufferFeatures; + +typedef struct VkFramebufferAttachmentImageInfo { + VkStructureType sType; + const void* pNext; + VkImageCreateFlags flags; + VkImageUsageFlags usage; + uint32_t width; + uint32_t height; + uint32_t layerCount; + uint32_t viewFormatCount; + const VkFormat* pViewFormats; +} VkFramebufferAttachmentImageInfo; + +typedef struct VkFramebufferAttachmentsCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentImageInfoCount; + const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; +} VkFramebufferAttachmentsCreateInfo; + +typedef struct VkRenderPassAttachmentBeginInfo { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkImageView* pAttachments; +} VkRenderPassAttachmentBeginInfo; + +typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { + VkStructureType sType; + void* pNext; + VkBool32 uniformBufferStandardLayout; +} VkPhysicalDeviceUniformBufferStandardLayoutFeatures; + +typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupExtendedTypes; +} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; + +typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { + VkStructureType sType; + void* pNext; + VkBool32 separateDepthStencilLayouts; +} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; + +typedef struct VkAttachmentReferenceStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilLayout; +} VkAttachmentReferenceStencilLayout; + +typedef struct VkAttachmentDescriptionStencilLayout { + VkStructureType sType; + void* pNext; + VkImageLayout stencilInitialLayout; + VkImageLayout stencilFinalLayout; +} VkAttachmentDescriptionStencilLayout; + +typedef struct VkPhysicalDeviceHostQueryResetFeatures { + VkStructureType sType; + void* pNext; + VkBool32 hostQueryReset; +} VkPhysicalDeviceHostQueryResetFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { + VkStructureType sType; + void* pNext; + VkBool32 timelineSemaphore; +} VkPhysicalDeviceTimelineSemaphoreFeatures; + +typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { + VkStructureType sType; + void* pNext; + uint64_t maxTimelineSemaphoreValueDifference; +} VkPhysicalDeviceTimelineSemaphoreProperties; + +typedef struct VkSemaphoreTypeCreateInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreType semaphoreType; + uint64_t initialValue; +} VkSemaphoreTypeCreateInfo; + +typedef struct VkTimelineSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreValueCount; + const uint64_t* pWaitSemaphoreValues; + uint32_t signalSemaphoreValueCount; + const uint64_t* pSignalSemaphoreValues; +} VkTimelineSemaphoreSubmitInfo; + +typedef struct VkSemaphoreWaitInfo { + VkStructureType sType; + const void* pNext; + VkSemaphoreWaitFlags flags; + uint32_t semaphoreCount; + const VkSemaphore* pSemaphores; + const uint64_t* pValues; +} VkSemaphoreWaitInfo; + +typedef struct VkSemaphoreSignalInfo { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; +} VkSemaphoreSignalInfo; + +typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeatures; + +typedef struct VkBufferDeviceAddressInfo { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferDeviceAddressInfo; + +typedef struct VkBufferOpaqueCaptureAddressCreateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkBufferOpaqueCaptureAddressCreateInfo; + +typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { + VkStructureType sType; + const void* pNext; + uint64_t opaqueCaptureAddress; +} VkMemoryOpaqueCaptureAddressAllocateInfo; + +typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; +} VkDeviceMemoryOpaqueCaptureAddressInfo; + +typedef void ( *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void ( *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef VkResult ( *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void ( *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void ( *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void ( *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void ( *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +typedef VkResult ( *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +typedef VkResult ( *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +typedef VkResult ( *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); +typedef VkDeviceAddress ( *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t ( *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t ( *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +# 6558 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef uint64_t VkFlags64; +typedef struct VkPrivateDataSlot_T *VkPrivateDataSlot; + +typedef enum VkPipelineCreationFeedbackFlagBits { + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004, + VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, + VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, + VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, + VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkPipelineCreationFeedbackFlagBits; +typedef VkFlags VkPipelineCreationFeedbackFlags; + +typedef enum VkToolPurposeFlagBits { + VK_TOOL_PURPOSE_VALIDATION_BIT = 0x00000001, + VK_TOOL_PURPOSE_PROFILING_BIT = 0x00000002, + VK_TOOL_PURPOSE_TRACING_BIT = 0x00000004, + VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 0x00000008, + VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 0x00000010, + VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020, + VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040, + VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = VK_TOOL_PURPOSE_VALIDATION_BIT, + VK_TOOL_PURPOSE_PROFILING_BIT_EXT = VK_TOOL_PURPOSE_PROFILING_BIT, + VK_TOOL_PURPOSE_TRACING_BIT_EXT = VK_TOOL_PURPOSE_TRACING_BIT, + VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, + VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, + VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkToolPurposeFlagBits; +typedef VkFlags VkToolPurposeFlags; +typedef VkFlags VkPrivateDataSlotCreateFlags; +typedef VkFlags64 VkPipelineStageFlags2; + + +typedef VkFlags64 VkPipelineStageFlagBits2; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE = 0ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 0x00000001ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 0x00000002ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 0x00000004ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 0x00000008ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 0x00000040ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 0x00000080ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 0x00000100ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 0x00000200ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 0x00000800ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 0x00002000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT = 0x00004000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 0x00008000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0x00010000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT = 0x100000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0x200000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT = 0x400000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT = 0x800000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 0x1000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 0x2000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL; + + + +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0x00080000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 0x00100000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI = 0x8000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0x10000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0x40000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ULL; +static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ULL; + +typedef VkFlags64 VkAccessFlags2; + + +typedef VkFlags64 VkAccessFlagBits2; +static const VkAccessFlagBits2 VK_ACCESS_2_NONE = 0ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 0x00000001ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT = 0x00000002ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT = 0x00000008ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 0x00000010ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT = 0x00000020ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT = 0x00000040ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 0x00000080ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT = 0x00000800ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT = 0x00001000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT = 0x00002000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT = 0x00004000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT = 0x00008000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 0x00010000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 0x100000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0x200000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x400000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL; + + + + + + +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0x20000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0x10000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0x200000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000000ULL; +static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ULL; + + +typedef enum VkSubmitFlagBits { + VK_SUBMIT_PROTECTED_BIT = 0x00000001, + VK_SUBMIT_PROTECTED_BIT_KHR = VK_SUBMIT_PROTECTED_BIT, + VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkSubmitFlagBits; +typedef VkFlags VkSubmitFlags; + +typedef enum VkRenderingFlagBits { + VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001, + VK_RENDERING_SUSPENDING_BIT = 0x00000002, + VK_RENDERING_RESUMING_BIT = 0x00000004, + VK_RENDERING_CONTENTS_INLINE_BIT_EXT = 0x00000010, + VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008, + VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, + VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT, + VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT, + VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF +} VkRenderingFlagBits; +typedef VkFlags VkRenderingFlags; +typedef VkFlags64 VkFormatFeatureFlags2; + + +typedef VkFlags64 VkFormatFeatureFlagBits2; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0x00000001ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0x00000002ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000010ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0x00000040ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0x00000080ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0x00000400ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0x00000800ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0x00002000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0x00004000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0x00008000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0x00400000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0x00800000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0x80000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0x100000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0x200000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ULL; + + + + + + +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0x1000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0x2000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ULL; +static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ULL; + +typedef struct VkPhysicalDeviceVulkan13Features { + VkStructureType sType; + void* pNext; + VkBool32 robustImageAccess; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; + VkBool32 pipelineCreationCacheControl; + VkBool32 privateData; + VkBool32 shaderDemoteToHelperInvocation; + VkBool32 shaderTerminateInvocation; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; + VkBool32 synchronization2; + VkBool32 textureCompressionASTC_HDR; + VkBool32 shaderZeroInitializeWorkgroupMemory; + VkBool32 dynamicRendering; + VkBool32 shaderIntegerDotProduct; + VkBool32 maintenance4; +} VkPhysicalDeviceVulkan13Features; + +typedef struct VkPhysicalDeviceVulkan13Properties { + VkStructureType sType; + void* pNext; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; + uint32_t maxInlineUniformTotalSize; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize maxBufferSize; +} VkPhysicalDeviceVulkan13Properties; + +typedef struct VkPipelineCreationFeedback { + VkPipelineCreationFeedbackFlags flags; + uint64_t duration; +} VkPipelineCreationFeedback; + +typedef struct VkPipelineCreationFeedbackCreateInfo { + VkStructureType sType; + const void* pNext; + VkPipelineCreationFeedback* pPipelineCreationFeedback; + uint32_t pipelineStageCreationFeedbackCount; + VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks; +} VkPipelineCreationFeedbackCreateInfo; + +typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderTerminateInvocation; +} VkPhysicalDeviceShaderTerminateInvocationFeatures; + +typedef struct VkPhysicalDeviceToolProperties { + VkStructureType sType; + void* pNext; + char name[256U]; + char version[256U]; + VkToolPurposeFlags purposes; + char description[256U]; + char layer[256U]; +} VkPhysicalDeviceToolProperties; + +typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderDemoteToHelperInvocation; +} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; + +typedef struct VkPhysicalDevicePrivateDataFeatures { + VkStructureType sType; + void* pNext; + VkBool32 privateData; +} VkPhysicalDevicePrivateDataFeatures; + +typedef struct VkDevicePrivateDataCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t privateDataSlotRequestCount; +} VkDevicePrivateDataCreateInfo; + +typedef struct VkPrivateDataSlotCreateInfo { + VkStructureType sType; + const void* pNext; + VkPrivateDataSlotCreateFlags flags; +} VkPrivateDataSlotCreateInfo; + +typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures { + VkStructureType sType; + void* pNext; + VkBool32 pipelineCreationCacheControl; +} VkPhysicalDevicePipelineCreationCacheControlFeatures; + +typedef struct VkMemoryBarrier2 { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; +} VkMemoryBarrier2; + +typedef struct VkBufferMemoryBarrier2 { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; +} VkBufferMemoryBarrier2; + +typedef struct VkImageMemoryBarrier2 { + VkStructureType sType; + const void* pNext; + VkPipelineStageFlags2 srcStageMask; + VkAccessFlags2 srcAccessMask; + VkPipelineStageFlags2 dstStageMask; + VkAccessFlags2 dstAccessMask; + VkImageLayout oldLayout; + VkImageLayout newLayout; + uint32_t srcQueueFamilyIndex; + uint32_t dstQueueFamilyIndex; + VkImage image; + VkImageSubresourceRange subresourceRange; +} VkImageMemoryBarrier2; + +typedef struct VkDependencyInfo { + VkStructureType sType; + const void* pNext; + VkDependencyFlags dependencyFlags; + uint32_t memoryBarrierCount; + const VkMemoryBarrier2* pMemoryBarriers; + uint32_t bufferMemoryBarrierCount; + const VkBufferMemoryBarrier2* pBufferMemoryBarriers; + uint32_t imageMemoryBarrierCount; + const VkImageMemoryBarrier2* pImageMemoryBarriers; +} VkDependencyInfo; + +typedef struct VkSemaphoreSubmitInfo { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + uint64_t value; + VkPipelineStageFlags2 stageMask; + uint32_t deviceIndex; +} VkSemaphoreSubmitInfo; + +typedef struct VkCommandBufferSubmitInfo { + VkStructureType sType; + const void* pNext; + VkCommandBuffer commandBuffer; + uint32_t deviceMask; +} VkCommandBufferSubmitInfo; + +typedef struct VkSubmitInfo2 { + VkStructureType sType; + const void* pNext; + VkSubmitFlags flags; + uint32_t waitSemaphoreInfoCount; + const VkSemaphoreSubmitInfo* pWaitSemaphoreInfos; + uint32_t commandBufferInfoCount; + const VkCommandBufferSubmitInfo* pCommandBufferInfos; + uint32_t signalSemaphoreInfoCount; + const VkSemaphoreSubmitInfo* pSignalSemaphoreInfos; +} VkSubmitInfo2; + +typedef struct VkPhysicalDeviceSynchronization2Features { + VkStructureType sType; + void* pNext; + VkBool32 synchronization2; +} VkPhysicalDeviceSynchronization2Features; + +typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderZeroInitializeWorkgroupMemory; +} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; + +typedef struct VkPhysicalDeviceImageRobustnessFeatures { + VkStructureType sType; + void* pNext; + VkBool32 robustImageAccess; +} VkPhysicalDeviceImageRobustnessFeatures; + +typedef struct VkBufferCopy2 { + VkStructureType sType; + const void* pNext; + VkDeviceSize srcOffset; + VkDeviceSize dstOffset; + VkDeviceSize size; +} VkBufferCopy2; + +typedef struct VkCopyBufferInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer srcBuffer; + VkBuffer dstBuffer; + uint32_t regionCount; + const VkBufferCopy2* pRegions; +} VkCopyBufferInfo2; + +typedef struct VkImageCopy2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageCopy2; + +typedef struct VkCopyImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageCopy2* pRegions; +} VkCopyImageInfo2; + +typedef struct VkBufferImageCopy2 { + VkStructureType sType; + const void* pNext; + VkDeviceSize bufferOffset; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkBufferImageCopy2; + +typedef struct VkCopyBufferToImageInfo2 { + VkStructureType sType; + const void* pNext; + VkBuffer srcBuffer; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkBufferImageCopy2* pRegions; +} VkCopyBufferToImageInfo2; + +typedef struct VkCopyImageToBufferInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkBuffer dstBuffer; + uint32_t regionCount; + const VkBufferImageCopy2* pRegions; +} VkCopyImageToBufferInfo2; + +typedef struct VkImageBlit2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffsets[2]; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffsets[2]; +} VkImageBlit2; + +typedef struct VkBlitImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageBlit2* pRegions; + VkFilter filter; +} VkBlitImageInfo2; + +typedef struct VkImageResolve2 { + VkStructureType sType; + const void* pNext; + VkImageSubresourceLayers srcSubresource; + VkOffset3D srcOffset; + VkImageSubresourceLayers dstSubresource; + VkOffset3D dstOffset; + VkExtent3D extent; +} VkImageResolve2; + +typedef struct VkResolveImageInfo2 { + VkStructureType sType; + const void* pNext; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageResolve2* pRegions; +} VkResolveImageInfo2; + +typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures { + VkStructureType sType; + void* pNext; + VkBool32 subgroupSizeControl; + VkBool32 computeFullSubgroups; +} VkPhysicalDeviceSubgroupSizeControlFeatures; + +typedef struct VkPhysicalDeviceSubgroupSizeControlProperties { + VkStructureType sType; + void* pNext; + uint32_t minSubgroupSize; + uint32_t maxSubgroupSize; + uint32_t maxComputeWorkgroupSubgroups; + VkShaderStageFlags requiredSubgroupSizeStages; +} VkPhysicalDeviceSubgroupSizeControlProperties; + +typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo { + VkStructureType sType; + void* pNext; + uint32_t requiredSubgroupSize; +} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; + +typedef struct VkPhysicalDeviceInlineUniformBlockFeatures { + VkStructureType sType; + void* pNext; + VkBool32 inlineUniformBlock; + VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; +} VkPhysicalDeviceInlineUniformBlockFeatures; + +typedef struct VkPhysicalDeviceInlineUniformBlockProperties { + VkStructureType sType; + void* pNext; + uint32_t maxInlineUniformBlockSize; + uint32_t maxPerStageDescriptorInlineUniformBlocks; + uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; + uint32_t maxDescriptorSetInlineUniformBlocks; + uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; +} VkPhysicalDeviceInlineUniformBlockProperties; + +typedef struct VkWriteDescriptorSetInlineUniformBlock { + VkStructureType sType; + const void* pNext; + uint32_t dataSize; + const void* pData; +} VkWriteDescriptorSetInlineUniformBlock; + +typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t maxInlineUniformBlockBindings; +} VkDescriptorPoolInlineUniformBlockCreateInfo; + +typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures { + VkStructureType sType; + void* pNext; + VkBool32 textureCompressionASTC_HDR; +} VkPhysicalDeviceTextureCompressionASTCHDRFeatures; + +typedef struct VkRenderingAttachmentInfo { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkImageLayout imageLayout; + VkResolveModeFlagBits resolveMode; + VkImageView resolveImageView; + VkImageLayout resolveImageLayout; + VkAttachmentLoadOp loadOp; + VkAttachmentStoreOp storeOp; + VkClearValue clearValue; +} VkRenderingAttachmentInfo; + +typedef struct VkRenderingInfo { + VkStructureType sType; + const void* pNext; + VkRenderingFlags flags; + VkRect2D renderArea; + uint32_t layerCount; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkRenderingAttachmentInfo* pColorAttachments; + const VkRenderingAttachmentInfo* pDepthAttachment; + const VkRenderingAttachmentInfo* pStencilAttachment; +} VkRenderingInfo; + +typedef struct VkPipelineRenderingCreateInfo { + VkStructureType sType; + const void* pNext; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} VkPipelineRenderingCreateInfo; + +typedef struct VkPhysicalDeviceDynamicRenderingFeatures { + VkStructureType sType; + void* pNext; + VkBool32 dynamicRendering; +} VkPhysicalDeviceDynamicRenderingFeatures; + +typedef struct VkCommandBufferInheritanceRenderingInfo { + VkStructureType sType; + const void* pNext; + VkRenderingFlags flags; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; + VkSampleCountFlagBits rasterizationSamples; +} VkCommandBufferInheritanceRenderingInfo; + +typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures { + VkStructureType sType; + void* pNext; + VkBool32 shaderIntegerDotProduct; +} VkPhysicalDeviceShaderIntegerDotProductFeatures; + +typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties { + VkStructureType sType; + void* pNext; + VkBool32 integerDotProduct8BitUnsignedAccelerated; + VkBool32 integerDotProduct8BitSignedAccelerated; + VkBool32 integerDotProduct8BitMixedSignednessAccelerated; + VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; + VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProduct16BitUnsignedAccelerated; + VkBool32 integerDotProduct16BitSignedAccelerated; + VkBool32 integerDotProduct16BitMixedSignednessAccelerated; + VkBool32 integerDotProduct32BitUnsignedAccelerated; + VkBool32 integerDotProduct32BitSignedAccelerated; + VkBool32 integerDotProduct32BitMixedSignednessAccelerated; + VkBool32 integerDotProduct64BitUnsignedAccelerated; + VkBool32 integerDotProduct64BitSignedAccelerated; + VkBool32 integerDotProduct64BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; + VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; +} VkPhysicalDeviceShaderIntegerDotProductProperties; + +typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties { + VkStructureType sType; + void* pNext; + VkDeviceSize storageTexelBufferOffsetAlignmentBytes; + VkBool32 storageTexelBufferOffsetSingleTexelAlignment; + VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; + VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; +} VkPhysicalDeviceTexelBufferAlignmentProperties; + +typedef struct VkFormatProperties3 { + VkStructureType sType; + void* pNext; + VkFormatFeatureFlags2 linearTilingFeatures; + VkFormatFeatureFlags2 optimalTilingFeatures; + VkFormatFeatureFlags2 bufferFeatures; +} VkFormatProperties3; + +typedef struct VkPhysicalDeviceMaintenance4Features { + VkStructureType sType; + void* pNext; + VkBool32 maintenance4; +} VkPhysicalDeviceMaintenance4Features; + +typedef struct VkPhysicalDeviceMaintenance4Properties { + VkStructureType sType; + void* pNext; + VkDeviceSize maxBufferSize; +} VkPhysicalDeviceMaintenance4Properties; + +typedef struct VkDeviceBufferMemoryRequirements { + VkStructureType sType; + const void* pNext; + const VkBufferCreateInfo* pCreateInfo; +} VkDeviceBufferMemoryRequirements; + +typedef struct VkDeviceImageMemoryRequirements { + VkStructureType sType; + const void* pNext; + const VkImageCreateInfo* pCreateInfo; + VkImageAspectFlagBits planeAspect; +} VkDeviceImageMemoryRequirements; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +typedef VkResult ( *PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +typedef void ( *PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +typedef void ( *PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +typedef void ( *PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +typedef void ( *PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +typedef void ( *PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +typedef void ( *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +typedef void ( *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +typedef VkResult ( *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +typedef void ( *PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +typedef void ( *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +typedef void ( *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +typedef void ( *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +typedef void ( *PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +typedef void ( *PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +typedef void ( *PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +typedef void ( *PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer); +typedef void ( *PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void ( *PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void ( *PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void ( *PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void ( *PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void ( *PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +typedef void ( *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void ( *PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void ( *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void ( *PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void ( *PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void ( *PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +typedef void ( *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void ( *PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void ( *PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +typedef void ( *PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +# 7600 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkSurfaceKHR_T *VkSurfaceKHR; + + + +typedef enum VkPresentModeKHR { + VK_PRESENT_MODE_IMMEDIATE_KHR = 0, + VK_PRESENT_MODE_MAILBOX_KHR = 1, + VK_PRESENT_MODE_FIFO_KHR = 2, + VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, + VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, + VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, + VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPresentModeKHR; + +typedef enum VkColorSpaceKHR { + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, + VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, + VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, + VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, + VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, + VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, + VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, + VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, + VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, + VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, + VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, + VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, + VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, + VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, + VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, + VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000, + VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, + VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, + VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkColorSpaceKHR; + +typedef enum VkSurfaceTransformFlagBitsKHR { + VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, + VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSurfaceTransformFlagBitsKHR; + +typedef enum VkCompositeAlphaFlagBitsKHR { + VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, + VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkCompositeAlphaFlagBitsKHR; +typedef VkFlags VkCompositeAlphaFlagsKHR; +typedef VkFlags VkSurfaceTransformFlagsKHR; +typedef struct VkSurfaceCapabilitiesKHR { + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; +} VkSurfaceCapabilitiesKHR; + +typedef struct VkSurfaceFormatKHR { + VkFormat format; + VkColorSpaceKHR colorSpace; +} VkSurfaceFormatKHR; + +typedef void ( *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); +typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); +typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); +typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); +# 7715 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkSwapchainKHR_T *VkSwapchainKHR; + + + +typedef enum VkSwapchainCreateFlagBitsKHR { + VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, + VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, + VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, + VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = 0x00000008, + VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkSwapchainCreateFlagBitsKHR; +typedef VkFlags VkSwapchainCreateFlagsKHR; + +typedef enum VkDeviceGroupPresentModeFlagBitsKHR { + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, + VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, + VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, + VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, + VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDeviceGroupPresentModeFlagBitsKHR; +typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; +typedef struct VkSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainCreateFlagsKHR flags; + VkSurfaceKHR surface; + uint32_t minImageCount; + VkFormat imageFormat; + VkColorSpaceKHR imageColorSpace; + VkExtent2D imageExtent; + uint32_t imageArrayLayers; + VkImageUsageFlags imageUsage; + VkSharingMode imageSharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; + VkSurfaceTransformFlagBitsKHR preTransform; + VkCompositeAlphaFlagBitsKHR compositeAlpha; + VkPresentModeKHR presentMode; + VkBool32 clipped; + VkSwapchainKHR oldSwapchain; +} VkSwapchainCreateInfoKHR; + +typedef struct VkPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t waitSemaphoreCount; + const VkSemaphore* pWaitSemaphores; + uint32_t swapchainCount; + const VkSwapchainKHR* pSwapchains; + const uint32_t* pImageIndices; + VkResult* pResults; +} VkPresentInfoKHR; + +typedef struct VkImageSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; +} VkImageSwapchainCreateInfoKHR; + +typedef struct VkBindImageMemorySwapchainInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndex; +} VkBindImageMemorySwapchainInfoKHR; + +typedef struct VkAcquireNextImageInfoKHR { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint64_t timeout; + VkSemaphore semaphore; + VkFence fence; + uint32_t deviceMask; +} VkAcquireNextImageInfoKHR; + +typedef struct VkDeviceGroupPresentCapabilitiesKHR { + VkStructureType sType; + void* pNext; + uint32_t presentMask[32U]; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupPresentCapabilitiesKHR; + +typedef struct VkDeviceGroupPresentInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint32_t* pDeviceMasks; + VkDeviceGroupPresentModeFlagBitsKHR mode; +} VkDeviceGroupPresentInfoKHR; + +typedef struct VkDeviceGroupSwapchainCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceGroupPresentModeFlagsKHR modes; +} VkDeviceGroupSwapchainCreateInfoKHR; + +typedef VkResult ( *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); +typedef void ( *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); +typedef VkResult ( *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); +typedef VkResult ( *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); +typedef VkResult ( *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); +typedef VkResult ( *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); +typedef VkResult ( *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); +typedef VkResult ( *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); +# 7876 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkDisplayKHR_T *VkDisplayKHR; +typedef struct VkDisplayModeKHR_T *VkDisplayModeKHR; + + +typedef VkFlags VkDisplayModeCreateFlagsKHR; + +typedef enum VkDisplayPlaneAlphaFlagBitsKHR { + VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, + VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, + VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, + VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkDisplayPlaneAlphaFlagBitsKHR; +typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; +typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; +typedef struct VkDisplayModeParametersKHR { + VkExtent2D visibleRegion; + uint32_t refreshRate; +} VkDisplayModeParametersKHR; + +typedef struct VkDisplayModeCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeCreateFlagsKHR flags; + VkDisplayModeParametersKHR parameters; +} VkDisplayModeCreateInfoKHR; + +typedef struct VkDisplayModePropertiesKHR { + VkDisplayModeKHR displayMode; + VkDisplayModeParametersKHR parameters; +} VkDisplayModePropertiesKHR; + +typedef struct VkDisplayPlaneCapabilitiesKHR { + VkDisplayPlaneAlphaFlagsKHR supportedAlpha; + VkOffset2D minSrcPosition; + VkOffset2D maxSrcPosition; + VkExtent2D minSrcExtent; + VkExtent2D maxSrcExtent; + VkOffset2D minDstPosition; + VkOffset2D maxDstPosition; + VkExtent2D minDstExtent; + VkExtent2D maxDstExtent; +} VkDisplayPlaneCapabilitiesKHR; + +typedef struct VkDisplayPlanePropertiesKHR { + VkDisplayKHR currentDisplay; + uint32_t currentStackIndex; +} VkDisplayPlanePropertiesKHR; + +typedef struct VkDisplayPropertiesKHR { + VkDisplayKHR display; + const char* displayName; + VkExtent2D physicalDimensions; + VkExtent2D physicalResolution; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkBool32 planeReorderPossible; + VkBool32 persistentContent; +} VkDisplayPropertiesKHR; + +typedef struct VkDisplaySurfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkDisplaySurfaceCreateFlagsKHR flags; + VkDisplayModeKHR displayMode; + uint32_t planeIndex; + uint32_t planeStackIndex; + VkSurfaceTransformFlagBitsKHR transform; + float globalAlpha; + VkDisplayPlaneAlphaFlagBitsKHR alphaMode; + VkExtent2D imageExtent; +} VkDisplaySurfaceCreateInfoKHR; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); +typedef VkResult ( *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); +typedef VkResult ( *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); +typedef VkResult ( *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); +typedef VkResult ( *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); +typedef VkResult ( *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); +typedef VkResult ( *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +# 8004 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkDisplayPresentInfoKHR { + VkStructureType sType; + const void* pNext; + VkRect2D srcRect; + VkRect2D dstRect; + VkBool32 persistent; +} VkDisplayPresentInfoKHR; + +typedef VkResult ( *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); +# 8032 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkVideoSessionKHR_T *VkVideoSessionKHR; +typedef struct VkVideoSessionParametersKHR_T *VkVideoSessionParametersKHR; + + + +typedef enum VkQueryResultStatusKHR { + VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, + VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, + VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, + VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR = -1000299000, + VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkQueryResultStatusKHR; + +typedef enum VkVideoCodecOperationFlagBitsKHR { + VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0, + + + + + + + VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, + VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, + VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodecOperationFlagBitsKHR; +typedef VkFlags VkVideoCodecOperationFlagsKHR; + +typedef enum VkVideoChromaSubsamplingFlagBitsKHR { + VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR = 0, + VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, + VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, + VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, + VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, + VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoChromaSubsamplingFlagBitsKHR; +typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; + +typedef enum VkVideoComponentBitDepthFlagBitsKHR { + VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, + VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, + VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, + VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, + VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoComponentBitDepthFlagBitsKHR; +typedef VkFlags VkVideoComponentBitDepthFlagsKHR; + +typedef enum VkVideoCapabilityFlagBitsKHR { + VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, + VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCapabilityFlagBitsKHR; +typedef VkFlags VkVideoCapabilityFlagsKHR; + +typedef enum VkVideoSessionCreateFlagBitsKHR { + VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, + + + + VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoSessionCreateFlagBitsKHR; +typedef VkFlags VkVideoSessionCreateFlagsKHR; +typedef VkFlags VkVideoSessionParametersCreateFlagsKHR; +typedef VkFlags VkVideoBeginCodingFlagsKHR; +typedef VkFlags VkVideoEndCodingFlagsKHR; + +typedef enum VkVideoCodingControlFlagBitsKHR { + VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, + + + + + + + VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoCodingControlFlagBitsKHR; +typedef VkFlags VkVideoCodingControlFlagsKHR; +typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 queryResultStatusSupport; +} VkQueueFamilyQueryResultStatusPropertiesKHR; + +typedef struct VkQueueFamilyVideoPropertiesKHR { + VkStructureType sType; + void* pNext; + VkVideoCodecOperationFlagsKHR videoCodecOperations; +} VkQueueFamilyVideoPropertiesKHR; + +typedef struct VkVideoProfileInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoCodecOperationFlagBitsKHR videoCodecOperation; + VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; + VkVideoComponentBitDepthFlagsKHR lumaBitDepth; + VkVideoComponentBitDepthFlagsKHR chromaBitDepth; +} VkVideoProfileInfoKHR; + +typedef struct VkVideoProfileListInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t profileCount; + const VkVideoProfileInfoKHR* pProfiles; +} VkVideoProfileListInfoKHR; + +typedef struct VkVideoCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoCapabilityFlagsKHR flags; + VkDeviceSize minBitstreamBufferOffsetAlignment; + VkDeviceSize minBitstreamBufferSizeAlignment; + VkExtent2D pictureAccessGranularity; + VkExtent2D minCodedExtent; + VkExtent2D maxCodedExtent; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + VkExtensionProperties stdHeaderVersion; +} VkVideoCapabilitiesKHR; + +typedef struct VkPhysicalDeviceVideoFormatInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageUsageFlags imageUsage; +} VkPhysicalDeviceVideoFormatInfoKHR; + +typedef struct VkVideoFormatPropertiesKHR { + VkStructureType sType; + void* pNext; + VkFormat format; + VkComponentMapping componentMapping; + VkImageCreateFlags imageCreateFlags; + VkImageType imageType; + VkImageTiling imageTiling; + VkImageUsageFlags imageUsageFlags; +} VkVideoFormatPropertiesKHR; + +typedef struct VkVideoPictureResourceInfoKHR { + VkStructureType sType; + const void* pNext; + VkOffset2D codedOffset; + VkExtent2D codedExtent; + uint32_t baseArrayLayer; + VkImageView imageViewBinding; +} VkVideoPictureResourceInfoKHR; + +typedef struct VkVideoReferenceSlotInfoKHR { + VkStructureType sType; + const void* pNext; + int32_t slotIndex; + const VkVideoPictureResourceInfoKHR* pPictureResource; +} VkVideoReferenceSlotInfoKHR; + +typedef struct VkVideoSessionMemoryRequirementsKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryBindIndex; + VkMemoryRequirements memoryRequirements; +} VkVideoSessionMemoryRequirementsKHR; + +typedef struct VkBindVideoSessionMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t memoryBindIndex; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + VkDeviceSize memorySize; +} VkBindVideoSessionMemoryInfoKHR; + +typedef struct VkVideoSessionCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + VkVideoSessionCreateFlagsKHR flags; + const VkVideoProfileInfoKHR* pVideoProfile; + VkFormat pictureFormat; + VkExtent2D maxCodedExtent; + VkFormat referencePictureFormat; + uint32_t maxDpbSlots; + uint32_t maxActiveReferencePictures; + const VkExtensionProperties* pStdHeaderVersion; +} VkVideoSessionCreateInfoKHR; + +typedef struct VkVideoSessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoSessionParametersCreateFlagsKHR flags; + VkVideoSessionParametersKHR videoSessionParametersTemplate; + VkVideoSessionKHR videoSession; +} VkVideoSessionParametersCreateInfoKHR; + +typedef struct VkVideoSessionParametersUpdateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t updateSequenceCount; +} VkVideoSessionParametersUpdateInfoKHR; + +typedef struct VkVideoBeginCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoBeginCodingFlagsKHR flags; + VkVideoSessionKHR videoSession; + VkVideoSessionParametersKHR videoSessionParameters; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; +} VkVideoBeginCodingInfoKHR; + +typedef struct VkVideoEndCodingInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoEndCodingFlagsKHR flags; +} VkVideoEndCodingInfoKHR; + +typedef struct VkVideoCodingControlInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoCodingControlFlagsKHR flags; +} VkVideoCodingControlInfoKHR; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); +typedef VkResult ( *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); +typedef VkResult ( *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); +typedef void ( *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); +typedef VkResult ( *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); +typedef VkResult ( *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); +typedef VkResult ( *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); +typedef void ( *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); +typedef void ( *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); +typedef void ( *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); +# 8332 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkVideoDecodeCapabilityFlagBitsKHR { + VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeCapabilityFlagBitsKHR; +typedef VkFlags VkVideoDecodeCapabilityFlagsKHR; + +typedef enum VkVideoDecodeUsageFlagBitsKHR { + VK_VIDEO_DECODE_USAGE_DEFAULT_KHR = 0, + VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0x00000004, + VK_VIDEO_DECODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeUsageFlagBitsKHR; +typedef VkFlags VkVideoDecodeUsageFlagsKHR; +typedef VkFlags VkVideoDecodeFlagsKHR; +typedef struct VkVideoDecodeCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkVideoDecodeCapabilityFlagsKHR flags; +} VkVideoDecodeCapabilitiesKHR; + +typedef struct VkVideoDecodeUsageInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoDecodeUsageFlagsKHR videoUsageHints; +} VkVideoDecodeUsageInfoKHR; + +typedef struct VkVideoDecodeInfoKHR { + VkStructureType sType; + const void* pNext; + VkVideoDecodeFlagsKHR flags; + VkBuffer srcBuffer; + VkDeviceSize srcBufferOffset; + VkDeviceSize srcBufferRange; + VkVideoPictureResourceInfoKHR dstPictureResource; + const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; + uint32_t referenceSlotCount; + const VkVideoReferenceSlotInfoKHR* pReferenceSlots; +} VkVideoDecodeInfoKHR; + +typedef void ( *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); +# 8384 "/usr/include/vulkan/vulkan_core.h" 3 4 +# 1 "/usr/include/vk_video/vulkan_video_codec_h264std.h" 1 3 4 +# 17 "/usr/include/vk_video/vulkan_video_codec_h264std.h" 3 4 +extern "C" { + + + + + + +# 1 "/usr/include/vk_video/vulkan_video_codecs_common.h" 1 3 4 +# 17 "/usr/include/vk_video/vulkan_video_codecs_common.h" 3 4 +extern "C" { +# 33 "/usr/include/vk_video/vulkan_video_codecs_common.h" 3 4 +} +# 25 "/usr/include/vk_video/vulkan_video_codec_h264std.h" 2 3 4 +# 34 "/usr/include/vk_video/vulkan_video_codec_h264std.h" 3 4 +typedef enum StdVideoH264ChromaFormatIdc { + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ChromaFormatIdc; + +typedef enum StdVideoH264ProfileIdc { + STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, + STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, + STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, + STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, + STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ProfileIdc; + +typedef enum StdVideoH264LevelIdc { + STD_VIDEO_H264_LEVEL_IDC_1_0 = 0, + STD_VIDEO_H264_LEVEL_IDC_1_1 = 1, + STD_VIDEO_H264_LEVEL_IDC_1_2 = 2, + STD_VIDEO_H264_LEVEL_IDC_1_3 = 3, + STD_VIDEO_H264_LEVEL_IDC_2_0 = 4, + STD_VIDEO_H264_LEVEL_IDC_2_1 = 5, + STD_VIDEO_H264_LEVEL_IDC_2_2 = 6, + STD_VIDEO_H264_LEVEL_IDC_3_0 = 7, + STD_VIDEO_H264_LEVEL_IDC_3_1 = 8, + STD_VIDEO_H264_LEVEL_IDC_3_2 = 9, + STD_VIDEO_H264_LEVEL_IDC_4_0 = 10, + STD_VIDEO_H264_LEVEL_IDC_4_1 = 11, + STD_VIDEO_H264_LEVEL_IDC_4_2 = 12, + STD_VIDEO_H264_LEVEL_IDC_5_0 = 13, + STD_VIDEO_H264_LEVEL_IDC_5_1 = 14, + STD_VIDEO_H264_LEVEL_IDC_5_2 = 15, + STD_VIDEO_H264_LEVEL_IDC_6_0 = 16, + STD_VIDEO_H264_LEVEL_IDC_6_1 = 17, + STD_VIDEO_H264_LEVEL_IDC_6_2 = 18, + STD_VIDEO_H264_LEVEL_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264LevelIdc; + +typedef enum StdVideoH264PocType { + STD_VIDEO_H264_POC_TYPE_0 = 0, + STD_VIDEO_H264_POC_TYPE_1 = 1, + STD_VIDEO_H264_POC_TYPE_2 = 2, + STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_POC_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264PocType; + +typedef enum StdVideoH264AspectRatioIdc { + STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE = 1, + STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11 = 2, + STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11 = 3, + STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11 = 4, + STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33 = 5, + STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11 = 6, + STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11 = 7, + STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11 = 8, + STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33 = 9, + STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11 = 10, + STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11 = 11, + STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33 = 12, + STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99 = 13, + STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3 = 14, + STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15, + STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16, + STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264AspectRatioIdc; + +typedef enum StdVideoH264WeightedBipredIdc { + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264WeightedBipredIdc; + +typedef enum StdVideoH264ModificationOfPicNumsIdc { + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT = 0, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264ModificationOfPicNumsIdc; + +typedef enum StdVideoH264MemMgmtControlOp { + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END = 0, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM = 1, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM = 2, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM = 3, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264MemMgmtControlOp; + +typedef enum StdVideoH264CabacInitIdc { + STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0, + STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1, + STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2, + STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_CABAC_INIT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264CabacInitIdc; + +typedef enum StdVideoH264DisableDeblockingFilterIdc { + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264DisableDeblockingFilterIdc; + +typedef enum StdVideoH264SliceType { + STD_VIDEO_H264_SLICE_TYPE_P = 0, + STD_VIDEO_H264_SLICE_TYPE_B = 1, + STD_VIDEO_H264_SLICE_TYPE_I = 2, + STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264SliceType; + +typedef enum StdVideoH264PictureType { + STD_VIDEO_H264_PICTURE_TYPE_P = 0, + STD_VIDEO_H264_PICTURE_TYPE_B = 1, + STD_VIDEO_H264_PICTURE_TYPE_I = 2, + STD_VIDEO_H264_PICTURE_TYPE_IDR = 5, + STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264PictureType; + +typedef enum StdVideoH264NonVclNaluType { + STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS = 0, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS = 1, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD = 2, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX = 3, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H264_NON_VCL_NALU_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH264NonVclNaluType; +typedef struct StdVideoH264SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t color_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t timing_info_present_flag : 1; + uint32_t fixed_frame_rate_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; +} StdVideoH264SpsVuiFlags; + +typedef struct StdVideoH264HrdParameters { + uint8_t cpb_cnt_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t reserved1; + uint32_t bit_rate_value_minus1[32]; + uint32_t cpb_size_value_minus1[32]; + uint8_t cbr_flag[32]; + uint32_t initial_cpb_removal_delay_length_minus1; + uint32_t cpb_removal_delay_length_minus1; + uint32_t dpb_output_delay_length_minus1; + uint32_t time_offset_length; +} StdVideoH264HrdParameters; + +typedef struct StdVideoH264SequenceParameterSetVui { + StdVideoH264SpsVuiFlags flags; + StdVideoH264AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coefficients; + uint32_t num_units_in_tick; + uint32_t time_scale; + uint8_t max_num_reorder_frames; + uint8_t max_dec_frame_buffering; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint32_t reserved1; + const StdVideoH264HrdParameters* pHrdParameters; +} StdVideoH264SequenceParameterSetVui; + +typedef struct StdVideoH264SpsFlags { + uint32_t constraint_set0_flag : 1; + uint32_t constraint_set1_flag : 1; + uint32_t constraint_set2_flag : 1; + uint32_t constraint_set3_flag : 1; + uint32_t constraint_set4_flag : 1; + uint32_t constraint_set5_flag : 1; + uint32_t direct_8x8_inference_flag : 1; + uint32_t mb_adaptive_frame_field_flag : 1; + uint32_t frame_mbs_only_flag : 1; + uint32_t delta_pic_order_always_zero_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t gaps_in_frame_num_value_allowed_flag : 1; + uint32_t qpprime_y_zero_transform_bypass_flag : 1; + uint32_t frame_cropping_flag : 1; + uint32_t seq_scaling_matrix_present_flag : 1; + uint32_t vui_parameters_present_flag : 1; +} StdVideoH264SpsFlags; + +typedef struct StdVideoH264ScalingLists { + uint16_t scaling_list_present_mask; + uint16_t use_default_scaling_matrix_mask; + uint8_t ScalingList4x4[6][16]; + uint8_t ScalingList8x8[6][64]; +} StdVideoH264ScalingLists; + +typedef struct StdVideoH264SequenceParameterSet { + StdVideoH264SpsFlags flags; + StdVideoH264ProfileIdc profile_idc; + StdVideoH264LevelIdc level_idc; + StdVideoH264ChromaFormatIdc chroma_format_idc; + uint8_t seq_parameter_set_id; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_frame_num_minus4; + StdVideoH264PocType pic_order_cnt_type; + int32_t offset_for_non_ref_pic; + int32_t offset_for_top_to_bottom_field; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t num_ref_frames_in_pic_order_cnt_cycle; + uint8_t max_num_ref_frames; + uint8_t reserved1; + uint32_t pic_width_in_mbs_minus1; + uint32_t pic_height_in_map_units_minus1; + uint32_t frame_crop_left_offset; + uint32_t frame_crop_right_offset; + uint32_t frame_crop_top_offset; + uint32_t frame_crop_bottom_offset; + uint32_t reserved2; + const int32_t* pOffsetForRefFrame; + const StdVideoH264ScalingLists* pScalingLists; + const StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; +} StdVideoH264SequenceParameterSet; + +typedef struct StdVideoH264PpsFlags { + uint32_t transform_8x8_mode_flag : 1; + uint32_t redundant_pic_cnt_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t bottom_field_pic_order_in_frame_present_flag : 1; + uint32_t entropy_coding_mode_flag : 1; + uint32_t pic_scaling_matrix_present_flag : 1; +} StdVideoH264PpsFlags; + +typedef struct StdVideoH264PictureParameterSet { + StdVideoH264PpsFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + StdVideoH264WeightedBipredIdc weighted_bipred_idc; + int8_t pic_init_qp_minus26; + int8_t pic_init_qs_minus26; + int8_t chroma_qp_index_offset; + int8_t second_chroma_qp_index_offset; + const StdVideoH264ScalingLists* pScalingLists; +} StdVideoH264PictureParameterSet; + + + +} +# 8385 "/usr/include/vulkan/vulkan_core.h" 2 3 4 +# 1 "/usr/include/vk_video/vulkan_video_codec_h264std_decode.h" 1 3 4 +# 17 "/usr/include/vk_video/vulkan_video_codec_h264std_decode.h" 3 4 +extern "C" { +# 32 "/usr/include/vk_video/vulkan_video_codec_h264std_decode.h" 3 4 +typedef enum StdVideoDecodeH264FieldOrderCount { + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF, + STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_MAX_ENUM = 0x7FFFFFFF +} StdVideoDecodeH264FieldOrderCount; +typedef struct StdVideoDecodeH264PictureInfoFlags { + uint32_t field_pic_flag : 1; + uint32_t is_intra : 1; + uint32_t IdrPicFlag : 1; + uint32_t bottom_field_flag : 1; + uint32_t is_reference : 1; + uint32_t complementary_field_pair : 1; +} StdVideoDecodeH264PictureInfoFlags; + +typedef struct StdVideoDecodeH264PictureInfo { + StdVideoDecodeH264PictureInfoFlags flags; + uint8_t seq_parameter_set_id; + uint8_t pic_parameter_set_id; + uint8_t reserved1; + uint8_t reserved2; + uint16_t frame_num; + uint16_t idr_pic_id; + int32_t PicOrderCnt[2]; +} StdVideoDecodeH264PictureInfo; + +typedef struct StdVideoDecodeH264ReferenceInfoFlags { + uint32_t top_field_flag : 1; + uint32_t bottom_field_flag : 1; + uint32_t used_for_long_term_reference : 1; + uint32_t is_non_existing : 1; +} StdVideoDecodeH264ReferenceInfoFlags; + +typedef struct StdVideoDecodeH264ReferenceInfo { + StdVideoDecodeH264ReferenceInfoFlags flags; + uint16_t FrameNum; + uint16_t reserved; + int32_t PicOrderCnt[2]; +} StdVideoDecodeH264ReferenceInfo; + + + +} +# 8386 "/usr/include/vulkan/vulkan_core.h" 2 3 4 + + + +typedef enum VkVideoDecodeH264PictureLayoutFlagBitsKHR { + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR = 0, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR = 0x00000001, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR = 0x00000002, + VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkVideoDecodeH264PictureLayoutFlagBitsKHR; +typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsKHR; +typedef struct VkVideoDecodeH264ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH264ProfileIdc stdProfileIdc; + VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; +} VkVideoDecodeH264ProfileInfoKHR; + +typedef struct VkVideoDecodeH264CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoH264LevelIdc maxLevelIdc; + VkOffset2D fieldOffsetGranularity; +} VkVideoDecodeH264CapabilitiesKHR; + +typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdSPSCount; + const StdVideoH264SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH264PictureParameterSet* pStdPPSs; +} VkVideoDecodeH264SessionParametersAddInfoKHR; + +typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoDecodeH264SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeH264PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264PictureInfo* pStdPictureInfo; + uint32_t sliceCount; + const uint32_t* pSliceOffsets; +} VkVideoDecodeH264PictureInfoKHR; + +typedef struct VkVideoDecodeH264DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH264DpbSlotInfoKHR; + + + + + + + +typedef VkRenderingFlags VkRenderingFlagsKHR; + +typedef VkRenderingFlagBits VkRenderingFlagBitsKHR; + +typedef VkRenderingInfo VkRenderingInfoKHR; + +typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR; + +typedef VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfoKHR; + +typedef VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeaturesKHR; + +typedef VkCommandBufferInheritanceRenderingInfo VkCommandBufferInheritanceRenderingInfoKHR; + +typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkImageLayout imageLayout; + VkExtent2D shadingRateAttachmentTexelSize; +} VkRenderingFragmentShadingRateAttachmentInfoKHR; + +typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkImageLayout imageLayout; +} VkRenderingFragmentDensityMapAttachmentInfoEXT; + +typedef struct VkAttachmentSampleCountInfoAMD { + VkStructureType sType; + const void* pNext; + uint32_t colorAttachmentCount; + const VkSampleCountFlagBits* pColorAttachmentSamples; + VkSampleCountFlagBits depthStencilAttachmentSamples; +} VkAttachmentSampleCountInfoAMD; + +typedef VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoNV; + +typedef struct VkMultiviewPerViewAttributesInfoNVX { + VkStructureType sType; + const void* pNext; + VkBool32 perViewAttributes; + VkBool32 perViewAttributesPositionXOnly; +} VkMultiviewPerViewAttributesInfoNVX; + +typedef void ( *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); +typedef void ( *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer); +# 8510 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; + +typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; + +typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; + + + + + + + +typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; + +typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; + +typedef VkFormatProperties2 VkFormatProperties2KHR; + +typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; + +typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; + +typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; + +typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; + +typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; + +typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; + +typedef void ( *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); +typedef void ( *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); +typedef void ( *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); +typedef VkResult ( *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); +typedef void ( *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); +typedef void ( *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); +typedef void ( *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); +# 8588 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; + +typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; + +typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; + +typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; + +typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; + +typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; + +typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; + +typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; + +typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; + +typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; + +typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; + +typedef void ( *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); +typedef void ( *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); +typedef void ( *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +# 8649 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; + +typedef void ( *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); +# 8666 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; + +typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; + +typedef VkResult ( *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); +# 8685 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; + +typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; + +typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; + +typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; + +typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; + +typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; + +typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; + +typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; + +typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; + +typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; + +typedef void ( *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); +# 8720 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; + +typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; + +typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; + + + + + + + +typedef struct VkImportMemoryFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + int fd; +} VkImportMemoryFdInfoKHR; + +typedef struct VkMemoryFdPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryFdPropertiesKHR; + +typedef struct VkMemoryGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetFdInfoKHR; + +typedef VkResult ( *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); +typedef VkResult ( *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); +# 8773 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; + +typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; + +typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; + +typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; + +typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; + +typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; + +typedef void ( *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); +# 8799 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; + +typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; + +typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; + + + + + + + +typedef struct VkImportSemaphoreFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkSemaphoreImportFlags flags; + VkExternalSemaphoreHandleTypeFlagBits handleType; + int fd; +} VkImportSemaphoreFdInfoKHR; + +typedef struct VkSemaphoreGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkSemaphore semaphore; + VkExternalSemaphoreHandleTypeFlagBits handleType; +} VkSemaphoreGetFdInfoKHR; + +typedef VkResult ( *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); +typedef VkResult ( *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); +# 8846 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t maxPushDescriptors; +} VkPhysicalDevicePushDescriptorPropertiesKHR; + +typedef void ( *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); +typedef void ( *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); +# 8877 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR; + +typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR; + + + + + + + +typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; + + + + + + + +typedef struct VkRectLayerKHR { + VkOffset2D offset; + VkExtent2D extent; + uint32_t layer; +} VkRectLayerKHR; + +typedef struct VkPresentRegionKHR { + uint32_t rectangleCount; + const VkRectLayerKHR* pRectangles; +} VkPresentRegionKHR; + +typedef struct VkPresentRegionsKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentRegionKHR* pRegions; +} VkPresentRegionsKHR; + + + + + +typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; + + + +typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; + +typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; + +typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; + +typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; + +typedef VkResult ( *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); +typedef void ( *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); +# 8957 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR; + +typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR; + +typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR; + +typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR; + + + + + + + +typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR; + +typedef VkAttachmentDescription2 VkAttachmentDescription2KHR; + +typedef VkAttachmentReference2 VkAttachmentReference2KHR; + +typedef VkSubpassDescription2 VkSubpassDescription2KHR; + +typedef VkSubpassDependency2 VkSubpassDependency2KHR; + +typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR; + +typedef VkSubpassEndInfo VkSubpassEndInfoKHR; + +typedef VkResult ( *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); +typedef void ( *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); +typedef void ( *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); +typedef void ( *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); +# 9017 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkSharedPresentSurfaceCapabilitiesKHR { + VkStructureType sType; + void* pNext; + VkImageUsageFlags sharedPresentSupportedUsageFlags; +} VkSharedPresentSurfaceCapabilitiesKHR; + +typedef VkResult ( *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); +# 9036 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; + +typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; + +typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; + +typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; + +typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; + +typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; + +typedef void ( *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); +# 9062 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkFenceImportFlags VkFenceImportFlagsKHR; + +typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; + +typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; + + + + + + + +typedef struct VkImportFenceFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkFenceImportFlags flags; + VkExternalFenceHandleTypeFlagBits handleType; + int fd; +} VkImportFenceFdInfoKHR; + +typedef struct VkFenceGetFdInfoKHR { + VkStructureType sType; + const void* pNext; + VkFence fence; + VkExternalFenceHandleTypeFlagBits handleType; +} VkFenceGetFdInfoKHR; + +typedef VkResult ( *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); +typedef VkResult ( *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); +# 9110 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkPerformanceCounterUnitKHR { + VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, + VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, + VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, + VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, + VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, + VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, + VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, + VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, + VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, + VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, + VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterUnitKHR; + +typedef enum VkPerformanceCounterScopeKHR { + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, + VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, + VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, + VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, + VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, + VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, + VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterScopeKHR; + +typedef enum VkPerformanceCounterStorageKHR { + VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, + VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, + VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, + VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, + VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, + VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterStorageKHR; + +typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { + VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001, + VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002, + VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, + VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, + VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPerformanceCounterDescriptionFlagBitsKHR; +typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; + +typedef enum VkAcquireProfilingLockFlagBitsKHR { + VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAcquireProfilingLockFlagBitsKHR; +typedef VkFlags VkAcquireProfilingLockFlagsKHR; +typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 performanceCounterQueryPools; + VkBool32 performanceCounterMultipleQueryPools; +} VkPhysicalDevicePerformanceQueryFeaturesKHR; + +typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 allowCommandBufferQueryCopies; +} VkPhysicalDevicePerformanceQueryPropertiesKHR; + +typedef struct VkPerformanceCounterKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterUnitKHR unit; + VkPerformanceCounterScopeKHR scope; + VkPerformanceCounterStorageKHR storage; + uint8_t uuid[16U]; +} VkPerformanceCounterKHR; + +typedef struct VkPerformanceCounterDescriptionKHR { + VkStructureType sType; + void* pNext; + VkPerformanceCounterDescriptionFlagsKHR flags; + char name[256U]; + char category[256U]; + char description[256U]; +} VkPerformanceCounterDescriptionKHR; + +typedef struct VkQueryPoolPerformanceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t queueFamilyIndex; + uint32_t counterIndexCount; + const uint32_t* pCounterIndices; +} VkQueryPoolPerformanceCreateInfoKHR; + +typedef union VkPerformanceCounterResultKHR { + int32_t int32; + int64_t int64; + uint32_t uint32; + uint64_t uint64; + float float32; + double float64; +} VkPerformanceCounterResultKHR; + +typedef struct VkAcquireProfilingLockInfoKHR { + VkStructureType sType; + const void* pNext; + VkAcquireProfilingLockFlagsKHR flags; + uint64_t timeout; +} VkAcquireProfilingLockInfoKHR; + +typedef struct VkPerformanceQuerySubmitInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t counterPassIndex; +} VkPerformanceQuerySubmitInfoKHR; + +typedef VkResult ( *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); +typedef void ( *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); +typedef VkResult ( *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); +typedef void ( *PFN_vkReleaseProfilingLockKHR)(VkDevice device); +# 9252 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; + +typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; + +typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; + +typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; + +typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; + +typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; + +typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; + + + + + + + +typedef struct VkPhysicalDeviceSurfaceInfo2KHR { + VkStructureType sType; + const void* pNext; + VkSurfaceKHR surface; +} VkPhysicalDeviceSurfaceInfo2KHR; + +typedef struct VkSurfaceCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceCapabilitiesKHR surfaceCapabilities; +} VkSurfaceCapabilities2KHR; + +typedef struct VkSurfaceFormat2KHR { + VkStructureType sType; + void* pNext; + VkSurfaceFormatKHR surfaceFormat; +} VkSurfaceFormat2KHR; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); +typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); +# 9311 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; + +typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR; + + + + + + + +typedef struct VkDisplayProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPropertiesKHR displayProperties; +} VkDisplayProperties2KHR; + +typedef struct VkDisplayPlaneProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlanePropertiesKHR displayPlaneProperties; +} VkDisplayPlaneProperties2KHR; + +typedef struct VkDisplayModeProperties2KHR { + VkStructureType sType; + void* pNext; + VkDisplayModePropertiesKHR displayModeProperties; +} VkDisplayModeProperties2KHR; + +typedef struct VkDisplayPlaneInfo2KHR { + VkStructureType sType; + const void* pNext; + VkDisplayModeKHR mode; + uint32_t planeIndex; +} VkDisplayPlaneInfo2KHR; + +typedef struct VkDisplayPlaneCapabilities2KHR { + VkStructureType sType; + void* pNext; + VkDisplayPlaneCapabilitiesKHR capabilities; +} VkDisplayPlaneCapabilities2KHR; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); +typedef VkResult ( *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); +typedef VkResult ( *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); +typedef VkResult ( *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); +# 9385 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; + +typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; +# 9407 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; + +typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; + +typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; + +typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; + +typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; + +typedef void ( *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +# 9444 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR; + + + + + +typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; + + + +typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; + +typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; + +typedef VkChromaLocation VkChromaLocationKHR; + +typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; + +typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; + +typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; + +typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; + +typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; + +typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; + +typedef VkResult ( *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); +typedef void ( *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); +# 9493 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; + +typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; + +typedef VkResult ( *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); +typedef VkResult ( *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); +# 9519 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; + +typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; + +typedef void ( *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); +# 9537 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef void ( *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void ( *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +# 9565 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; + + + + + + + +typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR; + + + + + + + +typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR; + + + + + + + +typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupClock; + VkBool32 shaderDeviceClock; +} VkPhysicalDeviceShaderClockFeaturesKHR; + + + + + +# 1 "/usr/include/vk_video/vulkan_video_codec_h265std.h" 1 3 4 +# 17 "/usr/include/vk_video/vulkan_video_codec_h265std.h" 3 4 +extern "C" { +# 49 "/usr/include/vk_video/vulkan_video_codec_h265std.h" 3 4 +typedef enum StdVideoH265ChromaFormatIdc { + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265ChromaFormatIdc; + +typedef enum StdVideoH265ProfileIdc { + STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, + STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, + STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, + STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, + STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, + STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265ProfileIdc; + +typedef enum StdVideoH265LevelIdc { + STD_VIDEO_H265_LEVEL_IDC_1_0 = 0, + STD_VIDEO_H265_LEVEL_IDC_2_0 = 1, + STD_VIDEO_H265_LEVEL_IDC_2_1 = 2, + STD_VIDEO_H265_LEVEL_IDC_3_0 = 3, + STD_VIDEO_H265_LEVEL_IDC_3_1 = 4, + STD_VIDEO_H265_LEVEL_IDC_4_0 = 5, + STD_VIDEO_H265_LEVEL_IDC_4_1 = 6, + STD_VIDEO_H265_LEVEL_IDC_5_0 = 7, + STD_VIDEO_H265_LEVEL_IDC_5_1 = 8, + STD_VIDEO_H265_LEVEL_IDC_5_2 = 9, + STD_VIDEO_H265_LEVEL_IDC_6_0 = 10, + STD_VIDEO_H265_LEVEL_IDC_6_1 = 11, + STD_VIDEO_H265_LEVEL_IDC_6_2 = 12, + STD_VIDEO_H265_LEVEL_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265LevelIdc; + +typedef enum StdVideoH265SliceType { + STD_VIDEO_H265_SLICE_TYPE_B = 0, + STD_VIDEO_H265_SLICE_TYPE_P = 1, + STD_VIDEO_H265_SLICE_TYPE_I = 2, + STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265SliceType; + +typedef enum StdVideoH265PictureType { + STD_VIDEO_H265_PICTURE_TYPE_P = 0, + STD_VIDEO_H265_PICTURE_TYPE_B = 1, + STD_VIDEO_H265_PICTURE_TYPE_I = 2, + STD_VIDEO_H265_PICTURE_TYPE_IDR = 3, + STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265PictureType; + +typedef enum StdVideoH265AspectRatioIdc { + STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED = 0, + STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE = 1, + STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11 = 2, + STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11 = 3, + STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11 = 4, + STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33 = 5, + STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11 = 6, + STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11 = 7, + STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11 = 8, + STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33 = 9, + STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11 = 10, + STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11 = 11, + STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33 = 12, + STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99 = 13, + STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3 = 14, + STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2 = 15, + STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1 = 16, + STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, + STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, + STD_VIDEO_H265_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF +} StdVideoH265AspectRatioIdc; +typedef struct StdVideoH265DecPicBufMgr { + uint32_t max_latency_increase_plus1[7]; + uint8_t max_dec_pic_buffering_minus1[7]; + uint8_t max_num_reorder_pics[7]; +} StdVideoH265DecPicBufMgr; + +typedef struct StdVideoH265SubLayerHrdParameters { + uint32_t bit_rate_value_minus1[32]; + uint32_t cpb_size_value_minus1[32]; + uint32_t cpb_size_du_value_minus1[32]; + uint32_t bit_rate_du_value_minus1[32]; + uint32_t cbr_flag; +} StdVideoH265SubLayerHrdParameters; + +typedef struct StdVideoH265HrdFlags { + uint32_t nal_hrd_parameters_present_flag : 1; + uint32_t vcl_hrd_parameters_present_flag : 1; + uint32_t sub_pic_hrd_params_present_flag : 1; + uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; + uint32_t fixed_pic_rate_general_flag : 8; + uint32_t fixed_pic_rate_within_cvs_flag : 8; + uint32_t low_delay_hrd_flag : 8; +} StdVideoH265HrdFlags; + +typedef struct StdVideoH265HrdParameters { + StdVideoH265HrdFlags flags; + uint8_t tick_divisor_minus2; + uint8_t du_cpb_removal_delay_increment_length_minus1; + uint8_t dpb_output_delay_du_length_minus1; + uint8_t bit_rate_scale; + uint8_t cpb_size_scale; + uint8_t cpb_size_du_scale; + uint8_t initial_cpb_removal_delay_length_minus1; + uint8_t au_cpb_removal_delay_length_minus1; + uint8_t dpb_output_delay_length_minus1; + uint8_t cpb_cnt_minus1[7]; + uint16_t elemental_duration_in_tc_minus1[7]; + uint16_t reserved[3]; + const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal; + const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl; +} StdVideoH265HrdParameters; + +typedef struct StdVideoH265VpsFlags { + uint32_t vps_temporal_id_nesting_flag : 1; + uint32_t vps_sub_layer_ordering_info_present_flag : 1; + uint32_t vps_timing_info_present_flag : 1; + uint32_t vps_poc_proportional_to_timing_flag : 1; +} StdVideoH265VpsFlags; + +typedef struct StdVideoH265ProfileTierLevelFlags { + uint32_t general_tier_flag : 1; + uint32_t general_progressive_source_flag : 1; + uint32_t general_interlaced_source_flag : 1; + uint32_t general_non_packed_constraint_flag : 1; + uint32_t general_frame_only_constraint_flag : 1; +} StdVideoH265ProfileTierLevelFlags; + +typedef struct StdVideoH265ProfileTierLevel { + StdVideoH265ProfileTierLevelFlags flags; + StdVideoH265ProfileIdc general_profile_idc; + StdVideoH265LevelIdc general_level_idc; +} StdVideoH265ProfileTierLevel; + +typedef struct StdVideoH265VideoParameterSet { + StdVideoH265VpsFlags flags; + uint8_t vps_video_parameter_set_id; + uint8_t vps_max_sub_layers_minus1; + uint8_t reserved1; + uint8_t reserved2; + uint32_t vps_num_units_in_tick; + uint32_t vps_time_scale; + uint32_t vps_num_ticks_poc_diff_one_minus1; + uint32_t reserved3; + const StdVideoH265DecPicBufMgr* pDecPicBufMgr; + const StdVideoH265HrdParameters* pHrdParameters; + const StdVideoH265ProfileTierLevel* pProfileTierLevel; +} StdVideoH265VideoParameterSet; + +typedef struct StdVideoH265ScalingLists { + uint8_t ScalingList4x4[6][16]; + uint8_t ScalingList8x8[6][64]; + uint8_t ScalingList16x16[6][64]; + uint8_t ScalingList32x32[2][64]; + uint8_t ScalingListDCCoef16x16[6]; + uint8_t ScalingListDCCoef32x32[2]; +} StdVideoH265ScalingLists; + +typedef struct StdVideoH265SpsVuiFlags { + uint32_t aspect_ratio_info_present_flag : 1; + uint32_t overscan_info_present_flag : 1; + uint32_t overscan_appropriate_flag : 1; + uint32_t video_signal_type_present_flag : 1; + uint32_t video_full_range_flag : 1; + uint32_t colour_description_present_flag : 1; + uint32_t chroma_loc_info_present_flag : 1; + uint32_t neutral_chroma_indication_flag : 1; + uint32_t field_seq_flag : 1; + uint32_t frame_field_info_present_flag : 1; + uint32_t default_display_window_flag : 1; + uint32_t vui_timing_info_present_flag : 1; + uint32_t vui_poc_proportional_to_timing_flag : 1; + uint32_t vui_hrd_parameters_present_flag : 1; + uint32_t bitstream_restriction_flag : 1; + uint32_t tiles_fixed_structure_flag : 1; + uint32_t motion_vectors_over_pic_boundaries_flag : 1; + uint32_t restricted_ref_pic_lists_flag : 1; +} StdVideoH265SpsVuiFlags; + +typedef struct StdVideoH265SequenceParameterSetVui { + StdVideoH265SpsVuiFlags flags; + StdVideoH265AspectRatioIdc aspect_ratio_idc; + uint16_t sar_width; + uint16_t sar_height; + uint8_t video_format; + uint8_t colour_primaries; + uint8_t transfer_characteristics; + uint8_t matrix_coeffs; + uint8_t chroma_sample_loc_type_top_field; + uint8_t chroma_sample_loc_type_bottom_field; + uint8_t reserved1; + uint8_t reserved2; + uint16_t def_disp_win_left_offset; + uint16_t def_disp_win_right_offset; + uint16_t def_disp_win_top_offset; + uint16_t def_disp_win_bottom_offset; + uint32_t vui_num_units_in_tick; + uint32_t vui_time_scale; + uint32_t vui_num_ticks_poc_diff_one_minus1; + uint16_t min_spatial_segmentation_idc; + uint16_t reserved3; + uint8_t max_bytes_per_pic_denom; + uint8_t max_bits_per_min_cu_denom; + uint8_t log2_max_mv_length_horizontal; + uint8_t log2_max_mv_length_vertical; + const StdVideoH265HrdParameters* pHrdParameters; +} StdVideoH265SequenceParameterSetVui; + +typedef struct StdVideoH265PredictorPaletteEntries { + uint16_t PredictorPaletteEntries[3][128]; +} StdVideoH265PredictorPaletteEntries; + +typedef struct StdVideoH265SpsFlags { + uint32_t sps_temporal_id_nesting_flag : 1; + uint32_t separate_colour_plane_flag : 1; + uint32_t conformance_window_flag : 1; + uint32_t sps_sub_layer_ordering_info_present_flag : 1; + uint32_t scaling_list_enabled_flag : 1; + uint32_t sps_scaling_list_data_present_flag : 1; + uint32_t amp_enabled_flag : 1; + uint32_t sample_adaptive_offset_enabled_flag : 1; + uint32_t pcm_enabled_flag : 1; + uint32_t pcm_loop_filter_disabled_flag : 1; + uint32_t long_term_ref_pics_present_flag : 1; + uint32_t sps_temporal_mvp_enabled_flag : 1; + uint32_t strong_intra_smoothing_enabled_flag : 1; + uint32_t vui_parameters_present_flag : 1; + uint32_t sps_extension_present_flag : 1; + uint32_t sps_range_extension_flag : 1; + uint32_t transform_skip_rotation_enabled_flag : 1; + uint32_t transform_skip_context_enabled_flag : 1; + uint32_t implicit_rdpcm_enabled_flag : 1; + uint32_t explicit_rdpcm_enabled_flag : 1; + uint32_t extended_precision_processing_flag : 1; + uint32_t intra_smoothing_disabled_flag : 1; + uint32_t high_precision_offsets_enabled_flag : 1; + uint32_t persistent_rice_adaptation_enabled_flag : 1; + uint32_t cabac_bypass_alignment_enabled_flag : 1; + uint32_t sps_scc_extension_flag : 1; + uint32_t sps_curr_pic_ref_enabled_flag : 1; + uint32_t palette_mode_enabled_flag : 1; + uint32_t sps_palette_predictor_initializers_present_flag : 1; + uint32_t intra_boundary_filtering_disabled_flag : 1; +} StdVideoH265SpsFlags; + +typedef struct StdVideoH265ShortTermRefPicSetFlags { + uint32_t inter_ref_pic_set_prediction_flag : 1; + uint32_t delta_rps_sign : 1; +} StdVideoH265ShortTermRefPicSetFlags; + +typedef struct StdVideoH265ShortTermRefPicSet { + StdVideoH265ShortTermRefPicSetFlags flags; + uint32_t delta_idx_minus1; + uint16_t use_delta_flag; + uint16_t abs_delta_rps_minus1; + uint16_t used_by_curr_pic_flag; + uint16_t used_by_curr_pic_s0_flag; + uint16_t used_by_curr_pic_s1_flag; + uint16_t reserved1; + uint8_t reserved2; + uint8_t reserved3; + uint8_t num_negative_pics; + uint8_t num_positive_pics; + uint16_t delta_poc_s0_minus1[16]; + uint16_t delta_poc_s1_minus1[16]; +} StdVideoH265ShortTermRefPicSet; + +typedef struct StdVideoH265LongTermRefPicsSps { + uint32_t used_by_curr_pic_lt_sps_flag; + uint32_t lt_ref_pic_poc_lsb_sps[32]; +} StdVideoH265LongTermRefPicsSps; + +typedef struct StdVideoH265SequenceParameterSet { + StdVideoH265SpsFlags flags; + StdVideoH265ChromaFormatIdc chroma_format_idc; + uint32_t pic_width_in_luma_samples; + uint32_t pic_height_in_luma_samples; + uint8_t sps_video_parameter_set_id; + uint8_t sps_max_sub_layers_minus1; + uint8_t sps_seq_parameter_set_id; + uint8_t bit_depth_luma_minus8; + uint8_t bit_depth_chroma_minus8; + uint8_t log2_max_pic_order_cnt_lsb_minus4; + uint8_t log2_min_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_luma_coding_block_size; + uint8_t log2_min_luma_transform_block_size_minus2; + uint8_t log2_diff_max_min_luma_transform_block_size; + uint8_t max_transform_hierarchy_depth_inter; + uint8_t max_transform_hierarchy_depth_intra; + uint8_t num_short_term_ref_pic_sets; + uint8_t num_long_term_ref_pics_sps; + uint8_t pcm_sample_bit_depth_luma_minus1; + uint8_t pcm_sample_bit_depth_chroma_minus1; + uint8_t log2_min_pcm_luma_coding_block_size_minus3; + uint8_t log2_diff_max_min_pcm_luma_coding_block_size; + uint8_t reserved1; + uint8_t reserved2; + uint8_t palette_max_size; + uint8_t delta_palette_max_predictor_size; + uint8_t motion_vector_resolution_control_idc; + uint8_t sps_num_palette_predictor_initializers_minus1; + uint32_t conf_win_left_offset; + uint32_t conf_win_right_offset; + uint32_t conf_win_top_offset; + uint32_t conf_win_bottom_offset; + const StdVideoH265ProfileTierLevel* pProfileTierLevel; + const StdVideoH265DecPicBufMgr* pDecPicBufMgr; + const StdVideoH265ScalingLists* pScalingLists; + const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; + const StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps; + const StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; + const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +} StdVideoH265SequenceParameterSet; + +typedef struct StdVideoH265PpsFlags { + uint32_t dependent_slice_segments_enabled_flag : 1; + uint32_t output_flag_present_flag : 1; + uint32_t sign_data_hiding_enabled_flag : 1; + uint32_t cabac_init_present_flag : 1; + uint32_t constrained_intra_pred_flag : 1; + uint32_t transform_skip_enabled_flag : 1; + uint32_t cu_qp_delta_enabled_flag : 1; + uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; + uint32_t weighted_pred_flag : 1; + uint32_t weighted_bipred_flag : 1; + uint32_t transquant_bypass_enabled_flag : 1; + uint32_t tiles_enabled_flag : 1; + uint32_t entropy_coding_sync_enabled_flag : 1; + uint32_t uniform_spacing_flag : 1; + uint32_t loop_filter_across_tiles_enabled_flag : 1; + uint32_t pps_loop_filter_across_slices_enabled_flag : 1; + uint32_t deblocking_filter_control_present_flag : 1; + uint32_t deblocking_filter_override_enabled_flag : 1; + uint32_t pps_deblocking_filter_disabled_flag : 1; + uint32_t pps_scaling_list_data_present_flag : 1; + uint32_t lists_modification_present_flag : 1; + uint32_t slice_segment_header_extension_present_flag : 1; + uint32_t pps_extension_present_flag : 1; + uint32_t cross_component_prediction_enabled_flag : 1; + uint32_t chroma_qp_offset_list_enabled_flag : 1; + uint32_t pps_curr_pic_ref_enabled_flag : 1; + uint32_t residual_adaptive_colour_transform_enabled_flag : 1; + uint32_t pps_slice_act_qp_offsets_present_flag : 1; + uint32_t pps_palette_predictor_initializers_present_flag : 1; + uint32_t monochrome_palette_flag : 1; + uint32_t pps_range_extension_flag : 1; +} StdVideoH265PpsFlags; + +typedef struct StdVideoH265PictureParameterSet { + StdVideoH265PpsFlags flags; + uint8_t pps_pic_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t sps_video_parameter_set_id; + uint8_t num_extra_slice_header_bits; + uint8_t num_ref_idx_l0_default_active_minus1; + uint8_t num_ref_idx_l1_default_active_minus1; + int8_t init_qp_minus26; + uint8_t diff_cu_qp_delta_depth; + int8_t pps_cb_qp_offset; + int8_t pps_cr_qp_offset; + int8_t pps_beta_offset_div2; + int8_t pps_tc_offset_div2; + uint8_t log2_parallel_merge_level_minus2; + uint8_t log2_max_transform_skip_block_size_minus2; + uint8_t diff_cu_chroma_qp_offset_depth; + uint8_t chroma_qp_offset_list_len_minus1; + int8_t cb_qp_offset_list[6]; + int8_t cr_qp_offset_list[6]; + uint8_t log2_sao_offset_scale_luma; + uint8_t log2_sao_offset_scale_chroma; + int8_t pps_act_y_qp_offset_plus5; + int8_t pps_act_cb_qp_offset_plus5; + int8_t pps_act_cr_qp_offset_plus3; + uint8_t pps_num_palette_predictor_initializers; + uint8_t luma_bit_depth_entry_minus8; + uint8_t chroma_bit_depth_entry_minus8; + uint8_t num_tile_columns_minus1; + uint8_t num_tile_rows_minus1; + uint8_t reserved1; + uint8_t reserved2; + uint16_t column_width_minus1[19]; + uint16_t row_height_minus1[21]; + uint32_t reserved3; + const StdVideoH265ScalingLists* pScalingLists; + const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; +} StdVideoH265PictureParameterSet; + + + +} +# 9601 "/usr/include/vulkan/vulkan_core.h" 2 3 4 +# 1 "/usr/include/vk_video/vulkan_video_codec_h265std_decode.h" 1 3 4 +# 17 "/usr/include/vk_video/vulkan_video_codec_h265std_decode.h" 3 4 +extern "C" { +# 31 "/usr/include/vk_video/vulkan_video_codec_h265std_decode.h" 3 4 +typedef struct StdVideoDecodeH265PictureInfoFlags { + uint32_t IrapPicFlag : 1; + uint32_t IdrPicFlag : 1; + uint32_t IsReference : 1; + uint32_t short_term_ref_pic_set_sps_flag : 1; +} StdVideoDecodeH265PictureInfoFlags; + +typedef struct StdVideoDecodeH265PictureInfo { + StdVideoDecodeH265PictureInfoFlags flags; + uint8_t sps_video_parameter_set_id; + uint8_t pps_seq_parameter_set_id; + uint8_t pps_pic_parameter_set_id; + uint8_t NumDeltaPocsOfRefRpsIdx; + int32_t PicOrderCntVal; + uint16_t NumBitsForSTRefPicSetInSlice; + uint16_t reserved; + uint8_t RefPicSetStCurrBefore[8]; + uint8_t RefPicSetStCurrAfter[8]; + uint8_t RefPicSetLtCurr[8]; +} StdVideoDecodeH265PictureInfo; + +typedef struct StdVideoDecodeH265ReferenceInfoFlags { + uint32_t used_for_long_term_reference : 1; + uint32_t unused_for_reference : 1; +} StdVideoDecodeH265ReferenceInfoFlags; + +typedef struct StdVideoDecodeH265ReferenceInfo { + StdVideoDecodeH265ReferenceInfoFlags flags; + int32_t PicOrderCntVal; +} StdVideoDecodeH265ReferenceInfo; + + + +} +# 9602 "/usr/include/vulkan/vulkan_core.h" 2 3 4 + + +typedef struct VkVideoDecodeH265ProfileInfoKHR { + VkStructureType sType; + const void* pNext; + StdVideoH265ProfileIdc stdProfileIdc; +} VkVideoDecodeH265ProfileInfoKHR; + +typedef struct VkVideoDecodeH265CapabilitiesKHR { + VkStructureType sType; + void* pNext; + StdVideoH265LevelIdc maxLevelIdc; +} VkVideoDecodeH265CapabilitiesKHR; + +typedef struct VkVideoDecodeH265SessionParametersAddInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t stdVPSCount; + const StdVideoH265VideoParameterSet* pStdVPSs; + uint32_t stdSPSCount; + const StdVideoH265SequenceParameterSet* pStdSPSs; + uint32_t stdPPSCount; + const StdVideoH265PictureParameterSet* pStdPPSs; +} VkVideoDecodeH265SessionParametersAddInfoKHR; + +typedef struct VkVideoDecodeH265SessionParametersCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxStdVPSCount; + uint32_t maxStdSPSCount; + uint32_t maxStdPPSCount; + const VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo; +} VkVideoDecodeH265SessionParametersCreateInfoKHR; + +typedef struct VkVideoDecodeH265PictureInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH265PictureInfo* pStdPictureInfo; + uint32_t sliceSegmentCount; + const uint32_t* pSliceSegmentOffsets; +} VkVideoDecodeH265PictureInfoKHR; + +typedef struct VkVideoDecodeH265DpbSlotInfoKHR { + VkStructureType sType; + const void* pNext; + const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo; +} VkVideoDecodeH265DpbSlotInfoKHR; +# 9658 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkQueueGlobalPriorityKHR { + VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = 128, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = 256, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = 512, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = 1024, + VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR, + VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR, + VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR, + VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR, + VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_KHR = 0x7FFFFFFF +} VkQueueGlobalPriorityKHR; +typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkQueueGlobalPriorityKHR globalPriority; +} VkDeviceQueueGlobalPriorityCreateInfoKHR; + +typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 globalPriorityQuery; +} VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR; + +typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t priorityCount; + VkQueueGlobalPriorityKHR priorities[16U]; +} VkQueueFamilyGlobalPriorityPropertiesKHR; +# 9696 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkDriverId VkDriverIdKHR; + +typedef VkConformanceVersion VkConformanceVersionKHR; + +typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR; + + + + + + + +typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR; + +typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR; + + + + + + + +typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR; + +typedef VkResolveModeFlags VkResolveModeFlagsKHR; + +typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR; + +typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR; +# 9738 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkSemaphoreType VkSemaphoreTypeKHR; + +typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR; + +typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR; + +typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR; + +typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR; + +typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR; + +typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR; + +typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR; + +typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR; + +typedef VkResult ( *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); +typedef VkResult ( *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); +typedef VkResult ( *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); +# 9781 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR; + + + + + + + +typedef VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; +# 9798 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkFragmentShadingRateCombinerOpKHR { + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, + VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF +} VkFragmentShadingRateCombinerOpKHR; +typedef struct VkFragmentShadingRateAttachmentInfoKHR { + VkStructureType sType; + const void* pNext; + const VkAttachmentReference2* pFragmentShadingRateAttachment; + VkExtent2D shadingRateAttachmentTexelSize; +} VkFragmentShadingRateAttachmentInfoKHR; + +typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkExtent2D fragmentSize; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateStateCreateInfoKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineFragmentShadingRate; + VkBool32 primitiveFragmentShadingRate; + VkBool32 attachmentFragmentShadingRate; +} VkPhysicalDeviceFragmentShadingRateFeaturesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentShadingRateAttachmentTexelSize; + VkExtent2D maxFragmentShadingRateAttachmentTexelSize; + uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; + VkBool32 primitiveFragmentShadingRateWithMultipleViewports; + VkBool32 layeredShadingRateAttachments; + VkBool32 fragmentShadingRateNonTrivialCombinerOps; + VkExtent2D maxFragmentSize; + uint32_t maxFragmentSizeAspectRatio; + uint32_t maxFragmentShadingRateCoverageSamples; + VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; + VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; + VkBool32 fragmentShadingRateWithSampleMask; + VkBool32 fragmentShadingRateWithShaderSampleMask; + VkBool32 fragmentShadingRateWithConservativeRasterization; + VkBool32 fragmentShadingRateWithFragmentShaderInterlock; + VkBool32 fragmentShadingRateWithCustomSampleLocations; + VkBool32 fragmentShadingRateStrictMultiplyCombiner; +} VkPhysicalDeviceFragmentShadingRatePropertiesKHR; + +typedef struct VkPhysicalDeviceFragmentShadingRateKHR { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleCounts; + VkExtent2D fragmentSize; +} VkPhysicalDeviceFragmentShadingRateKHR; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); +typedef void ( *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); +# 9883 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkSurfaceProtectedCapabilitiesKHR { + VkStructureType sType; + const void* pNext; + VkBool32 supportsProtected; +} VkSurfaceProtectedCapabilitiesKHR; + + + + + + + +typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; + +typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR; + +typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR; + + + + + + + +typedef struct VkPhysicalDevicePresentWaitFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentWait; +} VkPhysicalDevicePresentWaitFeaturesKHR; + +typedef VkResult ( *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); +# 9928 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; + + + + + + + +typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR; + +typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR; + +typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR; + +typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR; + +typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR; + +typedef VkDeviceAddress ( *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t ( *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +typedef uint64_t ( *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); +# 9967 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkDeferredOperationKHR_T *VkDeferredOperationKHR; + + +typedef VkResult ( *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation); +typedef void ( *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); +typedef uint32_t ( *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation); +typedef VkResult ( *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation); +typedef VkResult ( *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation); +# 10006 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkPipelineExecutableStatisticFormatKHR { + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3, + VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF +} VkPipelineExecutableStatisticFormatKHR; +typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 pipelineExecutableInfo; +} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; + +typedef struct VkPipelineInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipeline pipeline; +} VkPipelineInfoKHR; + +typedef struct VkPipelineExecutablePropertiesKHR { + VkStructureType sType; + void* pNext; + VkShaderStageFlags stages; + char name[256U]; + char description[256U]; + uint32_t subgroupSize; +} VkPipelineExecutablePropertiesKHR; + +typedef struct VkPipelineExecutableInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipeline pipeline; + uint32_t executableIndex; +} VkPipelineExecutableInfoKHR; + +typedef union VkPipelineExecutableStatisticValueKHR { + VkBool32 b32; + int64_t i64; + uint64_t u64; + double f64; +} VkPipelineExecutableStatisticValueKHR; + +typedef struct VkPipelineExecutableStatisticKHR { + VkStructureType sType; + void* pNext; + char name[256U]; + char description[256U]; + VkPipelineExecutableStatisticFormatKHR format; + VkPipelineExecutableStatisticValueKHR value; +} VkPipelineExecutableStatisticKHR; + +typedef struct VkPipelineExecutableInternalRepresentationKHR { + VkStructureType sType; + void* pNext; + char name[256U]; + char description[256U]; + VkBool32 isText; + size_t dataSize; + void* pData; +} VkPipelineExecutableInternalRepresentationKHR; + +typedef VkResult ( *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties); +typedef VkResult ( *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics); +typedef VkResult ( *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); +# 10096 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkFlags VkMemoryUnmapFlagsKHR; +typedef struct VkMemoryMapInfoKHR { + VkStructureType sType; + const void* pNext; + VkMemoryMapFlags flags; + VkDeviceMemory memory; + VkDeviceSize offset; + VkDeviceSize size; +} VkMemoryMapInfoKHR; + +typedef struct VkMemoryUnmapInfoKHR { + VkStructureType sType; + const void* pNext; + VkMemoryUnmapFlagsKHR flags; + VkDeviceMemory memory; +} VkMemoryUnmapInfoKHR; + +typedef VkResult ( *PFN_vkMapMemory2KHR)(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData); +typedef VkResult ( *PFN_vkUnmapMemory2KHR)(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); +# 10132 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR; + +typedef VkPhysicalDeviceShaderIntegerDotProductProperties VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR; + + + + + + + +typedef struct VkPipelineLibraryCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t libraryCount; + const VkPipeline* pLibraries; +} VkPipelineLibraryCreateInfoKHR; +# 10161 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPresentIdKHR { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const uint64_t* pPresentIds; +} VkPresentIdKHR; + +typedef struct VkPhysicalDevicePresentIdFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 presentId; +} VkPhysicalDevicePresentIdFeaturesKHR; + + + + + + + +typedef VkPipelineStageFlags2 VkPipelineStageFlags2KHR; + +typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR; + +typedef VkAccessFlags2 VkAccessFlags2KHR; + +typedef VkAccessFlagBits2 VkAccessFlagBits2KHR; + +typedef VkSubmitFlagBits VkSubmitFlagBitsKHR; + +typedef VkSubmitFlags VkSubmitFlagsKHR; + +typedef VkMemoryBarrier2 VkMemoryBarrier2KHR; + +typedef VkBufferMemoryBarrier2 VkBufferMemoryBarrier2KHR; + +typedef VkImageMemoryBarrier2 VkImageMemoryBarrier2KHR; + +typedef VkDependencyInfo VkDependencyInfoKHR; + +typedef VkSubmitInfo2 VkSubmitInfo2KHR; + +typedef VkSemaphoreSubmitInfo VkSemaphoreSubmitInfoKHR; + +typedef VkCommandBufferSubmitInfo VkCommandBufferSubmitInfoKHR; + +typedef VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2FeaturesKHR; + +typedef struct VkQueueFamilyCheckpointProperties2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2 checkpointExecutionStageMask; +} VkQueueFamilyCheckpointProperties2NV; + +typedef struct VkCheckpointData2NV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags2 stage; + void* pCheckpointMarker; +} VkCheckpointData2NV; + +typedef void ( *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); +typedef void ( *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); +typedef void ( *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); +typedef void ( *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); +typedef void ( *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); +typedef VkResult ( *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); +typedef void ( *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +typedef void ( *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); +# 10281 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderBarycentric; +} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; + +typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 triStripVertexOrderIndependentOfProvokingVertex; +} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR; + + + + + + + +typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 shaderSubgroupUniformControlFlow; +} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; + + + + + + + +typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; + + + + + + + +typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 workgroupMemoryExplicitLayout; + VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; + VkBool32 workgroupMemoryExplicitLayout8BitAccess; + VkBool32 workgroupMemoryExplicitLayout16BitAccess; +} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; + + + + + + + +typedef VkCopyBufferInfo2 VkCopyBufferInfo2KHR; + +typedef VkCopyImageInfo2 VkCopyImageInfo2KHR; + +typedef VkCopyBufferToImageInfo2 VkCopyBufferToImageInfo2KHR; + +typedef VkCopyImageToBufferInfo2 VkCopyImageToBufferInfo2KHR; + +typedef VkBlitImageInfo2 VkBlitImageInfo2KHR; + +typedef VkResolveImageInfo2 VkResolveImageInfo2KHR; + +typedef VkBufferCopy2 VkBufferCopy2KHR; + +typedef VkImageCopy2 VkImageCopy2KHR; + +typedef VkImageBlit2 VkImageBlit2KHR; + +typedef VkBufferImageCopy2 VkBufferImageCopy2KHR; + +typedef VkImageResolve2 VkImageResolve2KHR; + +typedef void ( *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); +typedef void ( *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); +typedef void ( *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); +typedef void ( *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); +typedef void ( *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); +typedef void ( *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); +# 10394 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR; + +typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR; + +typedef VkFormatProperties3 VkFormatProperties3KHR; + + + + + + + +typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingMaintenance1; + VkBool32 rayTracingPipelineTraceRaysIndirect2; +} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR; + +typedef struct VkTraceRaysIndirectCommand2KHR { + VkDeviceAddress raygenShaderRecordAddress; + VkDeviceSize raygenShaderRecordSize; + VkDeviceAddress missShaderBindingTableAddress; + VkDeviceSize missShaderBindingTableSize; + VkDeviceSize missShaderBindingTableStride; + VkDeviceAddress hitShaderBindingTableAddress; + VkDeviceSize hitShaderBindingTableSize; + VkDeviceSize hitShaderBindingTableStride; + VkDeviceAddress callableShaderBindingTableAddress; + VkDeviceSize callableShaderBindingTableSize; + VkDeviceSize callableShaderBindingTableStride; + uint32_t width; + uint32_t height; + uint32_t depth; +} VkTraceRaysIndirectCommand2KHR; + +typedef void ( *PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); +# 10449 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceMaintenance4Features VkPhysicalDeviceMaintenance4FeaturesKHR; + +typedef VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4PropertiesKHR; + +typedef VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirementsKHR; + +typedef VkDeviceImageMemoryRequirements VkDeviceImageMemoryRequirementsKHR; + +typedef void ( *PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); +# 10484 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkFlags64 VkPipelineCreateFlags2KHR; + + +typedef VkFlags64 VkPipelineCreateFlagBits2KHR; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR = 0x00000040ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR = 0x00000100ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR = 0x00000200ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR = 0x00000800ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV = 0x00040000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL; +static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL; + +typedef VkFlags64 VkBufferUsageFlags2KHR; + + +typedef VkFlags64 VkBufferUsageFlagBits2KHR; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR = 0x00000001ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR = 0x00000002ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000004ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR = 0x00000010ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR = 0x00000020ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR = 0x00000040ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR = 0x00000080ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR = 0x00000100ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 0x02000000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV = 0x00000400ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00004000ULL; + + + + + + +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; +static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; + +typedef struct VkPhysicalDeviceMaintenance5FeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 maintenance5; +} VkPhysicalDeviceMaintenance5FeaturesKHR; + +typedef struct VkPhysicalDeviceMaintenance5PropertiesKHR { + VkStructureType sType; + void* pNext; + VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; + VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; + VkBool32 depthStencilSwizzleOneSupport; + VkBool32 polygonModePointSize; + VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; + VkBool32 nonStrictWideLinesUseParallelogram; +} VkPhysicalDeviceMaintenance5PropertiesKHR; + +typedef struct VkRenderingAreaInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t viewMask; + uint32_t colorAttachmentCount; + const VkFormat* pColorAttachmentFormats; + VkFormat depthAttachmentFormat; + VkFormat stencilAttachmentFormat; +} VkRenderingAreaInfoKHR; + +typedef struct VkImageSubresource2KHR { + VkStructureType sType; + void* pNext; + VkImageSubresource imageSubresource; +} VkImageSubresource2KHR; + +typedef struct VkDeviceImageSubresourceInfoKHR { + VkStructureType sType; + const void* pNext; + const VkImageCreateInfo* pCreateInfo; + const VkImageSubresource2KHR* pSubresource; +} VkDeviceImageSubresourceInfoKHR; + +typedef struct VkSubresourceLayout2KHR { + VkStructureType sType; + void* pNext; + VkSubresourceLayout subresourceLayout; +} VkSubresourceLayout2KHR; + +typedef struct VkPipelineCreateFlags2CreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags2KHR flags; +} VkPipelineCreateFlags2CreateInfoKHR; + +typedef struct VkBufferUsageFlags2CreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkBufferUsageFlags2KHR usage; +} VkBufferUsageFlags2CreateInfoKHR; + +typedef void ( *PFN_vkCmdBindIndexBuffer2KHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); +typedef void ( *PFN_vkGetRenderingAreaGranularityKHR)(VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity); +typedef void ( *PFN_vkGetDeviceImageSubresourceLayoutKHR)(VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout); +typedef void ( *PFN_vkGetImageSubresourceLayout2KHR)(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout); +# 10649 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingPositionFetch; +} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; +# 10662 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkComponentTypeKHR { + VK_COMPONENT_TYPE_FLOAT16_KHR = 0, + VK_COMPONENT_TYPE_FLOAT32_KHR = 1, + VK_COMPONENT_TYPE_FLOAT64_KHR = 2, + VK_COMPONENT_TYPE_SINT8_KHR = 3, + VK_COMPONENT_TYPE_SINT16_KHR = 4, + VK_COMPONENT_TYPE_SINT32_KHR = 5, + VK_COMPONENT_TYPE_SINT64_KHR = 6, + VK_COMPONENT_TYPE_UINT8_KHR = 7, + VK_COMPONENT_TYPE_UINT16_KHR = 8, + VK_COMPONENT_TYPE_UINT32_KHR = 9, + VK_COMPONENT_TYPE_UINT64_KHR = 10, + VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR, + VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR, + VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR, + VK_COMPONENT_TYPE_SINT8_NV = VK_COMPONENT_TYPE_SINT8_KHR, + VK_COMPONENT_TYPE_SINT16_NV = VK_COMPONENT_TYPE_SINT16_KHR, + VK_COMPONENT_TYPE_SINT32_NV = VK_COMPONENT_TYPE_SINT32_KHR, + VK_COMPONENT_TYPE_SINT64_NV = VK_COMPONENT_TYPE_SINT64_KHR, + VK_COMPONENT_TYPE_UINT8_NV = VK_COMPONENT_TYPE_UINT8_KHR, + VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR, + VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR, + VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR, + VK_COMPONENT_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkComponentTypeKHR; + +typedef enum VkScopeKHR { + VK_SCOPE_DEVICE_KHR = 1, + VK_SCOPE_WORKGROUP_KHR = 2, + VK_SCOPE_SUBGROUP_KHR = 3, + VK_SCOPE_QUEUE_FAMILY_KHR = 5, + VK_SCOPE_DEVICE_NV = VK_SCOPE_DEVICE_KHR, + VK_SCOPE_WORKGROUP_NV = VK_SCOPE_WORKGROUP_KHR, + VK_SCOPE_SUBGROUP_NV = VK_SCOPE_SUBGROUP_KHR, + VK_SCOPE_QUEUE_FAMILY_NV = VK_SCOPE_QUEUE_FAMILY_KHR, + VK_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkScopeKHR; +typedef struct VkCooperativeMatrixPropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeKHR AType; + VkComponentTypeKHR BType; + VkComponentTypeKHR CType; + VkComponentTypeKHR ResultType; + VkBool32 saturatingAccumulation; + VkScopeKHR scope; +} VkCooperativeMatrixPropertiesKHR; + +typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesKHR; + +typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR { + VkStructureType sType; + void* pNext; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesKHR; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties); +# 10738 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkDebugReportCallbackEXT_T *VkDebugReportCallbackEXT; + + + +typedef enum VkDebugReportObjectTypeEXT { + VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, + VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, + VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, + VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, + VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, + VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, + VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, + VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, + VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, + VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, + VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, + VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, + VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, + VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, + VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, + VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, + VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, + VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, + VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000, + VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001, + VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000, + VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, + VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV = 1000307000, + VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV = 1000307001, + VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000, + VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, + VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportObjectTypeEXT; + +typedef enum VkDebugReportFlagBitsEXT { + VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, + VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, + VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, + VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, + VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, + VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugReportFlagBitsEXT; +typedef VkFlags VkDebugReportFlagsEXT; +typedef VkBool32 ( *PFN_vkDebugReportCallbackEXT)( + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage, + void* pUserData); + +typedef struct VkDebugReportCallbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportFlagsEXT flags; + PFN_vkDebugReportCallbackEXT pfnCallback; + void* pUserData; +} VkDebugReportCallbackCreateInfoEXT; + +typedef VkResult ( *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); +typedef void ( *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); +# 10869 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkRasterizationOrderAMD { + VK_RASTERIZATION_ORDER_STRICT_AMD = 0, + VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, + VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF +} VkRasterizationOrderAMD; +typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { + VkStructureType sType; + const void* pNext; + VkRasterizationOrderAMD rasterizationOrder; +} VkPipelineRasterizationStateRasterizationOrderAMD; +# 10898 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkDebugMarkerObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + const char* pObjectName; +} VkDebugMarkerObjectNameInfoEXT; + +typedef struct VkDebugMarkerObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugReportObjectTypeEXT objectType; + uint64_t object; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugMarkerObjectTagInfoEXT; + +typedef struct VkDebugMarkerMarkerInfoEXT { + VkStructureType sType; + const void* pNext; + const char* pMarkerName; + float color[4]; +} VkDebugMarkerMarkerInfoEXT; + +typedef VkResult ( *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); +typedef VkResult ( *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); +typedef void ( *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +typedef void ( *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); +typedef void ( *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); +# 10961 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkDedicatedAllocationImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationImageCreateInfoNV; + +typedef struct VkDedicatedAllocationBufferCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 dedicatedAllocation; +} VkDedicatedAllocationBufferCreateInfoNV; + +typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkImage image; + VkBuffer buffer; +} VkDedicatedAllocationMemoryAllocateInfoNV; + + + + + + + +typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT; +typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 transformFeedback; + VkBool32 geometryStreams; +} VkPhysicalDeviceTransformFeedbackFeaturesEXT; + +typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxTransformFeedbackStreams; + uint32_t maxTransformFeedbackBuffers; + VkDeviceSize maxTransformFeedbackBufferSize; + uint32_t maxTransformFeedbackStreamDataSize; + uint32_t maxTransformFeedbackBufferDataSize; + uint32_t maxTransformFeedbackBufferDataStride; + VkBool32 transformFeedbackQueries; + VkBool32 transformFeedbackStreamsLinesTriangles; + VkBool32 transformFeedbackRasterizationStreamSelect; + VkBool32 transformFeedbackDraw; +} VkPhysicalDeviceTransformFeedbackPropertiesEXT; + +typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationStateStreamCreateFlagsEXT flags; + uint32_t rasterizationStream; +} VkPipelineRasterizationStateStreamCreateInfoEXT; + +typedef void ( *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); +typedef void ( *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void ( *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); +typedef void ( *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); +typedef void ( *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); +typedef void ( *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); +# 11072 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkCuModuleNVX_T *VkCuModuleNVX; +typedef struct VkCuFunctionNVX_T *VkCuFunctionNVX; + + +typedef struct VkCuModuleCreateInfoNVX { + VkStructureType sType; + const void* pNext; + size_t dataSize; + const void* pData; +} VkCuModuleCreateInfoNVX; + +typedef struct VkCuFunctionCreateInfoNVX { + VkStructureType sType; + const void* pNext; + VkCuModuleNVX module; + const char* pName; +} VkCuFunctionCreateInfoNVX; + +typedef struct VkCuLaunchInfoNVX { + VkStructureType sType; + const void* pNext; + VkCuFunctionNVX function; + uint32_t gridDimX; + uint32_t gridDimY; + uint32_t gridDimZ; + uint32_t blockDimX; + uint32_t blockDimY; + uint32_t blockDimZ; + uint32_t sharedMemBytes; + size_t paramCount; + const void* const * pParams; + size_t extraCount; + const void* const * pExtras; +} VkCuLaunchInfoNVX; + +typedef VkResult ( *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule); +typedef VkResult ( *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction); +typedef void ( *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); +# 11146 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkImageViewHandleInfoNVX { + VkStructureType sType; + const void* pNext; + VkImageView imageView; + VkDescriptorType descriptorType; + VkSampler sampler; +} VkImageViewHandleInfoNVX; + +typedef struct VkImageViewAddressPropertiesNVX { + VkStructureType sType; + void* pNext; + VkDeviceAddress deviceAddress; + VkDeviceSize size; +} VkImageViewAddressPropertiesNVX; + +typedef uint32_t ( *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); +typedef VkResult ( *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties); +# 11180 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef void ( *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +typedef void ( *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +# 11226 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkTextureLODGatherFormatPropertiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 supportsTextureGatherLODBiasAMD; +} VkTextureLODGatherFormatPropertiesAMD; +# 11239 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkShaderInfoTypeAMD { + VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, + VK_SHADER_INFO_TYPE_BINARY_AMD = 1, + VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, + VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF +} VkShaderInfoTypeAMD; +typedef struct VkShaderResourceUsageAMD { + uint32_t numUsedVgprs; + uint32_t numUsedSgprs; + uint32_t ldsSizePerLocalWorkGroup; + size_t ldsUsageSizeInBytes; + size_t scratchMemUsageInBytes; +} VkShaderResourceUsageAMD; + +typedef struct VkShaderStatisticsInfoAMD { + VkShaderStageFlags shaderStageMask; + VkShaderResourceUsageAMD resourceUsage; + uint32_t numPhysicalVgprs; + uint32_t numPhysicalSgprs; + uint32_t numAvailableVgprs; + uint32_t numAvailableSgprs; + uint32_t computeWorkGroupSize[3]; +} VkShaderStatisticsInfoAMD; + +typedef VkResult ( *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); +# 11286 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cornerSampledImage; +} VkPhysicalDeviceCornerSampledImageFeaturesNV; +# 11305 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkExternalMemoryHandleTypeFlagBitsNV { + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, + VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryHandleTypeFlagBitsNV; +typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; + +typedef enum VkExternalMemoryFeatureFlagBitsNV { + VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, + VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, + VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, + VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkExternalMemoryFeatureFlagBitsNV; +typedef VkFlags VkExternalMemoryFeatureFlagsNV; +typedef struct VkExternalImageFormatPropertiesNV { + VkImageFormatProperties imageFormatProperties; + VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; + VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; + VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; +} VkExternalImageFormatPropertiesNV; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); +# 11347 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkExternalMemoryImageCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExternalMemoryImageCreateInfoNV; + +typedef struct VkExportMemoryAllocateInfoNV { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagsNV handleTypes; +} VkExportMemoryAllocateInfoNV; +# 11366 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkValidationCheckEXT { + VK_VALIDATION_CHECK_ALL_EXT = 0, + VK_VALIDATION_CHECK_SHADERS_EXT = 1, + VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCheckEXT; +typedef struct VkValidationFlagsEXT { + VkStructureType sType; + const void* pNext; + uint32_t disabledValidationCheckCount; + const VkValidationCheckEXT* pDisabledValidationChecks; +} VkValidationFlagsEXT; +# 11396 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; + + + + + + + +typedef struct VkImageViewASTCDecodeModeEXT { + VkStructureType sType; + const void* pNext; + VkFormat decodeMode; +} VkImageViewASTCDecodeModeEXT; + +typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 decodeModeSharedExponent; +} VkPhysicalDeviceASTCDecodeFeaturesEXT; +# 11423 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkPipelineRobustnessBufferBehaviorEXT { + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = 0, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = 1, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = 2, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = 3, + VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPipelineRobustnessBufferBehaviorEXT; + +typedef enum VkPipelineRobustnessImageBehaviorEXT { + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = 0, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = 1, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = 2, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = 3, + VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPipelineRobustnessImageBehaviorEXT; +typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineRobustness; +} VkPhysicalDevicePipelineRobustnessFeaturesEXT; + +typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT { + VkStructureType sType; + void* pNext; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers; + VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs; + VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages; +} VkPhysicalDevicePipelineRobustnessPropertiesEXT; + +typedef struct VkPipelineRobustnessCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRobustnessBufferBehaviorEXT storageBuffers; + VkPipelineRobustnessBufferBehaviorEXT uniformBuffers; + VkPipelineRobustnessBufferBehaviorEXT vertexInputs; + VkPipelineRobustnessImageBehaviorEXT images; +} VkPipelineRobustnessCreateInfoEXT; +# 11469 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkConditionalRenderingFlagBitsEXT { + VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, + VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConditionalRenderingFlagBitsEXT; +typedef VkFlags VkConditionalRenderingFlagsEXT; +typedef struct VkConditionalRenderingBeginInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; + VkDeviceSize offset; + VkConditionalRenderingFlagsEXT flags; +} VkConditionalRenderingBeginInfoEXT; + +typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 conditionalRendering; + VkBool32 inheritedConditionalRendering; +} VkPhysicalDeviceConditionalRenderingFeaturesEXT; + +typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 conditionalRenderingEnable; +} VkCommandBufferInheritanceConditionalRenderingInfoEXT; + +typedef void ( *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); +typedef void ( *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); +# 11512 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkViewportWScalingNV { + float xcoeff; + float ycoeff; +} VkViewportWScalingNV; + +typedef struct VkPipelineViewportWScalingStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportWScalingEnable; + uint32_t viewportCount; + const VkViewportWScalingNV* pViewportWScalings; +} VkPipelineViewportWScalingStateCreateInfoNV; + +typedef void ( *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); +# 11540 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkResult ( *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); +# 11554 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkSurfaceCounterFlagBitsEXT { + VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001, + VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT, + VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSurfaceCounterFlagBitsEXT; +typedef VkFlags VkSurfaceCounterFlagsEXT; +typedef struct VkSurfaceCapabilities2EXT { + VkStructureType sType; + void* pNext; + uint32_t minImageCount; + uint32_t maxImageCount; + VkExtent2D currentExtent; + VkExtent2D minImageExtent; + VkExtent2D maxImageExtent; + uint32_t maxImageArrayLayers; + VkSurfaceTransformFlagsKHR supportedTransforms; + VkSurfaceTransformFlagBitsKHR currentTransform; + VkCompositeAlphaFlagsKHR supportedCompositeAlpha; + VkImageUsageFlags supportedUsageFlags; + VkSurfaceCounterFlagsEXT supportedSurfaceCounters; +} VkSurfaceCapabilities2EXT; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); +# 11591 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkDisplayPowerStateEXT { + VK_DISPLAY_POWER_STATE_OFF_EXT = 0, + VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, + VK_DISPLAY_POWER_STATE_ON_EXT = 2, + VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayPowerStateEXT; + +typedef enum VkDeviceEventTypeEXT { + VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, + VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceEventTypeEXT; + +typedef enum VkDisplayEventTypeEXT { + VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, + VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDisplayEventTypeEXT; +typedef struct VkDisplayPowerInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayPowerStateEXT powerState; +} VkDisplayPowerInfoEXT; + +typedef struct VkDeviceEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceEventTypeEXT deviceEvent; +} VkDeviceEventInfoEXT; + +typedef struct VkDisplayEventInfoEXT { + VkStructureType sType; + const void* pNext; + VkDisplayEventTypeEXT displayEvent; +} VkDisplayEventInfoEXT; + +typedef struct VkSwapchainCounterCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkSurfaceCounterFlagsEXT surfaceCounters; +} VkSwapchainCounterCreateInfoEXT; + +typedef VkResult ( *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); +typedef VkResult ( *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult ( *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); +typedef VkResult ( *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); +# 11667 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkRefreshCycleDurationGOOGLE { + uint64_t refreshDuration; +} VkRefreshCycleDurationGOOGLE; + +typedef struct VkPastPresentationTimingGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; + uint64_t actualPresentTime; + uint64_t earliestPresentTime; + uint64_t presentMargin; +} VkPastPresentationTimingGOOGLE; + +typedef struct VkPresentTimeGOOGLE { + uint32_t presentID; + uint64_t desiredPresentTime; +} VkPresentTimeGOOGLE; + +typedef struct VkPresentTimesInfoGOOGLE { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentTimeGOOGLE* pTimes; +} VkPresentTimesInfoGOOGLE; + +typedef VkResult ( *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); +typedef VkResult ( *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); +# 11732 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { + VkStructureType sType; + void* pNext; + VkBool32 perViewPositionAllComponents; +} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; +# 11745 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkViewportCoordinateSwizzleNV { + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, + VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, + VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, + VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF +} VkViewportCoordinateSwizzleNV; +typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; +typedef struct VkViewportSwizzleNV { + VkViewportCoordinateSwizzleNV x; + VkViewportCoordinateSwizzleNV y; + VkViewportCoordinateSwizzleNV z; + VkViewportCoordinateSwizzleNV w; +} VkViewportSwizzleNV; + +typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineViewportSwizzleStateCreateFlagsNV flags; + uint32_t viewportCount; + const VkViewportSwizzleNV* pViewportSwizzles; +} VkPipelineViewportSwizzleStateCreateInfoNV; +# 11779 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkDiscardRectangleModeEXT { + VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, + VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, + VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDiscardRectangleModeEXT; +typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxDiscardRectangles; +} VkPhysicalDeviceDiscardRectanglePropertiesEXT; + +typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineDiscardRectangleStateCreateFlagsEXT flags; + VkDiscardRectangleModeEXT discardRectangleMode; + uint32_t discardRectangleCount; + const VkRect2D* pDiscardRectangles; +} VkPipelineDiscardRectangleStateCreateInfoEXT; + +typedef void ( *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); +typedef void ( *PFN_vkCmdSetDiscardRectangleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); +typedef void ( *PFN_vkCmdSetDiscardRectangleModeEXT)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); +# 11826 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkConservativeRasterizationModeEXT { + VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, + VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, + VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, + VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkConservativeRasterizationModeEXT; +typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + float primitiveOverestimationSize; + float maxExtraPrimitiveOverestimationSize; + float extraPrimitiveOverestimationSizeGranularity; + VkBool32 primitiveUnderestimation; + VkBool32 conservativePointAndLineRasterization; + VkBool32 degenerateTrianglesRasterized; + VkBool32 degenerateLinesRasterized; + VkBool32 fullyCoveredFragmentShaderInputVariable; + VkBool32 conservativeRasterizationPostDepthCoverage; +} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; + VkConservativeRasterizationModeEXT conservativeRasterizationMode; + float extraPrimitiveOverestimationSize; +} VkPipelineRasterizationConservativeStateCreateInfoEXT; + + + + + + + +typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; +typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClipEnable; +} VkPhysicalDeviceDepthClipEnableFeaturesEXT; + +typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; + VkBool32 depthClipEnable; +} VkPipelineRasterizationDepthClipStateCreateInfoEXT; +# 11887 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkXYColorEXT { + float x; + float y; +} VkXYColorEXT; + +typedef struct VkHdrMetadataEXT { + VkStructureType sType; + const void* pNext; + VkXYColorEXT displayPrimaryRed; + VkXYColorEXT displayPrimaryGreen; + VkXYColorEXT displayPrimaryBlue; + VkXYColorEXT whitePoint; + float maxLuminance; + float minLuminance; + float maxContentLightLevel; + float maxFrameAverageLightLevel; +} VkHdrMetadataEXT; + +typedef void ( *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); +# 11931 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkDebugUtilsMessengerEXT_T *VkDebugUtilsMessengerEXT; + + +typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; + +typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, + VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageSeverityFlagBitsEXT; + +typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { + VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, + VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, + VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, + VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0x00000008, + VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDebugUtilsMessageTypeFlagBitsEXT; +typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; +typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; +typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; +typedef struct VkDebugUtilsLabelEXT { + VkStructureType sType; + const void* pNext; + const char* pLabelName; + float color[4]; +} VkDebugUtilsLabelEXT; + +typedef struct VkDebugUtilsObjectNameInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + const char* pObjectName; +} VkDebugUtilsObjectNameInfoEXT; + +typedef struct VkDebugUtilsMessengerCallbackDataEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCallbackDataFlagsEXT flags; + const char* pMessageIdName; + int32_t messageIdNumber; + const char* pMessage; + uint32_t queueLabelCount; + const VkDebugUtilsLabelEXT* pQueueLabels; + uint32_t cmdBufLabelCount; + const VkDebugUtilsLabelEXT* pCmdBufLabels; + uint32_t objectCount; + const VkDebugUtilsObjectNameInfoEXT* pObjects; +} VkDebugUtilsMessengerCallbackDataEXT; + +typedef VkBool32 ( *PFN_vkDebugUtilsMessengerCallbackEXT)( + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDebugUtilsMessengerCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDebugUtilsMessengerCreateFlagsEXT flags; + VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; + VkDebugUtilsMessageTypeFlagsEXT messageType; + PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; + void* pUserData; +} VkDebugUtilsMessengerCreateInfoEXT; + +typedef struct VkDebugUtilsObjectTagInfoEXT { + VkStructureType sType; + const void* pNext; + VkObjectType objectType; + uint64_t objectHandle; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkDebugUtilsObjectTagInfoEXT; + +typedef VkResult ( *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); +typedef VkResult ( *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); +typedef void ( *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void ( *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); +typedef void ( *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void ( *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef void ( *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); +typedef void ( *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); +typedef VkResult ( *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); +typedef void ( *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); +# 12076 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkSamplerReductionMode VkSamplerReductionModeEXT; + +typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT; + +typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; +# 12106 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlineUniformBlockFeaturesEXT; + +typedef VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInlineUniformBlockPropertiesEXT; + +typedef VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlockEXT; + +typedef VkDescriptorPoolInlineUniformBlockCreateInfo VkDescriptorPoolInlineUniformBlockCreateInfoEXT; +# 12126 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkSampleLocationEXT { + float x; + float y; +} VkSampleLocationEXT; + +typedef struct VkSampleLocationsInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampleCountFlagBits sampleLocationsPerPixel; + VkExtent2D sampleLocationGridSize; + uint32_t sampleLocationsCount; + const VkSampleLocationEXT* pSampleLocations; +} VkSampleLocationsInfoEXT; + +typedef struct VkAttachmentSampleLocationsEXT { + uint32_t attachmentIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkAttachmentSampleLocationsEXT; + +typedef struct VkSubpassSampleLocationsEXT { + uint32_t subpassIndex; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkSubpassSampleLocationsEXT; + +typedef struct VkRenderPassSampleLocationsBeginInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentInitialSampleLocationsCount; + const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; + uint32_t postSubpassSampleLocationsCount; + const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; +} VkRenderPassSampleLocationsBeginInfoEXT; + +typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 sampleLocationsEnable; + VkSampleLocationsInfoEXT sampleLocationsInfo; +} VkPipelineSampleLocationsStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { + VkStructureType sType; + void* pNext; + VkSampleCountFlags sampleLocationSampleCounts; + VkExtent2D maxSampleLocationGridSize; + float sampleLocationCoordinateRange[2]; + uint32_t sampleLocationSubPixelBits; + VkBool32 variableSampleLocations; +} VkPhysicalDeviceSampleLocationsPropertiesEXT; + +typedef struct VkMultisamplePropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D maxSampleLocationGridSize; +} VkMultisamplePropertiesEXT; + +typedef void ( *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); +typedef void ( *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); +# 12202 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkBlendOverlapEXT { + VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, + VK_BLEND_OVERLAP_DISJOINT_EXT = 1, + VK_BLEND_OVERLAP_CONJOINT_EXT = 2, + VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBlendOverlapEXT; +typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 advancedBlendCoherentOperations; +} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; + +typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t advancedBlendMaxColorAttachments; + VkBool32 advancedBlendIndependentBlend; + VkBool32 advancedBlendNonPremultipliedSrcColor; + VkBool32 advancedBlendNonPremultipliedDstColor; + VkBool32 advancedBlendCorrelatedOverlap; + VkBool32 advancedBlendAllOperations; +} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; + +typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; +} VkPipelineColorBlendAdvancedStateCreateInfoEXT; + + + + + + + +typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; +typedef struct VkPipelineCoverageToColorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageToColorStateCreateFlagsNV flags; + VkBool32 coverageToColorEnable; + uint32_t coverageToColorLocation; +} VkPipelineCoverageToColorStateCreateInfoNV; +# 12255 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkCoverageModulationModeNV { + VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, + VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, + VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, + VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, + VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageModulationModeNV; +typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; +typedef struct VkPipelineCoverageModulationStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageModulationStateCreateFlagsNV flags; + VkCoverageModulationModeNV coverageModulationMode; + VkBool32 coverageModulationTableEnable; + uint32_t coverageModulationTableCount; + const float* pCoverageModulationTable; +} VkPipelineCoverageModulationStateCreateInfoNV; +# 12285 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t shaderSMCount; + uint32_t shaderWarpsPerSM; +} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; + +typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shaderSMBuiltins; +} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; +# 12310 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkDrmFormatModifierPropertiesEXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags drmFormatModifierTilingFeatures; +} VkDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierPropertiesListEXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesListEXT; + +typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + VkSharingMode sharingMode; + uint32_t queueFamilyIndexCount; + const uint32_t* pQueueFamilyIndices; +} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; + +typedef struct VkImageDrmFormatModifierListCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t drmFormatModifierCount; + const uint64_t* pDrmFormatModifiers; +} VkImageDrmFormatModifierListCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + const VkSubresourceLayout* pPlaneLayouts; +} VkImageDrmFormatModifierExplicitCreateInfoEXT; + +typedef struct VkImageDrmFormatModifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint64_t drmFormatModifier; +} VkImageDrmFormatModifierPropertiesEXT; + +typedef struct VkDrmFormatModifierProperties2EXT { + uint64_t drmFormatModifier; + uint32_t drmFormatModifierPlaneCount; + VkFormatFeatureFlags2 drmFormatModifierTilingFeatures; +} VkDrmFormatModifierProperties2EXT; + +typedef struct VkDrmFormatModifierPropertiesList2EXT { + VkStructureType sType; + void* pNext; + uint32_t drmFormatModifierCount; + VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties; +} VkDrmFormatModifierPropertiesList2EXT; + +typedef VkResult ( *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); +# 12378 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkValidationCacheEXT_T *VkValidationCacheEXT; + + + +typedef enum VkValidationCacheHeaderVersionEXT { + VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, + VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationCacheHeaderVersionEXT; +typedef VkFlags VkValidationCacheCreateFlagsEXT; +typedef struct VkValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheCreateFlagsEXT flags; + size_t initialDataSize; + const void* pInitialData; +} VkValidationCacheCreateInfoEXT; + +typedef struct VkShaderModuleValidationCacheCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkValidationCacheEXT validationCache; +} VkShaderModuleValidationCacheCreateInfoEXT; + +typedef VkResult ( *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); +typedef void ( *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); +typedef VkResult ( *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); +# 12436 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT; + +typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT; + +typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; + +typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT; + +typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT; + +typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; + +typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; +# 12463 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkShadingRatePaletteEntryNV { + VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, + VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, + VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, + VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, + VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, + VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, + VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF +} VkShadingRatePaletteEntryNV; + +typedef enum VkCoarseSampleOrderTypeNV { + VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, + VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, + VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, + VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, + VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoarseSampleOrderTypeNV; +typedef struct VkShadingRatePaletteNV { + uint32_t shadingRatePaletteEntryCount; + const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries; +} VkShadingRatePaletteNV; + +typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 shadingRateImageEnable; + uint32_t viewportCount; + const VkShadingRatePaletteNV* pShadingRatePalettes; +} VkPipelineViewportShadingRateImageStateCreateInfoNV; + +typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 shadingRateImage; + VkBool32 shadingRateCoarseSampleOrder; +} VkPhysicalDeviceShadingRateImageFeaturesNV; + +typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV { + VkStructureType sType; + void* pNext; + VkExtent2D shadingRateTexelSize; + uint32_t shadingRatePaletteSize; + uint32_t shadingRateMaxCoarseSamples; +} VkPhysicalDeviceShadingRateImagePropertiesNV; + +typedef struct VkCoarseSampleLocationNV { + uint32_t pixelX; + uint32_t pixelY; + uint32_t sample; +} VkCoarseSampleLocationNV; + +typedef struct VkCoarseSampleOrderCustomNV { + VkShadingRatePaletteEntryNV shadingRate; + uint32_t sampleCount; + uint32_t sampleLocationCount; + const VkCoarseSampleLocationNV* pSampleLocations; +} VkCoarseSampleOrderCustomNV; + +typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkCoarseSampleOrderTypeNV sampleOrderType; + uint32_t customSampleOrderCount; + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders; +} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; + +typedef void ( *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +typedef void ( *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); +typedef void ( *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); +# 12561 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkAccelerationStructureNV_T *VkAccelerationStructureNV; + + + + + +typedef enum VkRayTracingShaderGroupTypeKHR { + VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0, + VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1, + VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2, + VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, + VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, + VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, + VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkRayTracingShaderGroupTypeKHR; +typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV; + + +typedef enum VkGeometryTypeKHR { + VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0, + VK_GEOMETRY_TYPE_AABBS_KHR = 1, + VK_GEOMETRY_TYPE_INSTANCES_KHR = 2, + VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, + VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, + VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkGeometryTypeKHR; +typedef VkGeometryTypeKHR VkGeometryTypeNV; + + +typedef enum VkAccelerationStructureTypeKHR { + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, + VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, + VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, + VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureTypeKHR; +typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV; + + +typedef enum VkCopyAccelerationStructureModeKHR { + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0, + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1, + VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2, + VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3, + VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, + VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, + VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkCopyAccelerationStructureModeKHR; +typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV; + + +typedef enum VkAccelerationStructureMemoryRequirementsTypeNV { + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, + VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureMemoryRequirementsTypeNV; + +typedef enum VkGeometryFlagBitsKHR { + VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001, + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002, + VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR, + VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR, + VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkGeometryFlagBitsKHR; +typedef VkFlags VkGeometryFlagsKHR; +typedef VkGeometryFlagsKHR VkGeometryFlagsNV; + +typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV; + + +typedef enum VkGeometryInstanceFlagBitsKHR { + VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001, + VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, + VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = 0x00000010, + VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000020, + VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, + VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, + VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, + VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkGeometryInstanceFlagBitsKHR; +typedef VkFlags VkGeometryInstanceFlagsKHR; +typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV; + +typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV; + + +typedef enum VkBuildAccelerationStructureFlagBitsKHR { + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, + VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = 0x00000040, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000080, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 0x00000100, + + + + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = 0x00000800, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, + VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkBuildAccelerationStructureFlagBitsKHR; +typedef VkFlags VkBuildAccelerationStructureFlagsKHR; +typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV; + +typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV; + +typedef struct VkRayTracingShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; +} VkRayTracingShaderGroupCreateInfoNV; + +typedef struct VkRayTracingPipelineCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const VkRayTracingShaderGroupCreateInfoNV* pGroups; + uint32_t maxRecursionDepth; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoNV; + +typedef struct VkGeometryTrianglesNV { + VkStructureType sType; + const void* pNext; + VkBuffer vertexData; + VkDeviceSize vertexOffset; + uint32_t vertexCount; + VkDeviceSize vertexStride; + VkFormat vertexFormat; + VkBuffer indexData; + VkDeviceSize indexOffset; + uint32_t indexCount; + VkIndexType indexType; + VkBuffer transformData; + VkDeviceSize transformOffset; +} VkGeometryTrianglesNV; + +typedef struct VkGeometryAABBNV { + VkStructureType sType; + const void* pNext; + VkBuffer aabbData; + uint32_t numAABBs; + uint32_t stride; + VkDeviceSize offset; +} VkGeometryAABBNV; + +typedef struct VkGeometryDataNV { + VkGeometryTrianglesNV triangles; + VkGeometryAABBNV aabbs; +} VkGeometryDataNV; + +typedef struct VkGeometryNV { + VkStructureType sType; + const void* pNext; + VkGeometryTypeKHR geometryType; + VkGeometryDataNV geometry; + VkGeometryFlagsKHR flags; +} VkGeometryNV; + +typedef struct VkAccelerationStructureInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeNV type; + VkBuildAccelerationStructureFlagsNV flags; + uint32_t instanceCount; + uint32_t geometryCount; + const VkGeometryNV* pGeometries; +} VkAccelerationStructureInfoNV; + +typedef struct VkAccelerationStructureCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceSize compactedSize; + VkAccelerationStructureInfoNV info; +} VkAccelerationStructureCreateInfoNV; + +typedef struct VkBindAccelerationStructureMemoryInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureNV accelerationStructure; + VkDeviceMemory memory; + VkDeviceSize memoryOffset; + uint32_t deviceIndexCount; + const uint32_t* pDeviceIndices; +} VkBindAccelerationStructureMemoryInfoNV; + +typedef struct VkWriteDescriptorSetAccelerationStructureNV { + VkStructureType sType; + const void* pNext; + uint32_t accelerationStructureCount; + const VkAccelerationStructureNV* pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureNV; + +typedef struct VkAccelerationStructureMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureMemoryRequirementsTypeNV type; + VkAccelerationStructureNV accelerationStructure; +} VkAccelerationStructureMemoryRequirementsInfoNV; + +typedef struct VkPhysicalDeviceRayTracingPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t shaderGroupHandleSize; + uint32_t maxRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxTriangleCount; + uint32_t maxDescriptorSetAccelerationStructures; +} VkPhysicalDeviceRayTracingPropertiesNV; + +typedef struct VkTransformMatrixKHR { + float matrix[3][4]; +} VkTransformMatrixKHR; + +typedef VkTransformMatrixKHR VkTransformMatrixNV; + +typedef struct VkAabbPositionsKHR { + float minX; + float minY; + float minZ; + float maxX; + float maxY; + float maxZ; +} VkAabbPositionsKHR; + +typedef VkAabbPositionsKHR VkAabbPositionsNV; + +typedef struct VkAccelerationStructureInstanceKHR { + VkTransformMatrixKHR transform; + uint32_t instanceCustomIndex:24; + uint32_t mask:8; + uint32_t instanceShaderBindingTableRecordOffset:24; + VkGeometryInstanceFlagsKHR flags:8; + uint64_t accelerationStructureReference; +} VkAccelerationStructureInstanceKHR; + +typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV; + +typedef VkResult ( *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); +typedef void ( *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); +typedef VkResult ( *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); +typedef void ( *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); +typedef void ( *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); +typedef void ( *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); +typedef VkResult ( *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult ( *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef VkResult ( *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef VkResult ( *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); +typedef void ( *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef VkResult ( *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader); +# 12942 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 representativeFragmentTest; +} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; + +typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 representativeFragmentTestEnable; +} VkPipelineRepresentativeFragmentTestStateCreateInfoNV; + + + + + + + +typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { + VkStructureType sType; + void* pNext; + VkImageViewType imageViewType; +} VkPhysicalDeviceImageViewImageFormatInfoEXT; + +typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 filterCubic; + VkBool32 filterCubicMinmax; +} VkFilterCubicImageViewImageFormatPropertiesEXT; +# 12985 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkQueueGlobalPriorityKHR VkQueueGlobalPriorityEXT; + +typedef VkDeviceQueueGlobalPriorityCreateInfoKHR VkDeviceQueueGlobalPriorityCreateInfoEXT; + + + + + + + +typedef struct VkImportMemoryHostPointerInfoEXT { + VkStructureType sType; + const void* pNext; + VkExternalMemoryHandleTypeFlagBits handleType; + void* pHostPointer; +} VkImportMemoryHostPointerInfoEXT; + +typedef struct VkMemoryHostPointerPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t memoryTypeBits; +} VkMemoryHostPointerPropertiesEXT; + +typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize minImportedHostPointerAlignment; +} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; + +typedef VkResult ( *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); +# 13029 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef void ( *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); +# 13046 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkPipelineCompilerControlFlagBitsAMD { + VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF +} VkPipelineCompilerControlFlagBitsAMD; +typedef VkFlags VkPipelineCompilerControlFlagsAMD; +typedef struct VkPipelineCompilerControlCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkPipelineCompilerControlFlagsAMD compilerControlFlags; +} VkPipelineCompilerControlCreateInfoAMD; +# 13063 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkTimeDomainEXT { + VK_TIME_DOMAIN_DEVICE_EXT = 0, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, + VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, + VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, + VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF +} VkTimeDomainEXT; +typedef struct VkCalibratedTimestampInfoEXT { + VkStructureType sType; + const void* pNext; + VkTimeDomainEXT timeDomain; +} VkCalibratedTimestampInfoEXT; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); +typedef VkResult ( *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); +# 13098 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { + VkStructureType sType; + void* pNext; + uint32_t shaderEngineCount; + uint32_t shaderArraysPerEngineCount; + uint32_t computeUnitsPerShaderArray; + uint32_t simdPerComputeUnit; + uint32_t wavefrontsPerSimd; + uint32_t wavefrontSize; + uint32_t sgprsPerSimd; + uint32_t minSgprAllocation; + uint32_t maxSgprAllocation; + uint32_t sgprAllocationGranularity; + uint32_t vgprsPerSimd; + uint32_t minVgprAllocation; + uint32_t maxVgprAllocation; + uint32_t vgprAllocationGranularity; +} VkPhysicalDeviceShaderCorePropertiesAMD; +# 13124 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkMemoryOverallocationBehaviorAMD { + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, + VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF +} VkMemoryOverallocationBehaviorAMD; +typedef struct VkDeviceMemoryOverallocationCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkMemoryOverallocationBehaviorAMD overallocationBehavior; +} VkDeviceMemoryOverallocationCreateInfoAMD; + + + + + + + +typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxVertexAttribDivisor; +} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; + +typedef struct VkVertexInputBindingDivisorDescriptionEXT { + uint32_t binding; + uint32_t divisor; +} VkVertexInputBindingDivisorDescriptionEXT; + +typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t vertexBindingDivisorCount; + const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; +} VkPipelineVertexInputDivisorStateCreateInfoEXT; + +typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexAttributeInstanceRateDivisor; + VkBool32 vertexAttributeInstanceRateZeroDivisor; +} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; + + + + + + + +typedef VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFlagBitsEXT; + +typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT; + +typedef VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackCreateInfoEXT; + +typedef VkPipelineCreationFeedback VkPipelineCreationFeedbackEXT; +# 13193 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 computeDerivativeGroupQuads; + VkBool32 computeDerivativeGroupLinear; +} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; + + + + + + + +typedef struct VkPhysicalDeviceMeshShaderFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 taskShader; + VkBool32 meshShader; +} VkPhysicalDeviceMeshShaderFeaturesNV; + +typedef struct VkPhysicalDeviceMeshShaderPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxDrawMeshTasksCount; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskTotalMemorySize; + uint32_t maxTaskOutputCount; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshTotalMemorySize; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; +} VkPhysicalDeviceMeshShaderPropertiesNV; + +typedef struct VkDrawMeshTasksIndirectCommandNV { + uint32_t taskCount; + uint32_t firstTask; +} VkDrawMeshTasksIndirectCommandNV; + +typedef void ( *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); +typedef void ( *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void ( *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +# 13268 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; + + + + + + + +typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 imageFootprint; +} VkPhysicalDeviceShaderImageFootprintFeaturesNV; + + + + + + + +typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t exclusiveScissorCount; + const VkRect2D* pExclusiveScissors; +} VkPipelineViewportExclusiveScissorStateCreateInfoNV; + +typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 exclusiveScissor; +} VkPhysicalDeviceExclusiveScissorFeaturesNV; + +typedef void ( *PFN_vkCmdSetExclusiveScissorEnableNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables); +typedef void ( *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); +# 13323 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkQueueFamilyCheckpointPropertiesNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlags checkpointExecutionStageMask; +} VkQueueFamilyCheckpointPropertiesNV; + +typedef struct VkCheckpointDataNV { + VkStructureType sType; + void* pNext; + VkPipelineStageFlagBits stage; + void* pCheckpointMarker; +} VkCheckpointDataNV; + +typedef void ( *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker); +typedef void ( *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); +# 13355 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { + VkStructureType sType; + void* pNext; + VkBool32 shaderIntegerFunctions2; +} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; + + + + + +typedef struct VkPerformanceConfigurationINTEL_T *VkPerformanceConfigurationINTEL; + + + +typedef enum VkPerformanceConfigurationTypeINTEL { + VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0, + VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceConfigurationTypeINTEL; + +typedef enum VkQueryPoolSamplingModeINTEL { + VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0, + VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkQueryPoolSamplingModeINTEL; + +typedef enum VkPerformanceOverrideTypeINTEL { + VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0, + VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1, + VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceOverrideTypeINTEL; + +typedef enum VkPerformanceParameterTypeINTEL { + VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0, + VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1, + VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceParameterTypeINTEL; + +typedef enum VkPerformanceValueTypeINTEL { + VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0, + VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1, + VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2, + VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3, + VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4, + VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF +} VkPerformanceValueTypeINTEL; +typedef union VkPerformanceValueDataINTEL { + uint32_t value32; + uint64_t value64; + float valueFloat; + VkBool32 valueBool; + const char* valueString; +} VkPerformanceValueDataINTEL; + +typedef struct VkPerformanceValueINTEL { + VkPerformanceValueTypeINTEL type; + VkPerformanceValueDataINTEL data; +} VkPerformanceValueINTEL; + +typedef struct VkInitializePerformanceApiInfoINTEL { + VkStructureType sType; + const void* pNext; + void* pUserData; +} VkInitializePerformanceApiInfoINTEL; + +typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL { + VkStructureType sType; + const void* pNext; + VkQueryPoolSamplingModeINTEL performanceCountersSampling; +} VkQueryPoolPerformanceQueryCreateInfoINTEL; + +typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL; + +typedef struct VkPerformanceMarkerInfoINTEL { + VkStructureType sType; + const void* pNext; + uint64_t marker; +} VkPerformanceMarkerInfoINTEL; + +typedef struct VkPerformanceStreamMarkerInfoINTEL { + VkStructureType sType; + const void* pNext; + uint32_t marker; +} VkPerformanceStreamMarkerInfoINTEL; + +typedef struct VkPerformanceOverrideInfoINTEL { + VkStructureType sType; + const void* pNext; + VkPerformanceOverrideTypeINTEL type; + VkBool32 enable; + uint64_t parameter; +} VkPerformanceOverrideInfoINTEL; + +typedef struct VkPerformanceConfigurationAcquireInfoINTEL { + VkStructureType sType; + const void* pNext; + VkPerformanceConfigurationTypeINTEL type; +} VkPerformanceConfigurationAcquireInfoINTEL; + +typedef VkResult ( *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); +typedef void ( *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device); +typedef VkResult ( *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo); +typedef VkResult ( *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); +typedef VkResult ( *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo); +typedef VkResult ( *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration); +typedef VkResult ( *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration); +typedef VkResult ( *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration); +typedef VkResult ( *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue); +# 13506 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t pciDomain; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; +} VkPhysicalDevicePCIBusInfoPropertiesEXT; + + + + + + + +typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD { + VkStructureType sType; + void* pNext; + VkBool32 localDimmingSupport; +} VkDisplayNativeHdrSurfaceCapabilitiesAMD; + +typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD { + VkStructureType sType; + const void* pNext; + VkBool32 localDimmingEnable; +} VkSwapchainDisplayNativeHdrCreateInfoAMD; + +typedef void ( *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); +# 13547 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMap; + VkBool32 fragmentDensityMapDynamic; + VkBool32 fragmentDensityMapNonSubsampledImages; +} VkPhysicalDeviceFragmentDensityMapFeaturesEXT; + +typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + VkExtent2D minFragmentDensityTexelSize; + VkExtent2D maxFragmentDensityTexelSize; + VkBool32 fragmentDensityInvocations; +} VkPhysicalDeviceFragmentDensityMapPropertiesEXT; + +typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkAttachmentReference fragmentDensityMapAttachment; +} VkRenderPassFragmentDensityMapCreateInfoEXT; + + + + + + + +typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT; +# 13597 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; + +typedef VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; + +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; +# 13610 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkShaderCorePropertiesFlagBitsAMD { + VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF +} VkShaderCorePropertiesFlagBitsAMD; +typedef VkFlags VkShaderCorePropertiesFlagsAMD; +typedef struct VkPhysicalDeviceShaderCoreProperties2AMD { + VkStructureType sType; + void* pNext; + VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; + uint32_t activeComputeUnitCount; +} VkPhysicalDeviceShaderCoreProperties2AMD; + + + + + + + +typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 deviceCoherentMemory; +} VkPhysicalDeviceCoherentMemoryFeaturesAMD; + + + + + + + +typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderImageInt64Atomics; + VkBool32 sparseImageInt64Atomics; +} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; + + + + + + + +typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize heapBudget[16U]; + VkDeviceSize heapUsage[16U]; +} VkPhysicalDeviceMemoryBudgetPropertiesEXT; + + + + + + + +typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 memoryPriority; +} VkPhysicalDeviceMemoryPriorityFeaturesEXT; + +typedef struct VkMemoryPriorityAllocateInfoEXT { + VkStructureType sType; + const void* pNext; + float priority; +} VkMemoryPriorityAllocateInfoEXT; + + + + + + + +typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 dedicatedAllocationImageAliasing; +} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; + + + + + + + +typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 bufferDeviceAddress; + VkBool32 bufferDeviceAddressCaptureReplay; + VkBool32 bufferDeviceAddressMultiDevice; +} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; + +typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT; + +typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT; + +typedef struct VkBufferDeviceAddressCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceAddress deviceAddress; +} VkBufferDeviceAddressCreateInfoEXT; + +typedef VkDeviceAddress ( *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); +# 13726 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkToolPurposeFlagBits VkToolPurposeFlagBitsEXT; + +typedef VkToolPurposeFlags VkToolPurposeFlagsEXT; + +typedef VkPhysicalDeviceToolProperties VkPhysicalDeviceToolPropertiesEXT; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); +# 13746 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT; +# 13755 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkValidationFeatureEnableEXT { + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, + VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, + VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, + VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, + VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, + VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureEnableEXT; + +typedef enum VkValidationFeatureDisableEXT { + VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, + VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, + VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, + VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, + VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, + VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, + VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, + VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, + VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkValidationFeatureDisableEXT; +typedef struct VkValidationFeaturesEXT { + VkStructureType sType; + const void* pNext; + uint32_t enabledValidationFeatureCount; + const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; + uint32_t disabledValidationFeatureCount; + const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; +} VkValidationFeaturesEXT; + + + + + + + +typedef VkComponentTypeKHR VkComponentTypeNV; + +typedef VkScopeKHR VkScopeNV; + +typedef struct VkCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t MSize; + uint32_t NSize; + uint32_t KSize; + VkComponentTypeNV AType; + VkComponentTypeNV BType; + VkComponentTypeNV CType; + VkComponentTypeNV DType; + VkScopeNV scope; +} VkCooperativeMatrixPropertiesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cooperativeMatrix; + VkBool32 cooperativeMatrixRobustBufferAccess; +} VkPhysicalDeviceCooperativeMatrixFeaturesNV; + +typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV { + VkStructureType sType; + void* pNext; + VkShaderStageFlags cooperativeMatrixSupportedStages; +} VkPhysicalDeviceCooperativeMatrixPropertiesNV; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); +# 13835 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkCoverageReductionModeNV { + VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0, + VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1, + VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkCoverageReductionModeNV; +typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV; +typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 coverageReductionMode; +} VkPhysicalDeviceCoverageReductionModeFeaturesNV; + +typedef struct VkPipelineCoverageReductionStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineCoverageReductionStateCreateFlagsNV flags; + VkCoverageReductionModeNV coverageReductionMode; +} VkPipelineCoverageReductionStateCreateInfoNV; + +typedef struct VkFramebufferMixedSamplesCombinationNV { + VkStructureType sType; + void* pNext; + VkCoverageReductionModeNV coverageReductionMode; + VkSampleCountFlagBits rasterizationSamples; + VkSampleCountFlags depthStencilSamples; + VkSampleCountFlags colorSamples; +} VkFramebufferMixedSamplesCombinationNV; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); +# 13877 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShaderSampleInterlock; + VkBool32 fragmentShaderPixelInterlock; + VkBool32 fragmentShaderShadingRateInterlock; +} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; + + + + + + + +typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcrImageArrays; +} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; +# 13904 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkProvokingVertexModeEXT { + VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0, + VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1, + VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkProvokingVertexModeEXT; +typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 provokingVertexLast; + VkBool32 transformFeedbackPreservesProvokingVertex; +} VkPhysicalDeviceProvokingVertexFeaturesEXT; + +typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 provokingVertexModePerPipeline; + VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; +} VkPhysicalDeviceProvokingVertexPropertiesEXT; + +typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkProvokingVertexModeEXT provokingVertexMode; +} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; + + + + + + + +typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; +typedef struct VkHeadlessSurfaceCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkHeadlessSurfaceCreateFlagsEXT flags; +} VkHeadlessSurfaceCreateInfoEXT; + +typedef VkResult ( *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); +# 13958 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkLineRasterizationModeEXT { + VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1, + VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2, + VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3, + VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkLineRasterizationModeEXT; +typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 rectangularLines; + VkBool32 bresenhamLines; + VkBool32 smoothLines; + VkBool32 stippledRectangularLines; + VkBool32 stippledBresenhamLines; + VkBool32 stippledSmoothLines; +} VkPhysicalDeviceLineRasterizationFeaturesEXT; + +typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t lineSubPixelPrecisionBits; +} VkPhysicalDeviceLineRasterizationPropertiesEXT; + +typedef struct VkPipelineRasterizationLineStateCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkLineRasterizationModeEXT lineRasterizationMode; + VkBool32 stippledLineEnable; + uint32_t lineStippleFactor; + uint16_t lineStipplePattern; +} VkPipelineRasterizationLineStateCreateInfoEXT; + +typedef void ( *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); +# 14005 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferFloat32Atomics; + VkBool32 shaderBufferFloat32AtomicAdd; + VkBool32 shaderBufferFloat64Atomics; + VkBool32 shaderBufferFloat64AtomicAdd; + VkBool32 shaderSharedFloat32Atomics; + VkBool32 shaderSharedFloat32AtomicAdd; + VkBool32 shaderSharedFloat64Atomics; + VkBool32 shaderSharedFloat64AtomicAdd; + VkBool32 shaderImageFloat32Atomics; + VkBool32 shaderImageFloat32AtomicAdd; + VkBool32 sparseImageFloat32Atomics; + VkBool32 sparseImageFloat32AtomicAdd; +} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; + + + + + + + +typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT; + +typedef void ( *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); +# 14045 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 indexTypeUint8; +} VkPhysicalDeviceIndexTypeUint8FeaturesEXT; + + + + + + + +typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState; +} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; + +typedef void ( *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); +typedef void ( *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); +typedef void ( *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); +typedef void ( *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); +typedef void ( *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); +typedef void ( *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); +typedef void ( *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); +typedef void ( *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); +typedef void ( *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); +typedef void ( *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); +typedef void ( *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); +typedef void ( *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); +# 14143 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkHostImageCopyFlagBitsEXT { + VK_HOST_IMAGE_COPY_MEMCPY_EXT = 0x00000001, + VK_HOST_IMAGE_COPY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkHostImageCopyFlagBitsEXT; +typedef VkFlags VkHostImageCopyFlagsEXT; +typedef struct VkPhysicalDeviceHostImageCopyFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 hostImageCopy; +} VkPhysicalDeviceHostImageCopyFeaturesEXT; + +typedef struct VkPhysicalDeviceHostImageCopyPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t copySrcLayoutCount; + VkImageLayout* pCopySrcLayouts; + uint32_t copyDstLayoutCount; + VkImageLayout* pCopyDstLayouts; + uint8_t optimalTilingLayoutUUID[16U]; + VkBool32 identicalMemoryTypeRequirements; +} VkPhysicalDeviceHostImageCopyPropertiesEXT; + +typedef struct VkMemoryToImageCopyEXT { + VkStructureType sType; + const void* pNext; + const void* pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkMemoryToImageCopyEXT; + +typedef struct VkImageToMemoryCopyEXT { + VkStructureType sType; + const void* pNext; + void* pHostPointer; + uint32_t memoryRowLength; + uint32_t memoryImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkImageToMemoryCopyEXT; + +typedef struct VkCopyMemoryToImageInfoEXT { + VkStructureType sType; + const void* pNext; + VkHostImageCopyFlagsEXT flags; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkMemoryToImageCopyEXT* pRegions; +} VkCopyMemoryToImageInfoEXT; + +typedef struct VkCopyImageToMemoryInfoEXT { + VkStructureType sType; + const void* pNext; + VkHostImageCopyFlagsEXT flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + uint32_t regionCount; + const VkImageToMemoryCopyEXT* pRegions; +} VkCopyImageToMemoryInfoEXT; + +typedef struct VkCopyImageToImageInfoEXT { + VkStructureType sType; + const void* pNext; + VkHostImageCopyFlagsEXT flags; + VkImage srcImage; + VkImageLayout srcImageLayout; + VkImage dstImage; + VkImageLayout dstImageLayout; + uint32_t regionCount; + const VkImageCopy2* pRegions; +} VkCopyImageToImageInfoEXT; + +typedef struct VkHostImageLayoutTransitionInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; + VkImageLayout oldLayout; + VkImageLayout newLayout; + VkImageSubresourceRange subresourceRange; +} VkHostImageLayoutTransitionInfoEXT; + +typedef struct VkSubresourceHostMemcpySizeEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize size; +} VkSubresourceHostMemcpySizeEXT; + +typedef struct VkHostImageCopyDevicePerformanceQueryEXT { + VkStructureType sType; + void* pNext; + VkBool32 optimalDeviceAccess; + VkBool32 identicalMemoryLayout; +} VkHostImageCopyDevicePerformanceQueryEXT; + +typedef VkSubresourceLayout2KHR VkSubresourceLayout2EXT; + +typedef VkImageSubresource2KHR VkImageSubresource2EXT; + +typedef VkResult ( *PFN_vkCopyMemoryToImageEXT)(VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo); +typedef VkResult ( *PFN_vkCopyImageToMemoryEXT)(VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo); +typedef VkResult ( *PFN_vkCopyImageToImageEXT)(VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo); +typedef VkResult ( *PFN_vkTransitionImageLayoutEXT)(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT* pTransitions); +typedef void ( *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout); +# 14281 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderBufferFloat16Atomics; + VkBool32 shaderBufferFloat16AtomicAdd; + VkBool32 shaderBufferFloat16AtomicMinMax; + VkBool32 shaderBufferFloat32AtomicMinMax; + VkBool32 shaderBufferFloat64AtomicMinMax; + VkBool32 shaderSharedFloat16Atomics; + VkBool32 shaderSharedFloat16AtomicAdd; + VkBool32 shaderSharedFloat16AtomicMinMax; + VkBool32 shaderSharedFloat32AtomicMinMax; + VkBool32 shaderSharedFloat64AtomicMinMax; + VkBool32 shaderImageFloat32AtomicMinMax; + VkBool32 sparseImageFloat32AtomicMinMax; +} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; +# 14305 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkPresentScalingFlagBitsEXT { + VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = 0x00000001, + VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = 0x00000002, + VK_PRESENT_SCALING_STRETCH_BIT_EXT = 0x00000004, + VK_PRESENT_SCALING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentScalingFlagBitsEXT; +typedef VkFlags VkPresentScalingFlagsEXT; + +typedef enum VkPresentGravityFlagBitsEXT { + VK_PRESENT_GRAVITY_MIN_BIT_EXT = 0x00000001, + VK_PRESENT_GRAVITY_MAX_BIT_EXT = 0x00000002, + VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = 0x00000004, + VK_PRESENT_GRAVITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkPresentGravityFlagBitsEXT; +typedef VkFlags VkPresentGravityFlagsEXT; +typedef struct VkSurfacePresentModeEXT { + VkStructureType sType; + void* pNext; + VkPresentModeKHR presentMode; +} VkSurfacePresentModeEXT; + +typedef struct VkSurfacePresentScalingCapabilitiesEXT { + VkStructureType sType; + void* pNext; + VkPresentScalingFlagsEXT supportedPresentScaling; + VkPresentGravityFlagsEXT supportedPresentGravityX; + VkPresentGravityFlagsEXT supportedPresentGravityY; + VkExtent2D minScaledImageExtent; + VkExtent2D maxScaledImageExtent; +} VkSurfacePresentScalingCapabilitiesEXT; + +typedef struct VkSurfacePresentModeCompatibilityEXT { + VkStructureType sType; + void* pNext; + uint32_t presentModeCount; + VkPresentModeKHR* pPresentModes; +} VkSurfacePresentModeCompatibilityEXT; + + + + + + + +typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 swapchainMaintenance1; +} VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT; + +typedef struct VkSwapchainPresentFenceInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkFence* pFences; +} VkSwapchainPresentFenceInfoEXT; + +typedef struct VkSwapchainPresentModesCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t presentModeCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModesCreateInfoEXT; + +typedef struct VkSwapchainPresentModeInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t swapchainCount; + const VkPresentModeKHR* pPresentModes; +} VkSwapchainPresentModeInfoEXT; + +typedef struct VkSwapchainPresentScalingCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkPresentScalingFlagsEXT scalingBehavior; + VkPresentGravityFlagsEXT presentGravityX; + VkPresentGravityFlagsEXT presentGravityY; +} VkSwapchainPresentScalingCreateInfoEXT; + +typedef struct VkReleaseSwapchainImagesInfoEXT { + VkStructureType sType; + const void* pNext; + VkSwapchainKHR swapchain; + uint32_t imageIndexCount; + const uint32_t* pImageIndices; +} VkReleaseSwapchainImagesInfoEXT; + +typedef VkResult ( *PFN_vkReleaseSwapchainImagesEXT)(VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); +# 14405 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; + + + + + +typedef struct VkIndirectCommandsLayoutNV_T *VkIndirectCommandsLayoutNV; + + + +typedef enum VkIndirectCommandsTokenTypeNV { + VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV = 1000428003, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV = 1000428004, + VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkIndirectCommandsTokenTypeNV; + +typedef enum VkIndirectStateFlagBitsNV { + VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001, + VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkIndirectStateFlagBitsNV; +typedef VkFlags VkIndirectStateFlagsNV; + +typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV { + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004, + VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkIndirectCommandsLayoutUsageFlagBitsNV; +typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t maxGraphicsShaderGroupCount; + uint32_t maxIndirectSequenceCount; + uint32_t maxIndirectCommandsTokenCount; + uint32_t maxIndirectCommandsStreamCount; + uint32_t maxIndirectCommandsTokenOffset; + uint32_t maxIndirectCommandsStreamStride; + uint32_t minSequencesCountBufferOffsetAlignment; + uint32_t minSequencesIndexBufferOffsetAlignment; + uint32_t minIndirectCommandsBufferOffsetAlignment; +} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; + +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 deviceGeneratedCommands; +} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; + +typedef struct VkGraphicsShaderGroupCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + const VkPipelineVertexInputStateCreateInfo* pVertexInputState; + const VkPipelineTessellationStateCreateInfo* pTessellationState; +} VkGraphicsShaderGroupCreateInfoNV; + +typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t groupCount; + const VkGraphicsShaderGroupCreateInfoNV* pGroups; + uint32_t pipelineCount; + const VkPipeline* pPipelines; +} VkGraphicsPipelineShaderGroupsCreateInfoNV; + +typedef struct VkBindShaderGroupIndirectCommandNV { + uint32_t groupIndex; +} VkBindShaderGroupIndirectCommandNV; + +typedef struct VkBindIndexBufferIndirectCommandNV { + VkDeviceAddress bufferAddress; + uint32_t size; + VkIndexType indexType; +} VkBindIndexBufferIndirectCommandNV; + +typedef struct VkBindVertexBufferIndirectCommandNV { + VkDeviceAddress bufferAddress; + uint32_t size; + uint32_t stride; +} VkBindVertexBufferIndirectCommandNV; + +typedef struct VkSetStateFlagsIndirectCommandNV { + uint32_t data; +} VkSetStateFlagsIndirectCommandNV; + +typedef struct VkIndirectCommandsStreamNV { + VkBuffer buffer; + VkDeviceSize offset; +} VkIndirectCommandsStreamNV; + +typedef struct VkIndirectCommandsLayoutTokenNV { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsTokenTypeNV tokenType; + uint32_t stream; + uint32_t offset; + uint32_t vertexBindingUnit; + VkBool32 vertexDynamicStride; + VkPipelineLayout pushconstantPipelineLayout; + VkShaderStageFlags pushconstantShaderStageFlags; + uint32_t pushconstantOffset; + uint32_t pushconstantSize; + VkIndirectStateFlagsNV indirectStateFlags; + uint32_t indexTypeCount; + const VkIndexType* pIndexTypes; + const uint32_t* pIndexTypeValues; +} VkIndirectCommandsLayoutTokenNV; + +typedef struct VkIndirectCommandsLayoutCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkIndirectCommandsLayoutUsageFlagsNV flags; + VkPipelineBindPoint pipelineBindPoint; + uint32_t tokenCount; + const VkIndirectCommandsLayoutTokenNV* pTokens; + uint32_t streamCount; + const uint32_t* pStreamStrides; +} VkIndirectCommandsLayoutCreateInfoNV; + +typedef struct VkGeneratedCommandsInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; + VkIndirectCommandsLayoutNV indirectCommandsLayout; + uint32_t streamCount; + const VkIndirectCommandsStreamNV* pStreams; + uint32_t sequencesCount; + VkBuffer preprocessBuffer; + VkDeviceSize preprocessOffset; + VkDeviceSize preprocessSize; + VkBuffer sequencesCountBuffer; + VkDeviceSize sequencesCountOffset; + VkBuffer sequencesIndexBuffer; + VkDeviceSize sequencesIndexOffset; +} VkGeneratedCommandsInfoNV; + +typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; + VkIndirectCommandsLayoutNV indirectCommandsLayout; + uint32_t maxSequencesCount; +} VkGeneratedCommandsMemoryRequirementsInfoNV; + +typedef void ( *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +typedef void ( *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); +typedef void ( *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex); +typedef VkResult ( *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); +typedef void ( *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); +# 14607 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 inheritedViewportScissor2D; +} VkPhysicalDeviceInheritedViewportScissorFeaturesNV; + +typedef struct VkCommandBufferInheritanceViewportScissorInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 viewportScissor2D; + uint32_t viewportDepthCount; + const VkViewport* pViewportDepths; +} VkCommandBufferInheritanceViewportScissorInfoNV; + + + + + + + +typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 texelBufferAlignment; +} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; + +typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; + + + + + + + +typedef struct VkRenderPassTransformBeginInfoQCOM { + VkStructureType sType; + void* pNext; + VkSurfaceTransformFlagBitsKHR transform; +} VkRenderPassTransformBeginInfoQCOM; + +typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM { + VkStructureType sType; + void* pNext; + VkSurfaceTransformFlagBitsKHR transform; + VkRect2D renderArea; +} VkCommandBufferInheritanceRenderPassTransformInfoQCOM; +# 14661 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkDepthBiasRepresentationEXT { + VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT = 0, + VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT = 1, + VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT = 2, + VK_DEPTH_BIAS_REPRESENTATION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDepthBiasRepresentationEXT; +typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthBiasControl; + VkBool32 leastRepresentableValueForceUnormRepresentation; + VkBool32 floatRepresentation; + VkBool32 depthBiasExact; +} VkPhysicalDeviceDepthBiasControlFeaturesEXT; + +typedef struct VkDepthBiasInfoEXT { + VkStructureType sType; + const void* pNext; + float depthBiasConstantFactor; + float depthBiasClamp; + float depthBiasSlopeFactor; +} VkDepthBiasInfoEXT; + +typedef struct VkDepthBiasRepresentationInfoEXT { + VkStructureType sType; + const void* pNext; + VkDepthBiasRepresentationEXT depthBiasRepresentation; + VkBool32 depthBiasExact; +} VkDepthBiasRepresentationInfoEXT; + +typedef void ( *PFN_vkCmdSetDepthBias2EXT)(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo); +# 14705 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkDeviceMemoryReportEventTypeEXT { + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4, + VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceMemoryReportEventTypeEXT; +typedef VkFlags VkDeviceMemoryReportFlagsEXT; +typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 deviceMemoryReport; +} VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; + +typedef struct VkDeviceMemoryReportCallbackDataEXT { + VkStructureType sType; + void* pNext; + VkDeviceMemoryReportFlagsEXT flags; + VkDeviceMemoryReportEventTypeEXT type; + uint64_t memoryObjectId; + VkDeviceSize size; + VkObjectType objectType; + uint64_t objectHandle; + uint32_t heapIndex; +} VkDeviceMemoryReportCallbackDataEXT; + +typedef void ( *PFN_vkDeviceMemoryReportCallbackEXT)( + const VkDeviceMemoryReportCallbackDataEXT* pCallbackData, + void* pUserData); + +typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceMemoryReportFlagsEXT flags; + PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback; + void* pUserData; +} VkDeviceDeviceMemoryReportCreateInfoEXT; + + + + + + + +typedef VkResult ( *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display); +typedef VkResult ( *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display); +# 14771 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceRobustness2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 robustBufferAccess2; + VkBool32 robustImageAccess2; + VkBool32 nullDescriptor; +} VkPhysicalDeviceRobustness2FeaturesEXT; + +typedef struct VkPhysicalDeviceRobustness2PropertiesEXT { + VkStructureType sType; + void* pNext; + VkDeviceSize robustStorageBufferAccessSizeAlignment; + VkDeviceSize robustUniformBufferAccessSizeAlignment; +} VkPhysicalDeviceRobustness2PropertiesEXT; + + + + + + + +typedef struct VkSamplerCustomBorderColorCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkClearColorValue customBorderColor; + VkFormat format; +} VkSamplerCustomBorderColorCreateInfoEXT; + +typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxCustomBorderColorSamplers; +} VkPhysicalDeviceCustomBorderColorPropertiesEXT; + +typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 customBorderColors; + VkBool32 customBorderColorWithoutFormat; +} VkPhysicalDeviceCustomBorderColorFeaturesEXT; +# 14824 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDevicePresentBarrierFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrier; +} VkPhysicalDevicePresentBarrierFeaturesNV; + +typedef struct VkSurfaceCapabilitiesPresentBarrierNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrierSupported; +} VkSurfaceCapabilitiesPresentBarrierNV; + +typedef struct VkSwapchainPresentBarrierCreateInfoNV { + VkStructureType sType; + void* pNext; + VkBool32 presentBarrierEnable; +} VkSwapchainPresentBarrierCreateInfoNV; + + + + + +typedef VkPrivateDataSlot VkPrivateDataSlotEXT; + + + +typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT; + +typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT; + +typedef VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT; + +typedef VkPrivateDataSlotCreateInfo VkPrivateDataSlotCreateInfoEXT; + +typedef VkResult ( *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); +typedef void ( *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); +typedef void ( *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); +# 14895 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT; +# 14904 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkDeviceDiagnosticsConfigFlagBitsNV { + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004, + VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV = 0x00000008, + VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkDeviceDiagnosticsConfigFlagBitsNV; +typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV; +typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 diagnosticsConfig; +} VkPhysicalDeviceDiagnosticsConfigFeaturesNV; + +typedef struct VkDeviceDiagnosticsConfigCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceDiagnosticsConfigFlagsNV flags; +} VkDeviceDiagnosticsConfigCreateInfoNV; +# 14934 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkCudaModuleNV_T *VkCudaModuleNV; +typedef struct VkCudaFunctionNV_T *VkCudaFunctionNV; + + +typedef struct VkCudaModuleCreateInfoNV { + VkStructureType sType; + const void* pNext; + size_t dataSize; + const void* pData; +} VkCudaModuleCreateInfoNV; + +typedef struct VkCudaFunctionCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkCudaModuleNV module; + const char* pName; +} VkCudaFunctionCreateInfoNV; + +typedef struct VkCudaLaunchInfoNV { + VkStructureType sType; + const void* pNext; + VkCudaFunctionNV function; + uint32_t gridDimX; + uint32_t gridDimY; + uint32_t gridDimZ; + uint32_t blockDimX; + uint32_t blockDimY; + uint32_t blockDimZ; + uint32_t sharedMemBytes; + size_t paramCount; + const void* const * pParams; + size_t extraCount; + const void* const * pExtras; +} VkCudaLaunchInfoNV; + +typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 cudaKernelLaunchFeatures; +} VkPhysicalDeviceCudaKernelLaunchFeaturesNV; + +typedef struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV { + VkStructureType sType; + void* pNext; + uint32_t computeCapabilityMinor; + uint32_t computeCapabilityMajor; +} VkPhysicalDeviceCudaKernelLaunchPropertiesNV; + +typedef VkResult ( *PFN_vkCreateCudaModuleNV)(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule); +typedef VkResult ( *PFN_vkGetCudaModuleCacheNV)(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData); +typedef VkResult ( *PFN_vkCreateCudaFunctionNV)(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction); +typedef void ( *PFN_vkDestroyCudaModuleNV)(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkDestroyCudaFunctionNV)(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo); +# 15028 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkQueryLowLatencySupportNV { + VkStructureType sType; + const void* pNext; + void* pQueriedLowLatencyData; +} VkQueryLowLatencySupportNV; + + + + + +typedef struct VkAccelerationStructureKHR_T *VkAccelerationStructureKHR; + + +typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 combinedImageSamplerDescriptorSingleArray; + VkBool32 bufferlessPushDescriptors; + VkBool32 allowSamplerImageViewPostSubmitCreation; + VkDeviceSize descriptorBufferOffsetAlignment; + uint32_t maxDescriptorBufferBindings; + uint32_t maxResourceDescriptorBufferBindings; + uint32_t maxSamplerDescriptorBufferBindings; + uint32_t maxEmbeddedImmutableSamplerBindings; + uint32_t maxEmbeddedImmutableSamplers; + size_t bufferCaptureReplayDescriptorDataSize; + size_t imageCaptureReplayDescriptorDataSize; + size_t imageViewCaptureReplayDescriptorDataSize; + size_t samplerCaptureReplayDescriptorDataSize; + size_t accelerationStructureCaptureReplayDescriptorDataSize; + size_t samplerDescriptorSize; + size_t combinedImageSamplerDescriptorSize; + size_t sampledImageDescriptorSize; + size_t storageImageDescriptorSize; + size_t uniformTexelBufferDescriptorSize; + size_t robustUniformTexelBufferDescriptorSize; + size_t storageTexelBufferDescriptorSize; + size_t robustStorageTexelBufferDescriptorSize; + size_t uniformBufferDescriptorSize; + size_t robustUniformBufferDescriptorSize; + size_t storageBufferDescriptorSize; + size_t robustStorageBufferDescriptorSize; + size_t inputAttachmentDescriptorSize; + size_t accelerationStructureDescriptorSize; + VkDeviceSize maxSamplerDescriptorBufferRange; + VkDeviceSize maxResourceDescriptorBufferRange; + VkDeviceSize samplerDescriptorBufferAddressSpaceSize; + VkDeviceSize resourceDescriptorBufferAddressSpaceSize; + VkDeviceSize descriptorBufferAddressSpaceSize; +} VkPhysicalDeviceDescriptorBufferPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { + VkStructureType sType; + void* pNext; + size_t combinedImageSamplerDensityMapDescriptorSize; +} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; + +typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 descriptorBuffer; + VkBool32 descriptorBufferCaptureReplay; + VkBool32 descriptorBufferImageLayoutIgnored; + VkBool32 descriptorBufferPushDescriptors; +} VkPhysicalDeviceDescriptorBufferFeaturesEXT; + +typedef struct VkDescriptorAddressInfoEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddress address; + VkDeviceSize range; + VkFormat format; +} VkDescriptorAddressInfoEXT; + +typedef struct VkDescriptorBufferBindingInfoEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddress address; + VkBufferUsageFlags usage; +} VkDescriptorBufferBindingInfoEXT; + +typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT { + VkStructureType sType; + void* pNext; + VkBuffer buffer; +} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; + +typedef union VkDescriptorDataEXT { + const VkSampler* pSampler; + const VkDescriptorImageInfo* pCombinedImageSampler; + const VkDescriptorImageInfo* pInputAttachmentImage; + const VkDescriptorImageInfo* pSampledImage; + const VkDescriptorImageInfo* pStorageImage; + const VkDescriptorAddressInfoEXT* pUniformTexelBuffer; + const VkDescriptorAddressInfoEXT* pStorageTexelBuffer; + const VkDescriptorAddressInfoEXT* pUniformBuffer; + const VkDescriptorAddressInfoEXT* pStorageBuffer; + VkDeviceAddress accelerationStructure; +} VkDescriptorDataEXT; + +typedef struct VkDescriptorGetInfoEXT { + VkStructureType sType; + const void* pNext; + VkDescriptorType type; + VkDescriptorDataEXT data; +} VkDescriptorGetInfoEXT; + +typedef struct VkBufferCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkBuffer buffer; +} VkBufferCaptureDescriptorDataInfoEXT; + +typedef struct VkImageCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkImage image; +} VkImageCaptureDescriptorDataInfoEXT; + +typedef struct VkImageViewCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkImageView imageView; +} VkImageViewCaptureDescriptorDataInfoEXT; + +typedef struct VkSamplerCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkSampler sampler; +} VkSamplerCaptureDescriptorDataInfoEXT; + +typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT { + VkStructureType sType; + const void* pNext; + const void* opaqueCaptureDescriptorData; +} VkOpaqueCaptureDescriptorDataCreateInfoEXT; + +typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR accelerationStructure; + VkAccelerationStructureNV accelerationStructureNV; +} VkAccelerationStructureCaptureDescriptorDataInfoEXT; + +typedef void ( *PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); +typedef void ( *PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); +typedef void ( *PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); +typedef void ( *PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos); +typedef void ( *PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); +typedef void ( *PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); +typedef VkResult ( *PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult ( *PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult ( *PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult ( *PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData); +typedef VkResult ( *PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); +# 15254 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkGraphicsPipelineLibraryFlagBitsEXT { + VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0x00000001, + VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 0x00000002, + VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 0x00000004, + VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 0x00000008, + VK_GRAPHICS_PIPELINE_LIBRARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkGraphicsPipelineLibraryFlagBitsEXT; +typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT; +typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 graphicsPipelineLibrary; +} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; + +typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 graphicsPipelineLibraryFastLinking; + VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration; +} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; + +typedef struct VkGraphicsPipelineLibraryCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkGraphicsPipelineLibraryFlagsEXT flags; +} VkGraphicsPipelineLibraryCreateInfoEXT; + + + + + + + +typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { + VkStructureType sType; + void* pNext; + VkBool32 shaderEarlyAndLateFragmentTests; +} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; +# 15300 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkFragmentShadingRateTypeNV { + VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0, + VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1, + VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkFragmentShadingRateTypeNV; + +typedef enum VkFragmentShadingRateNV { + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9, + VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10, + VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11, + VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12, + VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13, + VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14, + VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15, + VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF +} VkFragmentShadingRateNV; +typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 fragmentShadingRateEnums; + VkBool32 supersampleFragmentShadingRates; + VkBool32 noInvocationFragmentShadingRates; +} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; + +typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV { + VkStructureType sType; + void* pNext; + VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; +} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; + +typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkFragmentShadingRateTypeNV shadingRateType; + VkFragmentShadingRateNV shadingRate; + VkFragmentShadingRateCombinerOpKHR combinerOps[2]; +} VkPipelineFragmentShadingRateEnumStateCreateInfoNV; + +typedef void ( *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); +# 15358 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkAccelerationStructureMotionInstanceTypeNV { + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0, + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1, + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2, + VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkAccelerationStructureMotionInstanceTypeNV; +typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV; +typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV; +typedef union VkDeviceOrHostAddressConstKHR { + VkDeviceAddress deviceAddress; + const void* hostAddress; +} VkDeviceOrHostAddressConstKHR; + +typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR vertexData; +} VkAccelerationStructureGeometryMotionTrianglesDataNV; + +typedef struct VkAccelerationStructureMotionInfoNV { + VkStructureType sType; + const void* pNext; + uint32_t maxInstances; + VkAccelerationStructureMotionInfoFlagsNV flags; +} VkAccelerationStructureMotionInfoNV; + +typedef struct VkAccelerationStructureMatrixMotionInstanceNV { + VkTransformMatrixKHR transformT0; + VkTransformMatrixKHR transformT1; + uint32_t instanceCustomIndex:24; + uint32_t mask:8; + uint32_t instanceShaderBindingTableRecordOffset:24; + VkGeometryInstanceFlagsKHR flags:8; + uint64_t accelerationStructureReference; +} VkAccelerationStructureMatrixMotionInstanceNV; + +typedef struct VkSRTDataNV { + float sx; + float a; + float b; + float pvx; + float sy; + float c; + float pvy; + float sz; + float pvz; + float qx; + float qy; + float qz; + float qw; + float tx; + float ty; + float tz; +} VkSRTDataNV; + +typedef struct VkAccelerationStructureSRTMotionInstanceNV { + VkSRTDataNV transformT0; + VkSRTDataNV transformT1; + uint32_t instanceCustomIndex:24; + uint32_t mask:8; + uint32_t instanceShaderBindingTableRecordOffset:24; + VkGeometryInstanceFlagsKHR flags:8; + uint64_t accelerationStructureReference; +} VkAccelerationStructureSRTMotionInstanceNV; + +typedef union VkAccelerationStructureMotionInstanceDataNV { + VkAccelerationStructureInstanceKHR staticInstance; + VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; + VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance; +} VkAccelerationStructureMotionInstanceDataNV; + +typedef struct VkAccelerationStructureMotionInstanceNV { + VkAccelerationStructureMotionInstanceTypeNV type; + VkAccelerationStructureMotionInstanceFlagsNV flags; + VkAccelerationStructureMotionInstanceDataNV data; +} VkAccelerationStructureMotionInstanceNV; + +typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingMotionBlur; + VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect; +} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV; + + + + + + + +typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 ycbcr2plane444Formats; +} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; + + + + + + + +typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMapDeferred; +} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; + +typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 subsampledLoads; + VkBool32 subsampledCoarseReconstructionEarlyAccess; + uint32_t maxSubsampledArrayLayers; + uint32_t maxDescriptorSetSubsampledSamplers; +} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; + + + + + + + +typedef struct VkCopyCommandTransformInfoQCOM { + VkStructureType sType; + const void* pNext; + VkSurfaceTransformFlagBitsKHR transform; +} VkCopyCommandTransformInfoQCOM; + + + + + + + +typedef VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessFeaturesEXT; +# 15502 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkImageCompressionFlagBitsEXT { + VK_IMAGE_COMPRESSION_DEFAULT_EXT = 0, + VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = 0x00000001, + VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT = 0x00000002, + VK_IMAGE_COMPRESSION_DISABLED_EXT = 0x00000004, + VK_IMAGE_COMPRESSION_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkImageCompressionFlagBitsEXT; +typedef VkFlags VkImageCompressionFlagsEXT; + +typedef enum VkImageCompressionFixedRateFlagBitsEXT { + VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT = 0, + VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT = 0x00000001, + VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT = 0x00000002, + VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT = 0x00000004, + VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT = 0x00000008, + VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT = 0x00000010, + VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT = 0x00000020, + VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT = 0x00000040, + VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT = 0x00000080, + VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT = 0x00000100, + VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT = 0x00000200, + VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT = 0x00000400, + VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT = 0x00000800, + VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT = 0x00001000, + VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT = 0x00002000, + VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT = 0x00004000, + VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT = 0x00008000, + VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT = 0x00010000, + VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT = 0x00020000, + VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT = 0x00040000, + VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT = 0x00080000, + VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT = 0x00100000, + VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT = 0x00200000, + VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT = 0x00400000, + VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT = 0x00800000, + VK_IMAGE_COMPRESSION_FIXED_RATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkImageCompressionFixedRateFlagBitsEXT; +typedef VkFlags VkImageCompressionFixedRateFlagsEXT; +typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageCompressionControl; +} VkPhysicalDeviceImageCompressionControlFeaturesEXT; + +typedef struct VkImageCompressionControlEXT { + VkStructureType sType; + const void* pNext; + VkImageCompressionFlagsEXT flags; + uint32_t compressionControlPlaneCount; + VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags; +} VkImageCompressionControlEXT; + +typedef struct VkImageCompressionPropertiesEXT { + VkStructureType sType; + void* pNext; + VkImageCompressionFlagsEXT imageCompressionFlags; + VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; +} VkImageCompressionPropertiesEXT; + + + + + + + +typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 attachmentFeedbackLoopLayout; +} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; + + + + + + + +typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 formatA4R4G4B4; + VkBool32 formatA4B4G4R4; +} VkPhysicalDevice4444FormatsFeaturesEXT; +# 15593 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkDeviceFaultAddressTypeEXT { + VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0, + VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1, + VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2, + VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5, + VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6, + VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceFaultAddressTypeEXT; + +typedef enum VkDeviceFaultVendorBinaryHeaderVersionEXT { + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1, + VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceFaultVendorBinaryHeaderVersionEXT; +typedef struct VkPhysicalDeviceFaultFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 deviceFault; + VkBool32 deviceFaultVendorBinary; +} VkPhysicalDeviceFaultFeaturesEXT; + +typedef struct VkDeviceFaultCountsEXT { + VkStructureType sType; + void* pNext; + uint32_t addressInfoCount; + uint32_t vendorInfoCount; + VkDeviceSize vendorBinarySize; +} VkDeviceFaultCountsEXT; + +typedef struct VkDeviceFaultAddressInfoEXT { + VkDeviceFaultAddressTypeEXT addressType; + VkDeviceAddress reportedAddress; + VkDeviceSize addressPrecision; +} VkDeviceFaultAddressInfoEXT; + +typedef struct VkDeviceFaultVendorInfoEXT { + char description[256U]; + uint64_t vendorFaultCode; + uint64_t vendorFaultData; +} VkDeviceFaultVendorInfoEXT; + +typedef struct VkDeviceFaultInfoEXT { + VkStructureType sType; + void* pNext; + char description[256U]; + VkDeviceFaultAddressInfoEXT* pAddressInfos; + VkDeviceFaultVendorInfoEXT* pVendorInfos; + void* pVendorBinaryData; +} VkDeviceFaultInfoEXT; + +typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT { + uint32_t headerSize; + VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion; + uint32_t vendorID; + uint32_t deviceID; + uint32_t driverVersion; + uint8_t pipelineCacheUUID[16U]; + uint32_t applicationNameOffset; + uint32_t applicationVersion; + uint32_t engineNameOffset; + uint32_t engineVersion; + uint32_t apiVersion; +} VkDeviceFaultVendorBinaryHeaderVersionOneEXT; + +typedef VkResult ( *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); +# 15672 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 rasterizationOrderColorAttachmentAccess; + VkBool32 rasterizationOrderDepthAttachmentAccess; + VkBool32 rasterizationOrderStencilAttachmentAccess; +} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; + +typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; + + + + + + + +typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 formatRgba10x6WithoutYCbCrSampler; +} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; + + + + + + + +typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 mutableDescriptorType; +} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; + +typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; + +typedef struct VkMutableDescriptorTypeListEXT { + uint32_t descriptorTypeCount; + const VkDescriptorType* pDescriptorTypes; +} VkMutableDescriptorTypeListEXT; + +typedef VkMutableDescriptorTypeListEXT VkMutableDescriptorTypeListVALVE; + +typedef struct VkMutableDescriptorTypeCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t mutableDescriptorTypeListCount; + const VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists; +} VkMutableDescriptorTypeCreateInfoEXT; + +typedef VkMutableDescriptorTypeCreateInfoEXT VkMutableDescriptorTypeCreateInfoVALVE; + + + + + + + +typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 vertexInputDynamicState; +} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; + +typedef struct VkVertexInputBindingDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t binding; + uint32_t stride; + VkVertexInputRate inputRate; + uint32_t divisor; +} VkVertexInputBindingDescription2EXT; + +typedef struct VkVertexInputAttributeDescription2EXT { + VkStructureType sType; + void* pNext; + uint32_t location; + uint32_t binding; + VkFormat format; + uint32_t offset; +} VkVertexInputAttributeDescription2EXT; + +typedef void ( *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); +# 15770 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceDrmPropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 hasPrimary; + VkBool32 hasRender; + int64_t primaryMajor; + int64_t primaryMinor; + int64_t renderMajor; + int64_t renderMinor; +} VkPhysicalDeviceDrmPropertiesEXT; +# 15788 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkDeviceAddressBindingTypeEXT { + VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0, + VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1, + VK_DEVICE_ADDRESS_BINDING_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceAddressBindingTypeEXT; + +typedef enum VkDeviceAddressBindingFlagBitsEXT { + VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 0x00000001, + VK_DEVICE_ADDRESS_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkDeviceAddressBindingFlagBitsEXT; +typedef VkFlags VkDeviceAddressBindingFlagsEXT; +typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 reportAddressBinding; +} VkPhysicalDeviceAddressBindingReportFeaturesEXT; + +typedef struct VkDeviceAddressBindingCallbackDataEXT { + VkStructureType sType; + void* pNext; + VkDeviceAddressBindingFlagsEXT flags; + VkDeviceAddress baseAddress; + VkDeviceSize size; + VkDeviceAddressBindingTypeEXT bindingType; +} VkDeviceAddressBindingCallbackDataEXT; + + + + + + + +typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClipControl; +} VkPhysicalDeviceDepthClipControlFeaturesEXT; + +typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 negativeOneToOne; +} VkPipelineViewportDepthClipControlCreateInfoEXT; + + + + + + + +typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 primitiveTopologyListRestart; + VkBool32 primitiveTopologyPatchListRestart; +} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; + + + + + + + +typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI { + VkStructureType sType; + void* pNext; + VkRenderPass renderPass; + uint32_t subpass; +} VkSubpassShadingPipelineCreateInfoHUAWEI; + +typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 subpassShading; +} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI; + +typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI { + VkStructureType sType; + void* pNext; + uint32_t maxSubpassShadingWorkgroupSizeAspectRatio; +} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI; + +typedef VkResult ( *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize); +typedef void ( *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer); +# 15888 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 invocationMask; +} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; + +typedef void ( *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); +# 15906 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef void* VkRemoteAddressNV; + + +typedef struct VkMemoryGetRemoteAddressInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceMemory memory; + VkExternalMemoryHandleTypeFlagBits handleType; +} VkMemoryGetRemoteAddressInfoNV; + +typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 externalMemoryRDMA; +} VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; + +typedef VkResult ( *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress); +# 15936 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPipelineInfoKHR VkPipelineInfoEXT; + +typedef struct VkPipelinePropertiesIdentifierEXT { + VkStructureType sType; + void* pNext; + uint8_t pipelineIdentifier[16U]; +} VkPipelinePropertiesIdentifierEXT; + +typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelinePropertiesIdentifier; +} VkPhysicalDevicePipelinePropertiesFeaturesEXT; + +typedef VkResult ( *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); +# 15965 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkFrameBoundaryFlagBitsEXT { + VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT = 0x00000001, + VK_FRAME_BOUNDARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkFrameBoundaryFlagBitsEXT; +typedef VkFlags VkFrameBoundaryFlagsEXT; +typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 frameBoundary; +} VkPhysicalDeviceFrameBoundaryFeaturesEXT; + +typedef struct VkFrameBoundaryEXT { + VkStructureType sType; + const void* pNext; + VkFrameBoundaryFlagsEXT flags; + uint64_t frameID; + uint32_t imageCount; + const VkImage* pImages; + uint32_t bufferCount; + const VkBuffer* pBuffers; + uint64_t tagName; + size_t tagSize; + const void* pTag; +} VkFrameBoundaryEXT; + + + + + + + +typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 multisampledRenderToSingleSampled; +} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; + +typedef struct VkSubpassResolvePerformanceQueryEXT { + VkStructureType sType; + void* pNext; + VkBool32 optimal; +} VkSubpassResolvePerformanceQueryEXT; + +typedef struct VkMultisampledRenderToSingleSampledInfoEXT { + VkStructureType sType; + const void* pNext; + VkBool32 multisampledRenderToSingleSampledEnable; + VkSampleCountFlagBits rasterizationSamples; +} VkMultisampledRenderToSingleSampledInfoEXT; + + + + + + + +typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState2; + VkBool32 extendedDynamicState2LogicOp; + VkBool32 extendedDynamicState2PatchControlPoints; +} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; + +typedef void ( *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); +typedef void ( *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); +typedef void ( *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); +typedef void ( *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp); +typedef void ( *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); +# 16062 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 colorWriteEnable; +} VkPhysicalDeviceColorWriteEnableFeaturesEXT; + +typedef struct VkPipelineColorWriteCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t attachmentCount; + const VkBool32* pColorWriteEnables; +} VkPipelineColorWriteCreateInfoEXT; + +typedef void ( *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); +# 16089 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 primitivesGeneratedQuery; + VkBool32 primitivesGeneratedQueryWithRasterizerDiscard; + VkBool32 primitivesGeneratedQueryWithNonZeroStreams; +} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; +# 16104 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT; + +typedef VkQueueFamilyGlobalPriorityPropertiesKHR VkQueueFamilyGlobalPriorityPropertiesEXT; + + + + + + + +typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 minLod; +} VkPhysicalDeviceImageViewMinLodFeaturesEXT; + +typedef struct VkImageViewMinLodCreateInfoEXT { + VkStructureType sType; + const void* pNext; + float minLod; +} VkImageViewMinLodCreateInfoEXT; + + + + + + + +typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 multiDraw; +} VkPhysicalDeviceMultiDrawFeaturesEXT; + +typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxMultiDrawCount; +} VkPhysicalDeviceMultiDrawPropertiesEXT; + +typedef struct VkMultiDrawInfoEXT { + uint32_t firstVertex; + uint32_t vertexCount; +} VkMultiDrawInfoEXT; + +typedef struct VkMultiDrawIndexedInfoEXT { + uint32_t firstIndex; + uint32_t indexCount; + int32_t vertexOffset; +} VkMultiDrawIndexedInfoEXT; + +typedef void ( *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); +typedef void ( *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); +# 16182 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 image2DViewOf3D; + VkBool32 sampler2DViewOf3D; +} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT; + + + + + + + +typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageColorReadAccess; + VkBool32 shaderTileImageDepthReadAccess; + VkBool32 shaderTileImageStencilReadAccess; +} VkPhysicalDeviceShaderTileImageFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderTileImageCoherentReadAccelerated; + VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; + VkBool32 shaderTileImageReadFromHelperInvocation; +} VkPhysicalDeviceShaderTileImagePropertiesEXT; + + + + + +typedef struct VkMicromapEXT_T *VkMicromapEXT; + + + +typedef enum VkMicromapTypeEXT { + VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0, + + + + VK_MICROMAP_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkMicromapTypeEXT; + +typedef enum VkBuildMicromapModeEXT { + VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0, + VK_BUILD_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBuildMicromapModeEXT; + +typedef enum VkCopyMicromapModeEXT { + VK_COPY_MICROMAP_MODE_CLONE_EXT = 0, + VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1, + VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2, + VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3, + VK_COPY_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkCopyMicromapModeEXT; + +typedef enum VkOpacityMicromapFormatEXT { + VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, + VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, + VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF +} VkOpacityMicromapFormatEXT; + +typedef enum VkOpacityMicromapSpecialIndexEXT { + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, + VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_EXT = 0x7FFFFFFF +} VkOpacityMicromapSpecialIndexEXT; + +typedef enum VkAccelerationStructureCompatibilityKHR { + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1, + VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureCompatibilityKHR; + +typedef enum VkAccelerationStructureBuildTypeKHR { + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, + VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureBuildTypeKHR; + +typedef enum VkBuildMicromapFlagBitsEXT { + VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 0x00000001, + VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 0x00000002, + VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 0x00000004, + VK_BUILD_MICROMAP_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkBuildMicromapFlagBitsEXT; +typedef VkFlags VkBuildMicromapFlagsEXT; + +typedef enum VkMicromapCreateFlagBitsEXT { + VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000001, + VK_MICROMAP_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkMicromapCreateFlagBitsEXT; +typedef VkFlags VkMicromapCreateFlagsEXT; +typedef struct VkMicromapUsageEXT { + uint32_t count; + uint32_t subdivisionLevel; + uint32_t format; +} VkMicromapUsageEXT; + +typedef union VkDeviceOrHostAddressKHR { + VkDeviceAddress deviceAddress; + void* hostAddress; +} VkDeviceOrHostAddressKHR; + +typedef struct VkMicromapBuildInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapTypeEXT type; + VkBuildMicromapFlagsEXT flags; + VkBuildMicromapModeEXT mode; + VkMicromapEXT dstMicromap; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkDeviceOrHostAddressConstKHR data; + VkDeviceOrHostAddressKHR scratchData; + VkDeviceOrHostAddressConstKHR triangleArray; + VkDeviceSize triangleArrayStride; +} VkMicromapBuildInfoEXT; + +typedef struct VkMicromapCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapCreateFlagsEXT createFlags; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkMicromapTypeEXT type; + VkDeviceAddress deviceAddress; +} VkMicromapCreateInfoEXT; + +typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 micromap; + VkBool32 micromapCaptureReplay; + VkBool32 micromapHostCommands; +} VkPhysicalDeviceOpacityMicromapFeaturesEXT; + +typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxOpacity2StateSubdivisionLevel; + uint32_t maxOpacity4StateSubdivisionLevel; +} VkPhysicalDeviceOpacityMicromapPropertiesEXT; + +typedef struct VkMicromapVersionInfoEXT { + VkStructureType sType; + const void* pNext; + const uint8_t* pVersionData; +} VkMicromapVersionInfoEXT; + +typedef struct VkCopyMicromapToMemoryInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapEXT src; + VkDeviceOrHostAddressKHR dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapToMemoryInfoEXT; + +typedef struct VkCopyMemoryToMicromapInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; +} VkCopyMemoryToMicromapInfoEXT; + +typedef struct VkCopyMicromapInfoEXT { + VkStructureType sType; + const void* pNext; + VkMicromapEXT src; + VkMicromapEXT dst; + VkCopyMicromapModeEXT mode; +} VkCopyMicromapInfoEXT; + +typedef struct VkMicromapBuildSizesInfoEXT { + VkStructureType sType; + const void* pNext; + VkDeviceSize micromapSize; + VkDeviceSize buildScratchSize; + VkBool32 discardable; +} VkMicromapBuildSizesInfoEXT; + +typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT { + VkStructureType sType; + void* pNext; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexBuffer; + VkDeviceSize indexStride; + uint32_t baseTriangle; + uint32_t usageCountsCount; + const VkMicromapUsageEXT* pUsageCounts; + const VkMicromapUsageEXT* const* ppUsageCounts; + VkMicromapEXT micromap; +} VkAccelerationStructureTrianglesOpacityMicromapEXT; + +typedef struct VkMicromapTriangleEXT { + uint32_t dataOffset; + uint16_t subdivisionLevel; + uint16_t format; +} VkMicromapTriangleEXT; + +typedef VkResult ( *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); +typedef void ( *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult ( *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); +typedef VkResult ( *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); +typedef VkResult ( *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef VkResult ( *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef VkResult ( *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +typedef void ( *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); +typedef void ( *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); +typedef void ( *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); +typedef void ( *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void ( *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void ( *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); +# 16495 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI { + VkStructureType sType; + void* pNext; + VkBool32 clustercullingShader; + VkBool32 multiviewClusterCullingShader; +} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; + +typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI { + VkStructureType sType; + void* pNext; + uint32_t maxWorkGroupCount[3]; + uint32_t maxWorkGroupSize[3]; + uint32_t maxOutputClusterCount; + VkDeviceSize indirectBufferOffsetAlignment; +} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; + +typedef void ( *PFN_vkCmdDrawClusterHUAWEI)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void ( *PFN_vkCmdDrawClusterIndirectHUAWEI)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); +# 16532 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 borderColorSwizzle; + VkBool32 borderColorSwizzleFromImage; +} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; + +typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkComponentMapping components; + VkBool32 srgb; +} VkSamplerBorderColorComponentMappingCreateInfoEXT; + + + + + + + +typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pageableDeviceLocalMemory; +} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; + +typedef void ( *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority); +# 16572 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceShaderCorePropertiesARM { + VkStructureType sType; + void* pNext; + uint32_t pixelRate; + uint32_t texelRate; + uint32_t fmaRate; +} VkPhysicalDeviceShaderCorePropertiesARM; + + + + + + + +typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; + +typedef enum VkPhysicalDeviceSchedulingControlsFlagBitsARM { + VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001, + VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF +} VkPhysicalDeviceSchedulingControlsFlagBitsARM; +typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM { + VkStructureType sType; + void* pNext; + uint32_t shaderCoreCount; +} VkDeviceQueueShaderCoreControlCreateInfoARM; + +typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 schedulingControls; +} VkPhysicalDeviceSchedulingControlsFeaturesARM; + +typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM { + VkStructureType sType; + void* pNext; + VkPhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags; +} VkPhysicalDeviceSchedulingControlsPropertiesARM; +# 16617 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageSlicedViewOf3D; +} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; + +typedef struct VkImageViewSlicedCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t sliceOffset; + uint32_t sliceCount; +} VkImageViewSlicedCreateInfoEXT; + + + + + + + +typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { + VkStructureType sType; + void* pNext; + VkBool32 descriptorSetHostMapping; +} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; + +typedef struct VkDescriptorSetBindingReferenceVALVE { + VkStructureType sType; + const void* pNext; + VkDescriptorSetLayout descriptorSetLayout; + uint32_t binding; +} VkDescriptorSetBindingReferenceVALVE; + +typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE { + VkStructureType sType; + void* pNext; + size_t descriptorOffset; + uint32_t descriptorSize; +} VkDescriptorSetLayoutHostMappingInfoVALVE; + +typedef void ( *PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); +typedef void ( *PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void** ppData); +# 16676 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 depthClampZeroOne; +} VkPhysicalDeviceDepthClampZeroOneFeaturesEXT; + + + + + + + +typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 nonSeamlessCubeMap; +} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; + + + + + + + +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 fragmentDensityMapOffset; +} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; + +typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { + VkStructureType sType; + void* pNext; + VkExtent2D fragmentDensityOffsetGranularity; +} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; + +typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM { + VkStructureType sType; + const void* pNext; + uint32_t fragmentDensityOffsetCount; + const VkOffset2D* pFragmentDensityOffsets; +} VkSubpassFragmentDensityMapOffsetEndInfoQCOM; + + + + + + + +typedef struct VkCopyMemoryIndirectCommandNV { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize size; +} VkCopyMemoryIndirectCommandNV; + +typedef struct VkCopyMemoryToImageIndirectCommandNV { + VkDeviceAddress srcAddress; + uint32_t bufferRowLength; + uint32_t bufferImageHeight; + VkImageSubresourceLayers imageSubresource; + VkOffset3D imageOffset; + VkExtent3D imageExtent; +} VkCopyMemoryToImageIndirectCommandNV; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 indirectCopy; +} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV; + +typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV { + VkStructureType sType; + void* pNext; + VkQueueFlags supportedQueues; +} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV; + +typedef void ( *PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride); +typedef void ( *PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources); +# 16779 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef VkFlags64 VkMemoryDecompressionMethodFlagBitsNV; +static const VkMemoryDecompressionMethodFlagBitsNV VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0x00000001ULL; + +typedef VkFlags64 VkMemoryDecompressionMethodFlagsNV; +typedef struct VkDecompressMemoryRegionNV { + VkDeviceAddress srcAddress; + VkDeviceAddress dstAddress; + VkDeviceSize compressedSize; + VkDeviceSize decompressedSize; + VkMemoryDecompressionMethodFlagsNV decompressionMethod; +} VkDecompressMemoryRegionNV; + +typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 memoryDecompression; +} VkPhysicalDeviceMemoryDecompressionFeaturesNV; + +typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV { + VkStructureType sType; + void* pNext; + VkMemoryDecompressionMethodFlagsNV decompressionMethods; + uint64_t maxDecompressionIndirectCount; +} VkPhysicalDeviceMemoryDecompressionPropertiesNV; + +typedef void ( *PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); +typedef void ( *PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); +# 16825 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 deviceGeneratedCompute; + VkBool32 deviceGeneratedComputePipelines; + VkBool32 deviceGeneratedComputeCaptureReplay; +} VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; + +typedef struct VkComputePipelineIndirectBufferInfoNV { + VkStructureType sType; + const void* pNext; + VkDeviceAddress deviceAddress; + VkDeviceSize size; + VkDeviceAddress pipelineDeviceAddressCaptureReplay; +} VkComputePipelineIndirectBufferInfoNV; + +typedef struct VkPipelineIndirectDeviceAddressInfoNV { + VkStructureType sType; + const void* pNext; + VkPipelineBindPoint pipelineBindPoint; + VkPipeline pipeline; +} VkPipelineIndirectDeviceAddressInfoNV; + +typedef struct VkBindPipelineIndirectCommandNV { + VkDeviceAddress pipelineAddress; +} VkBindPipelineIndirectCommandNV; + +typedef void ( *PFN_vkGetPipelineIndirectMemoryRequirementsNV)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements); +typedef void ( *PFN_vkCmdUpdatePipelineIndirectBufferNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); +typedef VkDeviceAddress ( *PFN_vkGetPipelineIndirectDeviceAddressNV)(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo); +# 16877 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 linearColorAttachment; +} VkPhysicalDeviceLinearColorAttachmentFeaturesNV; +# 16895 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 imageCompressionControlSwapchain; +} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; + + + + + + + +typedef struct VkImageViewSampleWeightCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkOffset2D filterCenter; + VkExtent2D filterSize; + uint32_t numPhases; +} VkImageViewSampleWeightCreateInfoQCOM; + +typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 textureSampleWeighted; + VkBool32 textureBoxFilter; + VkBool32 textureBlockMatch; +} VkPhysicalDeviceImageProcessingFeaturesQCOM; + +typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM { + VkStructureType sType; + void* pNext; + uint32_t maxWeightFilterPhases; + VkExtent2D maxWeightFilterDimension; + VkExtent2D maxBlockMatchRegion; + VkExtent2D maxBoxFilterBlockSize; +} VkPhysicalDeviceImageProcessingPropertiesQCOM; + + + + + + + +typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 nestedCommandBuffer; + VkBool32 nestedCommandBufferRendering; + VkBool32 nestedCommandBufferSimultaneousUse; +} VkPhysicalDeviceNestedCommandBufferFeaturesEXT; + +typedef struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxCommandBufferNestingLevel; +} VkPhysicalDeviceNestedCommandBufferPropertiesEXT; + + + + + + + +typedef struct VkExternalMemoryAcquireUnmodifiedEXT { + VkStructureType sType; + const void* pNext; + VkBool32 acquireUnmodifiedMemory; +} VkExternalMemoryAcquireUnmodifiedEXT; + + + + + + + +typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 extendedDynamicState3TessellationDomainOrigin; + VkBool32 extendedDynamicState3DepthClampEnable; + VkBool32 extendedDynamicState3PolygonMode; + VkBool32 extendedDynamicState3RasterizationSamples; + VkBool32 extendedDynamicState3SampleMask; + VkBool32 extendedDynamicState3AlphaToCoverageEnable; + VkBool32 extendedDynamicState3AlphaToOneEnable; + VkBool32 extendedDynamicState3LogicOpEnable; + VkBool32 extendedDynamicState3ColorBlendEnable; + VkBool32 extendedDynamicState3ColorBlendEquation; + VkBool32 extendedDynamicState3ColorWriteMask; + VkBool32 extendedDynamicState3RasterizationStream; + VkBool32 extendedDynamicState3ConservativeRasterizationMode; + VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize; + VkBool32 extendedDynamicState3DepthClipEnable; + VkBool32 extendedDynamicState3SampleLocationsEnable; + VkBool32 extendedDynamicState3ColorBlendAdvanced; + VkBool32 extendedDynamicState3ProvokingVertexMode; + VkBool32 extendedDynamicState3LineRasterizationMode; + VkBool32 extendedDynamicState3LineStippleEnable; + VkBool32 extendedDynamicState3DepthClipNegativeOneToOne; + VkBool32 extendedDynamicState3ViewportWScalingEnable; + VkBool32 extendedDynamicState3ViewportSwizzle; + VkBool32 extendedDynamicState3CoverageToColorEnable; + VkBool32 extendedDynamicState3CoverageToColorLocation; + VkBool32 extendedDynamicState3CoverageModulationMode; + VkBool32 extendedDynamicState3CoverageModulationTableEnable; + VkBool32 extendedDynamicState3CoverageModulationTable; + VkBool32 extendedDynamicState3CoverageReductionMode; + VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable; + VkBool32 extendedDynamicState3ShadingRateImageEnable; +} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT; + +typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT { + VkStructureType sType; + void* pNext; + VkBool32 dynamicPrimitiveTopologyUnrestricted; +} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT; + +typedef struct VkColorBlendEquationEXT { + VkBlendFactor srcColorBlendFactor; + VkBlendFactor dstColorBlendFactor; + VkBlendOp colorBlendOp; + VkBlendFactor srcAlphaBlendFactor; + VkBlendFactor dstAlphaBlendFactor; + VkBlendOp alphaBlendOp; +} VkColorBlendEquationEXT; + +typedef struct VkColorBlendAdvancedEXT { + VkBlendOp advancedBlendOp; + VkBool32 srcPremultiplied; + VkBool32 dstPremultiplied; + VkBlendOverlapEXT blendOverlap; + VkBool32 clampResults; +} VkColorBlendAdvancedEXT; + +typedef void ( *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); +typedef void ( *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); +typedef void ( *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); +typedef void ( *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); +typedef void ( *PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); +typedef void ( *PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); +typedef void ( *PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); +typedef void ( *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); +typedef void ( *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); +typedef void ( *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); +typedef void ( *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); +typedef void ( *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream); +typedef void ( *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); +typedef void ( *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); +typedef void ( *PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); +typedef void ( *PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); +typedef void ( *PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); +typedef void ( *PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); +typedef void ( *PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); +typedef void ( *PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); +typedef void ( *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); +typedef void ( *PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); +typedef void ( *PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); +typedef void ( *PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); +typedef void ( *PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); +typedef void ( *PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); +typedef void ( *PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); +typedef void ( *PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); +typedef void ( *PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); +typedef void ( *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); +typedef void ( *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); +# 17205 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkSubpassMergeStatusEXT { + VK_SUBPASS_MERGE_STATUS_MERGED_EXT = 0, + VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT = 1, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT = 2, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT = 3, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT = 4, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT = 5, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT = 6, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT = 7, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT = 8, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT = 9, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT = 10, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT = 11, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT = 12, + VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT = 13, + VK_SUBPASS_MERGE_STATUS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkSubpassMergeStatusEXT; +typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 subpassMergeFeedback; +} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT; + +typedef struct VkRenderPassCreationControlEXT { + VkStructureType sType; + const void* pNext; + VkBool32 disallowMerging; +} VkRenderPassCreationControlEXT; + +typedef struct VkRenderPassCreationFeedbackInfoEXT { + uint32_t postMergeSubpassCount; +} VkRenderPassCreationFeedbackInfoEXT; + +typedef struct VkRenderPassCreationFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback; +} VkRenderPassCreationFeedbackCreateInfoEXT; + +typedef struct VkRenderPassSubpassFeedbackInfoEXT { + VkSubpassMergeStatusEXT subpassMergeStatus; + char description[256U]; + uint32_t postMergeIndex; +} VkRenderPassSubpassFeedbackInfoEXT; + +typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback; +} VkRenderPassSubpassFeedbackCreateInfoEXT; +# 17263 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkDirectDriverLoadingModeLUNARG { + VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0, + VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1, + VK_DIRECT_DRIVER_LOADING_MODE_MAX_ENUM_LUNARG = 0x7FFFFFFF +} VkDirectDriverLoadingModeLUNARG; +typedef VkFlags VkDirectDriverLoadingFlagsLUNARG; +typedef PFN_vkVoidFunction ( *PFN_vkGetInstanceProcAddrLUNARG)( + VkInstance instance, const char* pName); + +typedef struct VkDirectDriverLoadingInfoLUNARG { + VkStructureType sType; + void* pNext; + VkDirectDriverLoadingFlagsLUNARG flags; + PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr; +} VkDirectDriverLoadingInfoLUNARG; + +typedef struct VkDirectDriverLoadingListLUNARG { + VkStructureType sType; + void* pNext; + VkDirectDriverLoadingModeLUNARG mode; + uint32_t driverCount; + const VkDirectDriverLoadingInfoLUNARG* pDrivers; +} VkDirectDriverLoadingListLUNARG; +# 17294 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderModuleIdentifier; +} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT { + VkStructureType sType; + void* pNext; + uint8_t shaderModuleIdentifierAlgorithmUUID[16U]; +} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; + +typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT { + VkStructureType sType; + const void* pNext; + uint32_t identifierSize; + const uint8_t* pIdentifier; +} VkPipelineShaderStageModuleIdentifierCreateInfoEXT; + +typedef struct VkShaderModuleIdentifierEXT { + VkStructureType sType; + void* pNext; + uint32_t identifierSize; + uint8_t identifier[32U]; +} VkShaderModuleIdentifierEXT; + +typedef void ( *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); +typedef void ( *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); +# 17344 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkOpticalFlowSessionNV_T *VkOpticalFlowSessionNV; + + + +typedef enum VkOpticalFlowPerformanceLevelNV { + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3, + VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowPerformanceLevelNV; + +typedef enum VkOpticalFlowSessionBindingPointNV { + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8, + VK_OPTICAL_FLOW_SESSION_BINDING_POINT_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowSessionBindingPointNV; + +typedef enum VkOpticalFlowGridSizeFlagBitsNV { + VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_GRID_SIZE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowGridSizeFlagBitsNV; +typedef VkFlags VkOpticalFlowGridSizeFlagsNV; + +typedef enum VkOpticalFlowUsageFlagBitsNV { + VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV = 0, + VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 0x00000010, + VK_OPTICAL_FLOW_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowUsageFlagBitsNV; +typedef VkFlags VkOpticalFlowUsageFlagsNV; + +typedef enum VkOpticalFlowSessionCreateFlagBitsNV { + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 0x00000002, + VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 0x00000004, + VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 0x00000008, + VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 0x00000010, + VK_OPTICAL_FLOW_SESSION_CREATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowSessionCreateFlagBitsNV; +typedef VkFlags VkOpticalFlowSessionCreateFlagsNV; + +typedef enum VkOpticalFlowExecuteFlagBitsNV { + VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 0x00000001, + VK_OPTICAL_FLOW_EXECUTE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF +} VkOpticalFlowExecuteFlagBitsNV; +typedef VkFlags VkOpticalFlowExecuteFlagsNV; +typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 opticalFlow; +} VkPhysicalDeviceOpticalFlowFeaturesNV; + +typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV { + VkStructureType sType; + void* pNext; + VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes; + VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes; + VkBool32 hintSupported; + VkBool32 costSupported; + VkBool32 bidirectionalFlowSupported; + VkBool32 globalFlowSupported; + uint32_t minWidth; + uint32_t minHeight; + uint32_t maxWidth; + uint32_t maxHeight; + uint32_t maxNumRegionsOfInterest; +} VkPhysicalDeviceOpticalFlowPropertiesNV; + +typedef struct VkOpticalFlowImageFormatInfoNV { + VkStructureType sType; + const void* pNext; + VkOpticalFlowUsageFlagsNV usage; +} VkOpticalFlowImageFormatInfoNV; + +typedef struct VkOpticalFlowImageFormatPropertiesNV { + VkStructureType sType; + const void* pNext; + VkFormat format; +} VkOpticalFlowImageFormatPropertiesNV; + +typedef struct VkOpticalFlowSessionCreateInfoNV { + VkStructureType sType; + void* pNext; + uint32_t width; + uint32_t height; + VkFormat imageFormat; + VkFormat flowVectorFormat; + VkFormat costFormat; + VkOpticalFlowGridSizeFlagsNV outputGridSize; + VkOpticalFlowGridSizeFlagsNV hintGridSize; + VkOpticalFlowPerformanceLevelNV performanceLevel; + VkOpticalFlowSessionCreateFlagsNV flags; +} VkOpticalFlowSessionCreateInfoNV; + +typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV { + VkStructureType sType; + void* pNext; + uint32_t id; + uint32_t size; + const void* pPrivateData; +} VkOpticalFlowSessionCreatePrivateDataInfoNV; + +typedef struct VkOpticalFlowExecuteInfoNV { + VkStructureType sType; + void* pNext; + VkOpticalFlowExecuteFlagsNV flags; + uint32_t regionCount; + const VkRect2D* pRegions; +} VkOpticalFlowExecuteInfoNV; + +typedef VkResult ( *PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); +typedef VkResult ( *PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession); +typedef void ( *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); +typedef void ( *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); +# 17511 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 legacyDithering; +} VkPhysicalDeviceLegacyDitheringFeaturesEXT; + + + + + + + +typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineProtectedAccess; +} VkPhysicalDevicePipelineProtectedAccessFeaturesEXT; + + + + + +typedef struct VkShaderEXT_T *VkShaderEXT; + + + +typedef enum VkShaderCodeTypeEXT { + VK_SHADER_CODE_TYPE_BINARY_EXT = 0, + VK_SHADER_CODE_TYPE_SPIRV_EXT = 1, + VK_SHADER_CODE_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCodeTypeEXT; + +typedef enum VkShaderCreateFlagBitsEXT { + VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001, + VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002, + VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000004, + VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 0x00000008, + VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010, + VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, + VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, + VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF +} VkShaderCreateFlagBitsEXT; +typedef VkFlags VkShaderCreateFlagsEXT; +typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 shaderObject; +} VkPhysicalDeviceShaderObjectFeaturesEXT; + +typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT { + VkStructureType sType; + void* pNext; + uint8_t shaderBinaryUUID[16U]; + uint32_t shaderBinaryVersion; +} VkPhysicalDeviceShaderObjectPropertiesEXT; + +typedef struct VkShaderCreateInfoEXT { + VkStructureType sType; + const void* pNext; + VkShaderCreateFlagsEXT flags; + VkShaderStageFlagBits stage; + VkShaderStageFlags nextStage; + VkShaderCodeTypeEXT codeType; + size_t codeSize; + const void* pCode; + const char* pName; + uint32_t setLayoutCount; + const VkDescriptorSetLayout* pSetLayouts; + uint32_t pushConstantRangeCount; + const VkPushConstantRange* pPushConstantRanges; + const VkSpecializationInfo* pSpecializationInfo; +} VkShaderCreateInfoEXT; + +typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkShaderRequiredSubgroupSizeCreateInfoEXT; + +typedef VkResult ( *PFN_vkCreateShadersEXT)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); +typedef void ( *PFN_vkDestroyShaderEXT)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); +typedef VkResult ( *PFN_vkGetShaderBinaryDataEXT)(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); +typedef void ( *PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); +# 17622 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 tileProperties; +} VkPhysicalDeviceTilePropertiesFeaturesQCOM; + +typedef struct VkTilePropertiesQCOM { + VkStructureType sType; + void* pNext; + VkExtent3D tileSize; + VkExtent2D apronSize; + VkOffset2D origin; +} VkTilePropertiesQCOM; + +typedef VkResult ( *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties); +typedef VkResult ( *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); +# 17657 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceAmigoProfilingFeaturesSEC { + VkStructureType sType; + void* pNext; + VkBool32 amigoProfiling; +} VkPhysicalDeviceAmigoProfilingFeaturesSEC; + +typedef struct VkAmigoProfilingSubmitInfoSEC { + VkStructureType sType; + const void* pNext; + uint64_t firstDrawTimestamp; + uint64_t swapBufferTimestamp; +} VkAmigoProfilingSubmitInfoSEC; + + + + + + + +typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 multiviewPerViewViewports; +} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; +# 17689 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkRayTracingInvocationReorderModeNV { + VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = 0, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = 1, + VK_RAY_TRACING_INVOCATION_REORDER_MODE_MAX_ENUM_NV = 0x7FFFFFFF +} VkRayTracingInvocationReorderModeNV; +typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV { + VkStructureType sType; + void* pNext; + VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint; +} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV; + +typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingInvocationReorder; +} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV; + + + + + + + +typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 extendedSparseAddressSpace; +} VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; + +typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV { + VkStructureType sType; + void* pNext; + VkDeviceSize extendedSparseAddressSpaceSize; + VkImageUsageFlags extendedSparseImageUsageFlags; + VkBufferUsageFlags extendedSparseBufferUsageFlags; +} VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV; +# 17738 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM { + VkStructureType sType; + void* pNext; + VkBool32 shaderCoreBuiltins; +} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; + +typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { + VkStructureType sType; + void* pNext; + uint64_t shaderCoreMask; + uint32_t shaderCoreCount; + uint32_t shaderWarpsPerCore; +} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; + + + + + + + +typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 pipelineLibraryGroupHandles; +} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; + + + + + + + +typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 dynamicRenderingUnusedAttachments; +} VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; +# 17783 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkLatencyMarkerNV { + VK_LATENCY_MARKER_SIMULATION_START_NV = 0, + VK_LATENCY_MARKER_SIMULATION_END_NV = 1, + VK_LATENCY_MARKER_RENDERSUBMIT_START_NV = 2, + VK_LATENCY_MARKER_RENDERSUBMIT_END_NV = 3, + VK_LATENCY_MARKER_PRESENT_START_NV = 4, + VK_LATENCY_MARKER_PRESENT_END_NV = 5, + VK_LATENCY_MARKER_INPUT_SAMPLE_NV = 6, + VK_LATENCY_MARKER_TRIGGER_FLASH_NV = 7, + VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV = 8, + VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV = 9, + VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV = 10, + VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV = 11, + VK_LATENCY_MARKER_MAX_ENUM_NV = 0x7FFFFFFF +} VkLatencyMarkerNV; + +typedef enum VkOutOfBandQueueTypeNV { + VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV = 0, + VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV = 1, + VK_OUT_OF_BAND_QUEUE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF +} VkOutOfBandQueueTypeNV; +typedef struct VkLatencySleepModeInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 lowLatencyMode; + VkBool32 lowLatencyBoost; + uint32_t minimumIntervalUs; +} VkLatencySleepModeInfoNV; + +typedef struct VkLatencySleepInfoNV { + VkStructureType sType; + const void* pNext; + VkSemaphore signalSemaphore; + uint64_t value; +} VkLatencySleepInfoNV; + +typedef struct VkSetLatencyMarkerInfoNV { + VkStructureType sType; + const void* pNext; + uint64_t presentID; + VkLatencyMarkerNV marker; +} VkSetLatencyMarkerInfoNV; + +typedef struct VkLatencyTimingsFrameReportNV { + VkStructureType sType; + const void* pNext; + uint64_t presentID; + uint64_t inputSampleTimeUs; + uint64_t simStartTimeUs; + uint64_t simEndTimeUs; + uint64_t renderSubmitStartTimeUs; + uint64_t renderSubmitEndTimeUs; + uint64_t presentStartTimeUs; + uint64_t presentEndTimeUs; + uint64_t driverStartTimeUs; + uint64_t driverEndTimeUs; + uint64_t osRenderQueueStartTimeUs; + uint64_t osRenderQueueEndTimeUs; + uint64_t gpuRenderStartTimeUs; + uint64_t gpuRenderEndTimeUs; +} VkLatencyTimingsFrameReportNV; + +typedef struct VkGetLatencyMarkerInfoNV { + VkStructureType sType; + const void* pNext; + VkLatencyTimingsFrameReportNV* pTimings; +} VkGetLatencyMarkerInfoNV; + +typedef struct VkLatencySubmissionPresentIdNV { + VkStructureType sType; + const void* pNext; + uint64_t presentID; +} VkLatencySubmissionPresentIdNV; + +typedef struct VkSwapchainLatencyCreateInfoNV { + VkStructureType sType; + const void* pNext; + VkBool32 latencyModeEnable; +} VkSwapchainLatencyCreateInfoNV; + +typedef struct VkOutOfBandQueueTypeInfoNV { + VkStructureType sType; + const void* pNext; + VkOutOfBandQueueTypeNV queueType; +} VkOutOfBandQueueTypeInfoNV; + +typedef struct VkLatencySurfaceCapabilitiesNV { + VkStructureType sType; + const void* pNext; + uint32_t presentModeCount; + VkPresentModeKHR* pPresentModes; +} VkLatencySurfaceCapabilitiesNV; + +typedef VkResult ( *PFN_vkSetLatencySleepModeNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo); +typedef VkResult ( *PFN_vkLatencySleepNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo); +typedef void ( *PFN_vkSetLatencyMarkerNV)(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); +typedef void ( *PFN_vkGetLatencyTimingsNV)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pTimingCount, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); +typedef void ( *PFN_vkQueueNotifyOutOfBandNV)(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); +# 17914 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 multiviewPerViewRenderAreas; +} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; + +typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM { + VkStructureType sType; + const void* pNext; + uint32_t perViewRenderAreaCount; + const VkRect2D* pPerViewRenderAreas; +} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; +# 17934 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkBlockMatchWindowCompareModeQCOM { + VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM = 0, + VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM = 1, + VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_ENUM_QCOM = 0x7FFFFFFF +} VkBlockMatchWindowCompareModeQCOM; +typedef struct VkPhysicalDeviceImageProcessing2FeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 textureBlockMatch2; +} VkPhysicalDeviceImageProcessing2FeaturesQCOM; + +typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM { + VkStructureType sType; + void* pNext; + VkExtent2D maxBlockMatchWindow; +} VkPhysicalDeviceImageProcessing2PropertiesQCOM; + +typedef struct VkSamplerBlockMatchWindowCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkExtent2D windowExtent; + VkBlockMatchWindowCompareModeQCOM windowCompareMode; +} VkSamplerBlockMatchWindowCreateInfoQCOM; +# 17965 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkCubicFilterWeightsQCOM { + VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM = 0, + VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM = 1, + VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM = 2, + VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM = 3, + VK_CUBIC_FILTER_WEIGHTS_MAX_ENUM_QCOM = 0x7FFFFFFF +} VkCubicFilterWeightsQCOM; +typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 selectableCubicWeights; +} VkPhysicalDeviceCubicWeightsFeaturesQCOM; + +typedef struct VkSamplerCubicWeightsCreateInfoQCOM { + VkStructureType sType; + const void* pNext; + VkCubicFilterWeightsQCOM cubicWeights; +} VkSamplerCubicWeightsCreateInfoQCOM; + +typedef struct VkBlitImageCubicWeightsInfoQCOM { + VkStructureType sType; + const void* pNext; + VkCubicFilterWeightsQCOM cubicWeights; +} VkBlitImageCubicWeightsInfoQCOM; + + + + + + + +typedef struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 ycbcrDegamma; +} VkPhysicalDeviceYcbcrDegammaFeaturesQCOM; + +typedef struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM { + VkStructureType sType; + void* pNext; + VkBool32 enableYDegamma; + VkBool32 enableCbCrDegamma; +} VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; + + + + + + + +typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM { + VkStructureType sType; + void* pNext; + VkBool32 cubicRangeClamp; +} VkPhysicalDeviceCubicClampFeaturesQCOM; + + + + + + + +typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 attachmentFeedbackLoopDynamicState; +} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; + +typedef void ( *PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); +# 18047 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkLayeredDriverUnderlyingApiMSFT { + VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT = 0, + VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT = 1, + VK_LAYERED_DRIVER_UNDERLYING_API_MAX_ENUM_MSFT = 0x7FFFFFFF +} VkLayeredDriverUnderlyingApiMSFT; +typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT { + VkStructureType sType; + void* pNext; + VkLayeredDriverUnderlyingApiMSFT underlyingAPI; +} VkPhysicalDeviceLayeredDriverPropertiesMSFT; + + + + + + + +typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { + VkStructureType sType; + void* pNext; + VkBool32 descriptorPoolOverallocation; +} VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV; +# 18077 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkBuildAccelerationStructureModeKHR { + VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0, + VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1, + VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF +} VkBuildAccelerationStructureModeKHR; + +typedef enum VkAccelerationStructureCreateFlagBitsKHR { + VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, + VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, + VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, + VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF +} VkAccelerationStructureCreateFlagBitsKHR; +typedef VkFlags VkAccelerationStructureCreateFlagsKHR; +typedef struct VkAccelerationStructureBuildRangeInfoKHR { + uint32_t primitiveCount; + uint32_t primitiveOffset; + uint32_t firstVertex; + uint32_t transformOffset; +} VkAccelerationStructureBuildRangeInfoKHR; + +typedef struct VkAccelerationStructureGeometryTrianglesDataKHR { + VkStructureType sType; + const void* pNext; + VkFormat vertexFormat; + VkDeviceOrHostAddressConstKHR vertexData; + VkDeviceSize vertexStride; + uint32_t maxVertex; + VkIndexType indexType; + VkDeviceOrHostAddressConstKHR indexData; + VkDeviceOrHostAddressConstKHR transformData; +} VkAccelerationStructureGeometryTrianglesDataKHR; + +typedef struct VkAccelerationStructureGeometryAabbsDataKHR { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR data; + VkDeviceSize stride; +} VkAccelerationStructureGeometryAabbsDataKHR; + +typedef struct VkAccelerationStructureGeometryInstancesDataKHR { + VkStructureType sType; + const void* pNext; + VkBool32 arrayOfPointers; + VkDeviceOrHostAddressConstKHR data; +} VkAccelerationStructureGeometryInstancesDataKHR; + +typedef union VkAccelerationStructureGeometryDataKHR { + VkAccelerationStructureGeometryTrianglesDataKHR triangles; + VkAccelerationStructureGeometryAabbsDataKHR aabbs; + VkAccelerationStructureGeometryInstancesDataKHR instances; +} VkAccelerationStructureGeometryDataKHR; + +typedef struct VkAccelerationStructureGeometryKHR { + VkStructureType sType; + const void* pNext; + VkGeometryTypeKHR geometryType; + VkAccelerationStructureGeometryDataKHR geometry; + VkGeometryFlagsKHR flags; +} VkAccelerationStructureGeometryKHR; + +typedef struct VkAccelerationStructureBuildGeometryInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureTypeKHR type; + VkBuildAccelerationStructureFlagsKHR flags; + VkBuildAccelerationStructureModeKHR mode; + VkAccelerationStructureKHR srcAccelerationStructure; + VkAccelerationStructureKHR dstAccelerationStructure; + uint32_t geometryCount; + const VkAccelerationStructureGeometryKHR* pGeometries; + const VkAccelerationStructureGeometryKHR* const* ppGeometries; + VkDeviceOrHostAddressKHR scratchData; +} VkAccelerationStructureBuildGeometryInfoKHR; + +typedef struct VkAccelerationStructureCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureCreateFlagsKHR createFlags; + VkBuffer buffer; + VkDeviceSize offset; + VkDeviceSize size; + VkAccelerationStructureTypeKHR type; + VkDeviceAddress deviceAddress; +} VkAccelerationStructureCreateInfoKHR; + +typedef struct VkWriteDescriptorSetAccelerationStructureKHR { + VkStructureType sType; + const void* pNext; + uint32_t accelerationStructureCount; + const VkAccelerationStructureKHR* pAccelerationStructures; +} VkWriteDescriptorSetAccelerationStructureKHR; + +typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 accelerationStructure; + VkBool32 accelerationStructureCaptureReplay; + VkBool32 accelerationStructureIndirectBuild; + VkBool32 accelerationStructureHostCommands; + VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; +} VkPhysicalDeviceAccelerationStructureFeaturesKHR; + +typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR { + VkStructureType sType; + void* pNext; + uint64_t maxGeometryCount; + uint64_t maxInstanceCount; + uint64_t maxPrimitiveCount; + uint32_t maxPerStageDescriptorAccelerationStructures; + uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures; + uint32_t maxDescriptorSetAccelerationStructures; + uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures; + uint32_t minAccelerationStructureScratchOffsetAlignment; +} VkPhysicalDeviceAccelerationStructurePropertiesKHR; + +typedef struct VkAccelerationStructureDeviceAddressInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR accelerationStructure; +} VkAccelerationStructureDeviceAddressInfoKHR; + +typedef struct VkAccelerationStructureVersionInfoKHR { + VkStructureType sType; + const void* pNext; + const uint8_t* pVersionData; +} VkAccelerationStructureVersionInfoKHR; + +typedef struct VkCopyAccelerationStructureToMemoryInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR src; + VkDeviceOrHostAddressKHR dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyAccelerationStructureToMemoryInfoKHR; + +typedef struct VkCopyMemoryToAccelerationStructureInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceOrHostAddressConstKHR src; + VkAccelerationStructureKHR dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyMemoryToAccelerationStructureInfoKHR; + +typedef struct VkCopyAccelerationStructureInfoKHR { + VkStructureType sType; + const void* pNext; + VkAccelerationStructureKHR src; + VkAccelerationStructureKHR dst; + VkCopyAccelerationStructureModeKHR mode; +} VkCopyAccelerationStructureInfoKHR; + +typedef struct VkAccelerationStructureBuildSizesInfoKHR { + VkStructureType sType; + const void* pNext; + VkDeviceSize accelerationStructureSize; + VkDeviceSize updateScratchSize; + VkDeviceSize buildScratchSize; +} VkAccelerationStructureBuildSizesInfoKHR; + +typedef VkResult ( *PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); +typedef void ( *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator); +typedef void ( *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +typedef void ( *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); +typedef VkResult ( *PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); +typedef VkResult ( *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo); +typedef VkResult ( *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +typedef VkResult ( *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +typedef VkResult ( *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); +typedef void ( *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); +typedef void ( *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); +typedef void ( *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); +typedef VkDeviceAddress ( *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); +typedef void ( *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); +typedef void ( *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); +typedef void ( *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); +# 18353 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef enum VkShaderGroupShaderKHR { + VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0, + VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1, + VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2, + VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3, + VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF +} VkShaderGroupShaderKHR; +typedef struct VkRayTracingShaderGroupCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkRayTracingShaderGroupTypeKHR type; + uint32_t generalShader; + uint32_t closestHitShader; + uint32_t anyHitShader; + uint32_t intersectionShader; + const void* pShaderGroupCaptureReplayHandle; +} VkRayTracingShaderGroupCreateInfoKHR; + +typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR { + VkStructureType sType; + const void* pNext; + uint32_t maxPipelineRayPayloadSize; + uint32_t maxPipelineRayHitAttributeSize; +} VkRayTracingPipelineInterfaceCreateInfoKHR; + +typedef struct VkRayTracingPipelineCreateInfoKHR { + VkStructureType sType; + const void* pNext; + VkPipelineCreateFlags flags; + uint32_t stageCount; + const VkPipelineShaderStageCreateInfo* pStages; + uint32_t groupCount; + const VkRayTracingShaderGroupCreateInfoKHR* pGroups; + uint32_t maxPipelineRayRecursionDepth; + const VkPipelineLibraryCreateInfoKHR* pLibraryInfo; + const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface; + const VkPipelineDynamicStateCreateInfo* pDynamicState; + VkPipelineLayout layout; + VkPipeline basePipelineHandle; + int32_t basePipelineIndex; +} VkRayTracingPipelineCreateInfoKHR; + +typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayTracingPipeline; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay; + VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed; + VkBool32 rayTracingPipelineTraceRaysIndirect; + VkBool32 rayTraversalPrimitiveCulling; +} VkPhysicalDeviceRayTracingPipelineFeaturesKHR; + +typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR { + VkStructureType sType; + void* pNext; + uint32_t shaderGroupHandleSize; + uint32_t maxRayRecursionDepth; + uint32_t maxShaderGroupStride; + uint32_t shaderGroupBaseAlignment; + uint32_t shaderGroupHandleCaptureReplaySize; + uint32_t maxRayDispatchInvocationCount; + uint32_t shaderGroupHandleAlignment; + uint32_t maxRayHitAttributeSize; +} VkPhysicalDeviceRayTracingPipelinePropertiesKHR; + +typedef struct VkStridedDeviceAddressRegionKHR { + VkDeviceAddress deviceAddress; + VkDeviceSize stride; + VkDeviceSize size; +} VkStridedDeviceAddressRegionKHR; + +typedef struct VkTraceRaysIndirectCommandKHR { + uint32_t width; + uint32_t height; + uint32_t depth; +} VkTraceRaysIndirectCommandKHR; + +typedef void ( *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth); +typedef VkResult ( *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); +typedef VkResult ( *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); +typedef void ( *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); +typedef VkDeviceSize ( *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader); +typedef void ( *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); +# 18489 "/usr/include/vulkan/vulkan_core.h" 3 4 +typedef struct VkPhysicalDeviceRayQueryFeaturesKHR { + VkStructureType sType; + void* pNext; + VkBool32 rayQuery; +} VkPhysicalDeviceRayQueryFeaturesKHR; + + + + + + + +typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT { + VkStructureType sType; + void* pNext; + VkBool32 taskShader; + VkBool32 meshShader; + VkBool32 multiviewMeshShader; + VkBool32 primitiveFragmentShadingRateMeshShader; + VkBool32 meshShaderQueries; +} VkPhysicalDeviceMeshShaderFeaturesEXT; + +typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT { + VkStructureType sType; + void* pNext; + uint32_t maxTaskWorkGroupTotalCount; + uint32_t maxTaskWorkGroupCount[3]; + uint32_t maxTaskWorkGroupInvocations; + uint32_t maxTaskWorkGroupSize[3]; + uint32_t maxTaskPayloadSize; + uint32_t maxTaskSharedMemorySize; + uint32_t maxTaskPayloadAndSharedMemorySize; + uint32_t maxMeshWorkGroupTotalCount; + uint32_t maxMeshWorkGroupCount[3]; + uint32_t maxMeshWorkGroupInvocations; + uint32_t maxMeshWorkGroupSize[3]; + uint32_t maxMeshSharedMemorySize; + uint32_t maxMeshPayloadAndSharedMemorySize; + uint32_t maxMeshOutputMemorySize; + uint32_t maxMeshPayloadAndOutputMemorySize; + uint32_t maxMeshOutputComponents; + uint32_t maxMeshOutputVertices; + uint32_t maxMeshOutputPrimitives; + uint32_t maxMeshOutputLayers; + uint32_t maxMeshMultiviewViewCount; + uint32_t meshOutputPerVertexGranularity; + uint32_t meshOutputPerPrimitiveGranularity; + uint32_t maxPreferredTaskWorkGroupInvocations; + uint32_t maxPreferredMeshWorkGroupInvocations; + VkBool32 prefersLocalInvocationVertexOutput; + VkBool32 prefersLocalInvocationPrimitiveOutput; + VkBool32 prefersCompactVertexOutput; + VkBool32 prefersCompactPrimitiveOutput; +} VkPhysicalDeviceMeshShaderPropertiesEXT; + +typedef struct VkDrawMeshTasksIndirectCommandEXT { + uint32_t groupCountX; + uint32_t groupCountY; + uint32_t groupCountZ; +} VkDrawMeshTasksIndirectCommandEXT; + +typedef void ( *PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); +typedef void ( *PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); +typedef void ( *PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); +# 18579 "/usr/include/vulkan/vulkan_core.h" 3 4 +} +# 12 "/usr/include/vulkan/vulkan.h" 2 3 4 +# 51 "third_party/volk.h" 2 +# 63 "third_party/volk.h" +extern "C" { + + +struct VolkDeviceTable; + + + + + + +VkResult volkInitialize(void); +# 82 "third_party/volk.h" +void volkInitializeCustom(PFN_vkGetInstanceProcAddr handler); + + + + + + +uint32_t volkGetInstanceVersion(void); + + + + +void volkLoadInstance(VkInstance instance); + + + + + +void volkLoadInstanceOnly(VkInstance instance); + + + + + + +void volkLoadDevice(VkDevice device); + + + + + +VkInstance volkGetLoadedInstance(void); + + + + + +VkDevice volkGetLoadedDevice(void); + + + + + +void volkLoadDeviceTable(struct VolkDeviceTable* table, VkDevice device); + + + + +struct VolkDeviceTable +{ + + + PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers; + PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets; + PFN_vkAllocateMemory vkAllocateMemory; + PFN_vkBeginCommandBuffer vkBeginCommandBuffer; + PFN_vkBindBufferMemory vkBindBufferMemory; + PFN_vkBindImageMemory vkBindImageMemory; + PFN_vkCmdBeginQuery vkCmdBeginQuery; + PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass; + PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets; + PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer; + PFN_vkCmdBindPipeline vkCmdBindPipeline; + PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers; + PFN_vkCmdBlitImage vkCmdBlitImage; + PFN_vkCmdClearAttachments vkCmdClearAttachments; + PFN_vkCmdClearColorImage vkCmdClearColorImage; + PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage; + PFN_vkCmdCopyBuffer vkCmdCopyBuffer; + PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage; + PFN_vkCmdCopyImage vkCmdCopyImage; + PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer; + PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults; + PFN_vkCmdDispatch vkCmdDispatch; + PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect; + PFN_vkCmdDraw vkCmdDraw; + PFN_vkCmdDrawIndexed vkCmdDrawIndexed; + PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect; + PFN_vkCmdDrawIndirect vkCmdDrawIndirect; + PFN_vkCmdEndQuery vkCmdEndQuery; + PFN_vkCmdEndRenderPass vkCmdEndRenderPass; + PFN_vkCmdExecuteCommands vkCmdExecuteCommands; + PFN_vkCmdFillBuffer vkCmdFillBuffer; + PFN_vkCmdNextSubpass vkCmdNextSubpass; + PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier; + PFN_vkCmdPushConstants vkCmdPushConstants; + PFN_vkCmdResetEvent vkCmdResetEvent; + PFN_vkCmdResetQueryPool vkCmdResetQueryPool; + PFN_vkCmdResolveImage vkCmdResolveImage; + PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants; + PFN_vkCmdSetDepthBias vkCmdSetDepthBias; + PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds; + PFN_vkCmdSetEvent vkCmdSetEvent; + PFN_vkCmdSetLineWidth vkCmdSetLineWidth; + PFN_vkCmdSetScissor vkCmdSetScissor; + PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask; + PFN_vkCmdSetStencilReference vkCmdSetStencilReference; + PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask; + PFN_vkCmdSetViewport vkCmdSetViewport; + PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer; + PFN_vkCmdWaitEvents vkCmdWaitEvents; + PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp; + PFN_vkCreateBuffer vkCreateBuffer; + PFN_vkCreateBufferView vkCreateBufferView; + PFN_vkCreateCommandPool vkCreateCommandPool; + PFN_vkCreateComputePipelines vkCreateComputePipelines; + PFN_vkCreateDescriptorPool vkCreateDescriptorPool; + PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout; + PFN_vkCreateEvent vkCreateEvent; + PFN_vkCreateFence vkCreateFence; + PFN_vkCreateFramebuffer vkCreateFramebuffer; + PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines; + PFN_vkCreateImage vkCreateImage; + PFN_vkCreateImageView vkCreateImageView; + PFN_vkCreatePipelineCache vkCreatePipelineCache; + PFN_vkCreatePipelineLayout vkCreatePipelineLayout; + PFN_vkCreateQueryPool vkCreateQueryPool; + PFN_vkCreateRenderPass vkCreateRenderPass; + PFN_vkCreateSampler vkCreateSampler; + PFN_vkCreateSemaphore vkCreateSemaphore; + PFN_vkCreateShaderModule vkCreateShaderModule; + PFN_vkDestroyBuffer vkDestroyBuffer; + PFN_vkDestroyBufferView vkDestroyBufferView; + PFN_vkDestroyCommandPool vkDestroyCommandPool; + PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool; + PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout; + PFN_vkDestroyDevice vkDestroyDevice; + PFN_vkDestroyEvent vkDestroyEvent; + PFN_vkDestroyFence vkDestroyFence; + PFN_vkDestroyFramebuffer vkDestroyFramebuffer; + PFN_vkDestroyImage vkDestroyImage; + PFN_vkDestroyImageView vkDestroyImageView; + PFN_vkDestroyPipeline vkDestroyPipeline; + PFN_vkDestroyPipelineCache vkDestroyPipelineCache; + PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout; + PFN_vkDestroyQueryPool vkDestroyQueryPool; + PFN_vkDestroyRenderPass vkDestroyRenderPass; + PFN_vkDestroySampler vkDestroySampler; + PFN_vkDestroySemaphore vkDestroySemaphore; + PFN_vkDestroyShaderModule vkDestroyShaderModule; + PFN_vkDeviceWaitIdle vkDeviceWaitIdle; + PFN_vkEndCommandBuffer vkEndCommandBuffer; + PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges; + PFN_vkFreeCommandBuffers vkFreeCommandBuffers; + PFN_vkFreeDescriptorSets vkFreeDescriptorSets; + PFN_vkFreeMemory vkFreeMemory; + PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements; + PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment; + PFN_vkGetDeviceQueue vkGetDeviceQueue; + PFN_vkGetEventStatus vkGetEventStatus; + PFN_vkGetFenceStatus vkGetFenceStatus; + PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; + PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements; + PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout; + PFN_vkGetPipelineCacheData vkGetPipelineCacheData; + PFN_vkGetQueryPoolResults vkGetQueryPoolResults; + PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity; + PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges; + PFN_vkMapMemory vkMapMemory; + PFN_vkMergePipelineCaches vkMergePipelineCaches; + PFN_vkQueueBindSparse vkQueueBindSparse; + PFN_vkQueueSubmit vkQueueSubmit; + PFN_vkQueueWaitIdle vkQueueWaitIdle; + PFN_vkResetCommandBuffer vkResetCommandBuffer; + PFN_vkResetCommandPool vkResetCommandPool; + PFN_vkResetDescriptorPool vkResetDescriptorPool; + PFN_vkResetEvent vkResetEvent; + PFN_vkResetFences vkResetFences; + PFN_vkSetEvent vkSetEvent; + PFN_vkUnmapMemory vkUnmapMemory; + PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets; + PFN_vkWaitForFences vkWaitForFences; + + + PFN_vkBindBufferMemory2 vkBindBufferMemory2; + PFN_vkBindImageMemory2 vkBindImageMemory2; + PFN_vkCmdDispatchBase vkCmdDispatchBase; + PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask; + PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate; + PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion; + PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate; + PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion; + PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2; + PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport; + PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures; + PFN_vkGetDeviceQueue2 vkGetDeviceQueue2; + PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2; + PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2; + PFN_vkTrimCommandPool vkTrimCommandPool; + PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate; + + + PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2; + PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount; + PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount; + PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2; + PFN_vkCmdNextSubpass2 vkCmdNextSubpass2; + PFN_vkCreateRenderPass2 vkCreateRenderPass2; + PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress; + PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress; + PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress; + PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue; + PFN_vkResetQueryPool vkResetQueryPool; + PFN_vkSignalSemaphore vkSignalSemaphore; + PFN_vkWaitSemaphores vkWaitSemaphores; + + + PFN_vkCmdBeginRendering vkCmdBeginRendering; + PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2; + PFN_vkCmdBlitImage2 vkCmdBlitImage2; + PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2; + PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2; + PFN_vkCmdCopyImage2 vkCmdCopyImage2; + PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2; + PFN_vkCmdEndRendering vkCmdEndRendering; + PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2; + PFN_vkCmdResetEvent2 vkCmdResetEvent2; + PFN_vkCmdResolveImage2 vkCmdResolveImage2; + PFN_vkCmdSetCullMode vkCmdSetCullMode; + PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable; + PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable; + PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp; + PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable; + PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable; + PFN_vkCmdSetEvent2 vkCmdSetEvent2; + PFN_vkCmdSetFrontFace vkCmdSetFrontFace; + PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable; + PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology; + PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable; + PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount; + PFN_vkCmdSetStencilOp vkCmdSetStencilOp; + PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable; + PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount; + PFN_vkCmdWaitEvents2 vkCmdWaitEvents2; + PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2; + PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot; + PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot; + PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements; + PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements; + PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements; + PFN_vkGetPrivateData vkGetPrivateData; + PFN_vkQueueSubmit2 vkQueueSubmit2; + PFN_vkSetPrivateData vkSetPrivateData; + + + PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD; + + + PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD; + + + PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD; + PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD; + + + PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD; + + + + + + + PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT; + + + PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT; + + + PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT; + + + PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT; + PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT; + + + PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT; + PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT; + PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT; + PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT; + PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT; + + + PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT; + PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT; + PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT; + PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT; + PFN_vkGetDescriptorEXT vkGetDescriptorEXT; + PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT; + PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT; + PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT; + PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT; + PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT; + + + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT; + + + PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT; + + + PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT; + + + PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT; + PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT; + PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT; + PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT; + + + PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT; + PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT; + PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT; + PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT; + PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT; + PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT; + PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT; + PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT; + PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT; + PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT; + PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT; + PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT; + + + PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT; + PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT; + PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT; + PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT; + PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT; + + + PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT; + PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT; + PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT; + PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT; + PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT; + PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT; + PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT; + PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV; + PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV; + PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV; + PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV; + PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV; + PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV; + PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT; + PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT; + PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT; + PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT; + PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT; + PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT; + PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT; + PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT; + PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT; + PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT; + PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT; + PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV; + PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT; + PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT; + PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV; + PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT; + PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV; + PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV; + + + PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT; + + + + + + + PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT; + + + PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT; + + + PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT; + + + PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT; + + + PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT; + + + PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT; + PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT; + PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT; + + + + + + PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT; + PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT; + + + PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT; + PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT; + PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT; + PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT; + PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT; + PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT; + PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT; + PFN_vkCopyMicromapEXT vkCopyMicromapEXT; + PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT; + PFN_vkCreateMicromapEXT vkCreateMicromapEXT; + PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT; + PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT; + PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT; + PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT; + + + PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT; + + + PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT; + + + PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT; + PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT; + PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT; + PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT; + + + PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT; + + + PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT; + PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT; + + + PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT; + + + PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT; + PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT; + PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT; + PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT; + PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT; + PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT; + + + PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT; + PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT; + PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT; + PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT; + + + PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT; +# 549 "third_party/volk.h" + PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE; + PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE; + + + PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI; + + + PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI; + PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI; + + + PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL; + PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL; + PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL; + PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL; + PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL; + PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL; + PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL; + PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL; + PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL; + + + PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR; + PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR; + PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR; + PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR; + PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR; + PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR; + PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR; + PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR; + PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR; + PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR; + PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR; + PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR; + PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR; + PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR; + PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR; + PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR; + + + PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR; + PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR; + + + PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR; + PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR; + PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR; + + + PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR; + PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR; + PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR; + PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR; + PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR; + PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR; + + + PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR; + PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR; + PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR; + PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR; + + + PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR; + PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR; + PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR; + PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR; + PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR; + + + PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR; + PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR; + PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR; + + + PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR; + PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR; + PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR; + + + PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR; + + + PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR; + PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR; + + + PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR; + PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR; + + + PFN_vkGetFenceFdKHR vkGetFenceFdKHR; + PFN_vkImportFenceFdKHR vkImportFenceFdKHR; + + + + + + + PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR; + PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR; + + + + + + + PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR; + PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR; + + + + + + + PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR; + + + PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR; + PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR; + PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR; + + + PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR; + + + PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR; + + + PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR; + PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR; + PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR; + + + PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR; + PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR; + + + PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR; + PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR; + PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR; + + + PFN_vkWaitForPresentKHR vkWaitForPresentKHR; + + + PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR; + + + PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR; + + + PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR; + PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR; + PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR; + PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR; + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; + PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR; + PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR; + + + PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR; + PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR; + + + PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR; + + + PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR; + PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR; + PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR; + PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; + PFN_vkQueuePresentKHR vkQueuePresentKHR; + + + PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR; + PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR; + PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR; + PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR; + PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR; + PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR; + + + PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD; + + + PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV; + + + PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR; + PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR; + PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR; + + + PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR; + + + + + + PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR; + PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR; + PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR; + PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR; + PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR; + PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR; + PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR; + PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR; + PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR; + PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR; + + + PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX; + PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX; + PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX; + PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX; + PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX; + + + PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX; + PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX; + + + PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV; + + + PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV; + PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV; + + + PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV; + PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV; + + + PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV; + PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV; + PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV; + PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV; + PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV; + PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV; + + + PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV; + + + + + + PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV; + + + PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV; + PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV; + + + PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV; + PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV; + PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV; + + + PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV; + PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV; + PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV; + PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV; + + + PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV; + PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV; + PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV; + PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV; + PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV; + PFN_vkCompileDeferredNV vkCompileDeferredNV; + PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV; + PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV; + PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV; + PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV; + PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV; + PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV; + + + PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV; + + + PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV; + PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV; + PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV; + + + PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM; + PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM; + + + PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE; + PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE; + + + + + + PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR; + + + PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR; + PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR; + + + PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR; + + +}; + + + +extern PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers; +extern PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets; +extern PFN_vkAllocateMemory vkAllocateMemory; +extern PFN_vkBeginCommandBuffer vkBeginCommandBuffer; +extern PFN_vkBindBufferMemory vkBindBufferMemory; +extern PFN_vkBindImageMemory vkBindImageMemory; +extern PFN_vkCmdBeginQuery vkCmdBeginQuery; +extern PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass; +extern PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets; +extern PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer; +extern PFN_vkCmdBindPipeline vkCmdBindPipeline; +extern PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers; +extern PFN_vkCmdBlitImage vkCmdBlitImage; +extern PFN_vkCmdClearAttachments vkCmdClearAttachments; +extern PFN_vkCmdClearColorImage vkCmdClearColorImage; +extern PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage; +extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer; +extern PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage; +extern PFN_vkCmdCopyImage vkCmdCopyImage; +extern PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer; +extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults; +extern PFN_vkCmdDispatch vkCmdDispatch; +extern PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect; +extern PFN_vkCmdDraw vkCmdDraw; +extern PFN_vkCmdDrawIndexed vkCmdDrawIndexed; +extern PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect; +extern PFN_vkCmdDrawIndirect vkCmdDrawIndirect; +extern PFN_vkCmdEndQuery vkCmdEndQuery; +extern PFN_vkCmdEndRenderPass vkCmdEndRenderPass; +extern PFN_vkCmdExecuteCommands vkCmdExecuteCommands; +extern PFN_vkCmdFillBuffer vkCmdFillBuffer; +extern PFN_vkCmdNextSubpass vkCmdNextSubpass; +extern PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier; +extern PFN_vkCmdPushConstants vkCmdPushConstants; +extern PFN_vkCmdResetEvent vkCmdResetEvent; +extern PFN_vkCmdResetQueryPool vkCmdResetQueryPool; +extern PFN_vkCmdResolveImage vkCmdResolveImage; +extern PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants; +extern PFN_vkCmdSetDepthBias vkCmdSetDepthBias; +extern PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds; +extern PFN_vkCmdSetEvent vkCmdSetEvent; +extern PFN_vkCmdSetLineWidth vkCmdSetLineWidth; +extern PFN_vkCmdSetScissor vkCmdSetScissor; +extern PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask; +extern PFN_vkCmdSetStencilReference vkCmdSetStencilReference; +extern PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask; +extern PFN_vkCmdSetViewport vkCmdSetViewport; +extern PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer; +extern PFN_vkCmdWaitEvents vkCmdWaitEvents; +extern PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp; +extern PFN_vkCreateBuffer vkCreateBuffer; +extern PFN_vkCreateBufferView vkCreateBufferView; +extern PFN_vkCreateCommandPool vkCreateCommandPool; +extern PFN_vkCreateComputePipelines vkCreateComputePipelines; +extern PFN_vkCreateDescriptorPool vkCreateDescriptorPool; +extern PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout; +extern PFN_vkCreateDevice vkCreateDevice; +extern PFN_vkCreateEvent vkCreateEvent; +extern PFN_vkCreateFence vkCreateFence; +extern PFN_vkCreateFramebuffer vkCreateFramebuffer; +extern PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines; +extern PFN_vkCreateImage vkCreateImage; +extern PFN_vkCreateImageView vkCreateImageView; +extern PFN_vkCreateInstance vkCreateInstance; +extern PFN_vkCreatePipelineCache vkCreatePipelineCache; +extern PFN_vkCreatePipelineLayout vkCreatePipelineLayout; +extern PFN_vkCreateQueryPool vkCreateQueryPool; +extern PFN_vkCreateRenderPass vkCreateRenderPass; +extern PFN_vkCreateSampler vkCreateSampler; +extern PFN_vkCreateSemaphore vkCreateSemaphore; +extern PFN_vkCreateShaderModule vkCreateShaderModule; +extern PFN_vkDestroyBuffer vkDestroyBuffer; +extern PFN_vkDestroyBufferView vkDestroyBufferView; +extern PFN_vkDestroyCommandPool vkDestroyCommandPool; +extern PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool; +extern PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout; +extern PFN_vkDestroyDevice vkDestroyDevice; +extern PFN_vkDestroyEvent vkDestroyEvent; +extern PFN_vkDestroyFence vkDestroyFence; +extern PFN_vkDestroyFramebuffer vkDestroyFramebuffer; +extern PFN_vkDestroyImage vkDestroyImage; +extern PFN_vkDestroyImageView vkDestroyImageView; +extern PFN_vkDestroyInstance vkDestroyInstance; +extern PFN_vkDestroyPipeline vkDestroyPipeline; +extern PFN_vkDestroyPipelineCache vkDestroyPipelineCache; +extern PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout; +extern PFN_vkDestroyQueryPool vkDestroyQueryPool; +extern PFN_vkDestroyRenderPass vkDestroyRenderPass; +extern PFN_vkDestroySampler vkDestroySampler; +extern PFN_vkDestroySemaphore vkDestroySemaphore; +extern PFN_vkDestroyShaderModule vkDestroyShaderModule; +extern PFN_vkDeviceWaitIdle vkDeviceWaitIdle; +extern PFN_vkEndCommandBuffer vkEndCommandBuffer; +extern PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties; +extern PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties; +extern PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties; +extern PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties; +extern PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices; +extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges; +extern PFN_vkFreeCommandBuffers vkFreeCommandBuffers; +extern PFN_vkFreeDescriptorSets vkFreeDescriptorSets; +extern PFN_vkFreeMemory vkFreeMemory; +extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements; +extern PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment; +extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr; +extern PFN_vkGetDeviceQueue vkGetDeviceQueue; +extern PFN_vkGetEventStatus vkGetEventStatus; +extern PFN_vkGetFenceStatus vkGetFenceStatus; +extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; +extern PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements; +extern PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout; +extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; +extern PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures; +extern PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties; +extern PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties; +extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties; +extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties; +extern PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties; +extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties; +extern PFN_vkGetPipelineCacheData vkGetPipelineCacheData; +extern PFN_vkGetQueryPoolResults vkGetQueryPoolResults; +extern PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity; +extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges; +extern PFN_vkMapMemory vkMapMemory; +extern PFN_vkMergePipelineCaches vkMergePipelineCaches; +extern PFN_vkQueueBindSparse vkQueueBindSparse; +extern PFN_vkQueueSubmit vkQueueSubmit; +extern PFN_vkQueueWaitIdle vkQueueWaitIdle; +extern PFN_vkResetCommandBuffer vkResetCommandBuffer; +extern PFN_vkResetCommandPool vkResetCommandPool; +extern PFN_vkResetDescriptorPool vkResetDescriptorPool; +extern PFN_vkResetEvent vkResetEvent; +extern PFN_vkResetFences vkResetFences; +extern PFN_vkSetEvent vkSetEvent; +extern PFN_vkUnmapMemory vkUnmapMemory; +extern PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets; +extern PFN_vkWaitForFences vkWaitForFences; + + +extern PFN_vkBindBufferMemory2 vkBindBufferMemory2; +extern PFN_vkBindImageMemory2 vkBindImageMemory2; +extern PFN_vkCmdDispatchBase vkCmdDispatchBase; +extern PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask; +extern PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate; +extern PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion; +extern PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate; +extern PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion; +extern PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion; +extern PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups; +extern PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2; +extern PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport; +extern PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures; +extern PFN_vkGetDeviceQueue2 vkGetDeviceQueue2; +extern PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2; +extern PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2; +extern PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties; +extern PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties; +extern PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties; +extern PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2; +extern PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2; +extern PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2; +extern PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2; +extern PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2; +extern PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2; +extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2; +extern PFN_vkTrimCommandPool vkTrimCommandPool; +extern PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate; + + +extern PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2; +extern PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount; +extern PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount; +extern PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2; +extern PFN_vkCmdNextSubpass2 vkCmdNextSubpass2; +extern PFN_vkCreateRenderPass2 vkCreateRenderPass2; +extern PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress; +extern PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress; +extern PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress; +extern PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue; +extern PFN_vkResetQueryPool vkResetQueryPool; +extern PFN_vkSignalSemaphore vkSignalSemaphore; +extern PFN_vkWaitSemaphores vkWaitSemaphores; + + +extern PFN_vkCmdBeginRendering vkCmdBeginRendering; +extern PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2; +extern PFN_vkCmdBlitImage2 vkCmdBlitImage2; +extern PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2; +extern PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2; +extern PFN_vkCmdCopyImage2 vkCmdCopyImage2; +extern PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2; +extern PFN_vkCmdEndRendering vkCmdEndRendering; +extern PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2; +extern PFN_vkCmdResetEvent2 vkCmdResetEvent2; +extern PFN_vkCmdResolveImage2 vkCmdResolveImage2; +extern PFN_vkCmdSetCullMode vkCmdSetCullMode; +extern PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable; +extern PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable; +extern PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp; +extern PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable; +extern PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable; +extern PFN_vkCmdSetEvent2 vkCmdSetEvent2; +extern PFN_vkCmdSetFrontFace vkCmdSetFrontFace; +extern PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable; +extern PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology; +extern PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable; +extern PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount; +extern PFN_vkCmdSetStencilOp vkCmdSetStencilOp; +extern PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable; +extern PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount; +extern PFN_vkCmdWaitEvents2 vkCmdWaitEvents2; +extern PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2; +extern PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot; +extern PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot; +extern PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements; +extern PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements; +extern PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements; +extern PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties; +extern PFN_vkGetPrivateData vkGetPrivateData; +extern PFN_vkQueueSubmit2 vkQueueSubmit2; +extern PFN_vkSetPrivateData vkSetPrivateData; + + +extern PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD; + + +extern PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD; + + +extern PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD; +extern PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD; + + +extern PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD; + + + + + + +extern PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT; +extern PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT; + + + + + + +extern PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT; + + +extern PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT; +extern PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; + + +extern PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT; + + +extern PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT; +extern PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT; + + +extern PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT; +extern PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT; +extern PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT; +extern PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT; +extern PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT; + + +extern PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT; +extern PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT; +extern PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT; + + +extern PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT; +extern PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT; +extern PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT; +extern PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT; +extern PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT; +extern PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT; +extern PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT; +extern PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT; +extern PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT; +extern PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT; +extern PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT; + + +extern PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT; +extern PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT; +extern PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT; +extern PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT; +extern PFN_vkGetDescriptorEXT vkGetDescriptorEXT; +extern PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT; +extern PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT; +extern PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT; +extern PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT; +extern PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT; + + +extern PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT; + + +extern PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT; + + +extern PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT; + + + + + + +extern PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT; + + +extern PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT; +extern PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT; +extern PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT; +extern PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT; + + +extern PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT; + + +extern PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT; +extern PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT; +extern PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT; +extern PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT; +extern PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT; +extern PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT; +extern PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT; +extern PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT; +extern PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT; +extern PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT; +extern PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT; +extern PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT; + + +extern PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT; +extern PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT; +extern PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT; +extern PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT; +extern PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT; + + +extern PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT; +extern PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT; +extern PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT; +extern PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT; +extern PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT; +extern PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT; +extern PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT; +extern PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV; +extern PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV; +extern PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV; +extern PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV; +extern PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV; +extern PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV; +extern PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT; +extern PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT; +extern PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT; +extern PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT; +extern PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT; +extern PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT; +extern PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT; +extern PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT; +extern PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT; +extern PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT; +extern PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT; +extern PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV; +extern PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT; +extern PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT; +extern PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV; +extern PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT; +extern PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV; +extern PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV; + + +extern PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT; + + + + + + + +extern PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT; + + +extern PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT; + + +extern PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT; + + +extern PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT; + + +extern PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT; + + +extern PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT; + + +extern PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT; +extern PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT; +extern PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT; +# 1277 "third_party/volk.h" +extern PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT; +extern PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT; + + +extern PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT; +extern PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT; +extern PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT; +extern PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT; +extern PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT; +extern PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT; +extern PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT; +extern PFN_vkCopyMicromapEXT vkCopyMicromapEXT; +extern PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT; +extern PFN_vkCreateMicromapEXT vkCreateMicromapEXT; +extern PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT; +extern PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT; +extern PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT; +extern PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT; + + +extern PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT; + + +extern PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT; + + +extern PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT; +extern PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT; +extern PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT; +extern PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT; + + +extern PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT; +extern PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT; + + +extern PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT; +extern PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT; + + +extern PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT; + + +extern PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT; + + +extern PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT; +extern PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT; +extern PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT; +extern PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT; +extern PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT; +extern PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT; + + +extern PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT; +extern PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT; +extern PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT; +extern PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT; + + +extern PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT; +# 1361 "third_party/volk.h" +extern PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE; +extern PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE; + + +extern PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI; + + +extern PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI; +extern PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI; + + +extern PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL; +extern PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL; +extern PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL; +extern PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL; +extern PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL; +extern PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL; +extern PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL; +extern PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL; +extern PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL; + + +extern PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR; +extern PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR; +extern PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR; +extern PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR; +extern PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR; +extern PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR; +extern PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR; +extern PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR; +extern PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR; +extern PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR; +extern PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR; +extern PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR; +extern PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR; +extern PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR; +extern PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR; +extern PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR; + + + + + +extern PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR; +extern PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR; + + +extern PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR; +extern PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR; +extern PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR; + + +extern PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR; +extern PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR; +extern PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR; +extern PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR; +extern PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR; +extern PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR; + + +extern PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR; +extern PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR; +extern PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR; +extern PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR; + + +extern PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR; +extern PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR; +extern PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR; +extern PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR; +extern PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR; + + +extern PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR; +extern PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR; +extern PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR; + + +extern PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR; +extern PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR; +extern PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR; + + +extern PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR; + + +extern PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR; +extern PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR; +extern PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR; +extern PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR; +extern PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR; +extern PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR; +extern PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR; + + +extern PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR; + + +extern PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR; +extern PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR; + + +extern PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR; +extern PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR; + + +extern PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR; + + +extern PFN_vkGetFenceFdKHR vkGetFenceFdKHR; +extern PFN_vkImportFenceFdKHR vkImportFenceFdKHR; + + + + + + +extern PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR; + + +extern PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR; +extern PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR; + + + + + + +extern PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; + + +extern PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR; +extern PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR; + + + + + + +extern PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR; +extern PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR; + + +extern PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR; +extern PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR; +extern PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR; +extern PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR; + + +extern PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR; +extern PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR; +extern PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR; + + +extern PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR; +extern PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR; +extern PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR; +extern PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR; +extern PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR; +extern PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR; +extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR; + + +extern PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR; +extern PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR; + + +extern PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR; + + +extern PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR; + + +extern PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR; +extern PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR; +extern PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR; + + +extern PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR; +extern PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; +extern PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; +extern PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR; + + +extern PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR; +extern PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR; +extern PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR; + + +extern PFN_vkWaitForPresentKHR vkWaitForPresentKHR; + + +extern PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR; + + +extern PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR; + + +extern PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR; +extern PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR; +extern PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR; +extern PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR; +extern PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; +extern PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR; +extern PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR; + + +extern PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR; +extern PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR; + + +extern PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR; + + +extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR; +extern PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR; +extern PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR; +extern PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR; +extern PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR; + + +extern PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR; +extern PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR; +extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR; +extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; +extern PFN_vkQueuePresentKHR vkQueuePresentKHR; + + +extern PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR; +extern PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR; +extern PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR; +extern PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR; +extern PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR; +extern PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR; + + +extern PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD; + + +extern PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV; + + +extern PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR; +extern PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR; +extern PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR; + + +extern PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR; + + + + + +extern PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR; +extern PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR; +extern PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR; +extern PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR; +extern PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR; +extern PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR; +extern PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR; +extern PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR; +extern PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR; +extern PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR; +extern PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR; +extern PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR; +# 1653 "third_party/volk.h" +extern PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX; +extern PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX; +extern PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX; +extern PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX; +extern PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX; + + +extern PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX; +extern PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX; + + + + + + +extern PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV; + + +extern PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV; + + +extern PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV; +extern PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV; + + +extern PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV; + + +extern PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV; +extern PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV; + + +extern PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV; +extern PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV; +extern PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV; +extern PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV; +extern PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV; +extern PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV; + + +extern PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV; + + +extern PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV; + + + + + +extern PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV; + + +extern PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV; +extern PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV; + + +extern PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV; +extern PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV; +extern PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV; + + +extern PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV; +extern PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV; +extern PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV; +extern PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV; +extern PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV; + + +extern PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV; +extern PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV; +extern PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV; +extern PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV; +extern PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV; +extern PFN_vkCompileDeferredNV vkCompileDeferredNV; +extern PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV; +extern PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV; +extern PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV; +extern PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV; +extern PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV; +extern PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV; + + +extern PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV; + + +extern PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV; +extern PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV; +extern PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV; + + +extern PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM; +extern PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM; + + + + + + +extern PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE; +extern PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE; + + + + + +extern PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR; + + +extern PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR; +extern PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR; +extern PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR; + + +extern PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR; + + + + +} +# 17 "src/renderer/descriptors/vk_descriptor_set.h" 2 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/compare" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/compare" 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 3 + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__)); + terminate(); + } +#pragma GCC visibility pop +} +# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + template + class initializer_list + { + public: + typedef _E value_type; + typedef const _E& reference; + typedef const _E& const_reference; + typedef size_t size_type; + typedef const _E* iterator; + typedef const _E* const_iterator; + + private: + iterator _M_array; + size_type _M_len; + + + constexpr initializer_list(const_iterator __a, size_type __l) + : _M_array(__a), _M_len(__l) { } + + public: + constexpr initializer_list() noexcept + : _M_array(0), _M_len(0) { } + + + constexpr size_type + size() const noexcept { return _M_len; } + + + constexpr const_iterator + begin() const noexcept { return _M_array; } + + + constexpr const_iterator + end() const noexcept { return begin() + size(); } + }; + + + + + + + + template + constexpr const _Tp* + begin(initializer_list<_Tp> __ils) noexcept + { return __ils.begin(); } + + + + + + + + template + constexpr const _Tp* + end(initializer_list<_Tp> __ils) noexcept + { return __ils.end(); } +} +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } + + }; + + + + + + + + using true_type = integral_constant; + + + using false_type = integral_constant; + + + + template + using __bool_constant = integral_constant; + + + + + + + template + using bool_constant = integral_constant; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + template + struct is_reference + : public false_type + { }; + + template + struct is_reference<_Tp&> + : public true_type + { }; + + template + struct is_reference<_Tp&&> + : public true_type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long +# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long +# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __is_nothrow_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + template + struct is_same + + : public integral_constant + + + + { }; +# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; +# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_reference + { using type = _Tp; }; + + template + struct remove_reference<_Tp&> + { using type = _Tp; }; + + template + struct remove_reference<_Tp&&> + { using type = _Tp; }; + + + + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { 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; }; +# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; +# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __type; + }; + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; +# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template::value> + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + + template using void_t = void; +# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + + + bool _Dangle = false + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + +template + inline constexpr bool is_array_v = false; +template + inline constexpr bool is_array_v<_Tp[]> = true; +template + inline constexpr bool is_array_v<_Tp[_Num]> = true; + +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; +template + inline constexpr bool is_member_object_pointer_v = + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v = + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); +template + inline constexpr bool is_function_v = is_function<_Tp>::value; +template + inline constexpr bool is_reference_v = false; +template + inline constexpr bool is_reference_v<_Tp&> = true; +template + inline constexpr bool is_reference_v<_Tp&&> = true; +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; +template + inline constexpr bool is_object_v = is_object<_Tp>::value; +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); +# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +} +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; + }; +# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 +} +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; + + + + + + + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 +} +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + + inline + + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + + + + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + + + + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { + + template + using _IdxTuple = _Index_tuple<_Indices...>; + + + using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; + + + + + }; + + + + + + + template + struct integer_sequence + { + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + = __make_integer_seq; + + + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + + + + template + struct _Nth_type + { }; + + template + struct _Nth_type<0, _Tp0, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Rest...> + { using type = _Tp1; }; + + template + struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp2; }; + + template + + + + struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> + : _Nth_type<_Np - 3, _Rest...> + { }; + + + template + struct _Nth_type<0, _Tp0, _Tp1, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp1; }; + + + + + + + +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + class tuple; + + template + struct _Index_tuple; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; + + + + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } +# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } +# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iterator_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 +# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 +# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + namespace __detail + { +# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + } +# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } +# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + typename iterator_traits<_InputIterator>::value_type::first_type>; + + template + using __iter_val_t + = typename iterator_traits<_InputIterator>::value_type::second_type; + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +} +# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__res - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } +# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + } +# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { +# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template + + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +} +# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(_Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + begin(const _Container& __cont) -> decltype(__cont.begin()) + { return __cont.begin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(_Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + end(const _Container& __cont) -> decltype(__cont.end()) + { return __cont.end(); } + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr _Tp* + begin(_Tp (&__arr)[_Nm]) noexcept + { return __arr; } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr _Tp* + end(_Tp (&__arr)[_Nm]) noexcept + { return __arr + _Nm; } + + + + template class valarray; + + template _Tp* begin(valarray<_Tp>&) noexcept; + template const _Tp* begin(const valarray<_Tp>&) noexcept; + template _Tp* end(valarray<_Tp>&) noexcept; + template const _Tp* end(const valarray<_Tp>&) noexcept; + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + constexpr auto + cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) + -> decltype(std::begin(__cont)) + { return std::begin(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + constexpr auto + cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) + -> decltype(std::end(__cont)) + { return std::end(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rbegin(_Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) + { return __cont.rbegin(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(_Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + rend(const _Container& __cont) -> decltype(__cont.rend()) + { return __cont.rend(); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Tp*> + rbegin(_Tp (&__arr)[_Nm]) noexcept + { return reverse_iterator<_Tp*>(__arr + _Nm); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Tp*> + rend(_Tp (&__arr)[_Nm]) noexcept + { return reverse_iterator<_Tp*>(__arr); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator + rbegin(initializer_list<_Tp> __il) noexcept + { return reverse_iterator(__il.end()); } + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator + rend(initializer_list<_Tp> __il) noexcept + { return reverse_iterator(__il.begin()); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) + { return std::rbegin(__cont); } + + + + + + + template + [[__nodiscard__, __gnu__::__always_inline__]] + inline constexpr auto + crend(const _Container& __cont) -> decltype(std::rend(__cont)) + { return std::rend(__cont); } +# 261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + size(const _Container& __cont) noexcept(noexcept(__cont.size())) + -> decltype(__cont.size()) + { return __cont.size(); } + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr size_t + size(const _Tp (&)[_Nm]) noexcept + { return _Nm; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) + -> decltype(__cont.empty()) + { return __cont.empty(); } + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr bool + empty(const _Tp (&)[_Nm]) noexcept + { return false; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr bool + empty(initializer_list<_Tp> __il) noexcept + { return __il.size() == 0;} + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + data(_Container& __cont) noexcept(noexcept(__cont.data())) + -> decltype(__cont.data()) + { return __cont.data(); } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr auto + data(const _Container& __cont) noexcept(noexcept(__cont.data())) + -> decltype(__cont.data()) + { return __cont.data(); } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr _Tp* + data(_Tp (&__array)[_Nm]) noexcept + { return __array; } + + + + + + template + [[nodiscard, __gnu__::__always_inline__]] + constexpr const _Tp* + data(initializer_list<_Tp> __il) noexcept + { return __il.begin(); } +# 371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + struct __array_traits + { + using _Type = _Tp[_Nm]; + using _Is_swappable = __is_swappable<_Tp>; + using _Is_nothrow_swappable = __is_nothrow_swappable<_Tp>; + }; + + template + struct __array_traits<_Tp, 0> + { + + struct _Type + { + + __attribute__((__always_inline__,__noreturn__)) + _Tp& operator[](size_t) const noexcept { __builtin_trap(); } + + + __attribute__((__always_inline__)) + constexpr explicit operator _Tp*() const noexcept { return nullptr; } + }; + + using _Is_swappable = true_type; + using _Is_nothrow_swappable = true_type; + }; +# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 + template + struct array + { + typedef _Tp value_type; + typedef value_type* pointer; + typedef const value_type* const_pointer; + typedef value_type& reference; + typedef const value_type& const_reference; + typedef value_type* iterator; + typedef const value_type* const_iterator; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef std::reverse_iterator reverse_iterator; + typedef std::reverse_iterator const_reverse_iterator; + + + typename __array_traits<_Tp, _Nm>::_Type _M_elems; + + + + + void + fill(const value_type& __u) + { std::fill_n(begin(), size(), __u); } + + void + swap(array& __other) + noexcept(__array_traits<_Tp, _Nm>::_Is_nothrow_swappable::value) + { std::swap_ranges(begin(), end(), __other.begin()); } + + + [[__gnu__::__const__, __nodiscard__]] + constexpr iterator + begin() noexcept + { return iterator(data()); } + + [[__nodiscard__]] + constexpr const_iterator + begin() const noexcept + { return const_iterator(data()); } + + [[__gnu__::__const__, __nodiscard__]] + constexpr iterator + end() noexcept + { return iterator(data() + _Nm); } + + [[__nodiscard__]] + constexpr const_iterator + end() const noexcept + { return const_iterator(data() + _Nm); } + + [[__gnu__::__const__, __nodiscard__]] + constexpr reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + [[__nodiscard__]] + constexpr const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + [[__gnu__::__const__, __nodiscard__]] + constexpr reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + [[__nodiscard__]] + constexpr const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + [[__nodiscard__]] + constexpr const_iterator + cbegin() const noexcept + { return const_iterator(data()); } + + [[__nodiscard__]] + constexpr const_iterator + cend() const noexcept + { return const_iterator(data() + _Nm); } + + [[__nodiscard__]] + constexpr const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + [[__nodiscard__]] + constexpr const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + + [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] + constexpr size_type + size() const noexcept { return _Nm; } + + [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] + constexpr size_type + max_size() const noexcept { return _Nm; } + + [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] + constexpr bool + empty() const noexcept { return size() == 0; } + + + [[__nodiscard__]] + constexpr reference + operator[](size_type __n) noexcept + { + ; + return _M_elems[__n]; + } + + [[__nodiscard__]] + constexpr const_reference + operator[](size_type __n) const noexcept + { + + ; + + return _M_elems[__n]; + } + + constexpr reference + at(size_type __n) + { + if (__n >= _Nm) + std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), + + __n, _Nm); + return _M_elems[__n]; + } + + constexpr const_reference + at(size_type __n) const + { + + + return __n < _Nm ? _M_elems[__n] + : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), + + __n, _Nm), + _M_elems[__n]); + } + + [[__nodiscard__]] + constexpr reference + front() noexcept + { + ; + return _M_elems[(size_type)0]; + } + + [[__nodiscard__]] + constexpr const_reference + front() const noexcept + { + + ; + + return _M_elems[(size_type)0]; + } + + [[__nodiscard__]] + constexpr reference + back() noexcept + { + ; + return _M_elems[_Nm - 1]; + } + + [[__nodiscard__]] + constexpr const_reference + back() const noexcept + { + + ; + + return _M_elems[_Nm - 1]; + } + + [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] + constexpr pointer + data() noexcept + { return static_cast(_M_elems); } + + [[__nodiscard__]] + constexpr const_pointer + data() const noexcept + { return static_cast(_M_elems); } + }; + + + template + array(_Tp, _Up...) + -> array && ...), _Tp>, + 1 + sizeof...(_Up)>; + + + + template + [[__nodiscard__]] + + inline bool + operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return std::equal(__one.begin(), __one.end(), __two.begin()); } +# 322 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 + template + [[__nodiscard__]] + + inline bool + operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one == __two); } + + template + [[__nodiscard__]] + + inline bool + operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) + { + return std::lexicographical_compare(__a.begin(), __a.end(), + __b.begin(), __b.end()); + } + + template + [[__nodiscard__]] + + inline bool + operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return __two < __one; } + + template + [[__nodiscard__]] + + inline bool + operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one > __two); } + + template + [[__nodiscard__]] + + inline bool + operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) + { return !(__one < __two); } + + + + template + + inline + + + __enable_if_t<__array_traits<_Tp, _Nm>::_Is_swappable::value> + + + + swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) + noexcept(noexcept(__one.swap(__two))) + { __one.swap(__two); } + + + template + __enable_if_t::_Is_swappable::value> + swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete; + + + template + [[__nodiscard__]] + constexpr _Tp& + get(array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "array index is within bounds"); + return __arr._M_elems[_Int]; + } + + template + [[__nodiscard__]] + constexpr _Tp&& + get(array<_Tp, _Nm>&& __arr) noexcept + { + static_assert(_Int < _Nm, "array index is within bounds"); + return std::move(std::get<_Int>(__arr)); + } + + template + [[__nodiscard__]] + constexpr const _Tp& + get(const array<_Tp, _Nm>& __arr) noexcept + { + static_assert(_Int < _Nm, "array index is within bounds"); + return __arr._M_elems[_Int]; + } + + template + [[__nodiscard__]] + constexpr const _Tp&& + get(const array<_Tp, _Nm>&& __arr) noexcept + { + static_assert(_Int < _Nm, "array index is within bounds"); + return std::move(std::get<_Int>(__arr)); + } +# 460 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<_Ind, array<_Tp, _Nm>> + { + static_assert(_Ind < _Nm, "array index is in range"); + using type = _Tp; + }; + + + template + inline constexpr size_t tuple_size_v> = _Nm; + + template + inline constexpr size_t tuple_size_v> = _Nm; + + + template + struct __is_tuple_like_impl> : true_type + { }; + + +} +# 18 "src/renderer/descriptors/vk_descriptor_set.h" 2 + + +namespace mlx +{ + class DescriptorSet + { + public: + void init(class Renderer* renderer, class DescriptorPool* pool, class DescriptorSetLayout* layout); + + void writeDescriptor(int binding, class UBO* ubo) noexcept; + void writeDescriptor(int binding, VkImageView view, VkSampler sampler) noexcept; + + inline bool isInit() noexcept { return _pool != nullptr && _renderer != nullptr; } + + DescriptorSet duplicate(); + + VkDescriptorSet& operator()() noexcept; + VkDescriptorSet& get() noexcept; + + private: + std::array _desc_set; + class DescriptorPool* _pool = nullptr; + class DescriptorSetLayout* _layout = nullptr; + class Renderer* _renderer = nullptr; + }; +} +# 14 "src/renderer/descriptors/vk_descriptor_set.cpp" 2 +# 1 "src/renderer/descriptors/vk_descriptor_pool.h" 1 +# 16 "src/renderer/descriptors/vk_descriptor_pool.h" +# 1 "third_party/volk.h" 1 +# 17 "src/renderer/descriptors/vk_descriptor_pool.h" 2 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 1 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 + + + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 +# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 2 3 + +extern "C++" +{ + +namespace std +{ + + using ::max_align_t; +} + + + +namespace std +{ + + + + + enum class byte : unsigned char {}; + + template struct __byte_operand { }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + + + + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; + template<> struct __byte_operand { using __type = byte; }; +# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + template + struct __byte_operand + : __byte_operand<_IntegerType> { }; + + template + using __byte_op_t = typename __byte_operand<_IntegerType>::__type; + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType> + operator<<(byte __b, _IntegerType __shift) noexcept + { return (byte)(unsigned char)((unsigned)__b << __shift); } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType> + operator>>(byte __b, _IntegerType __shift) noexcept + { return (byte)(unsigned char)((unsigned)__b >> __shift); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator|(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator&(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator^(byte __l, byte __r) noexcept + { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } + + [[__gnu__::__always_inline__]] + constexpr byte + operator~(byte __b) noexcept + { return (byte)(unsigned char)~(unsigned)__b; } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType>& + operator<<=(byte& __b, _IntegerType __shift) noexcept + { return __b = __b << __shift; } + + template + [[__gnu__::__always_inline__]] + constexpr __byte_op_t<_IntegerType>& + operator>>=(byte& __b, _IntegerType __shift) noexcept + { return __b = __b >> __shift; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator|=(byte& __l, byte __r) noexcept + { return __l = __l | __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator&=(byte& __l, byte __r) noexcept + { return __l = __l & __r; } + + [[__gnu__::__always_inline__]] + constexpr byte& + operator^=(byte& __l, byte __r) noexcept + { return __l = __l ^ __r; } + + template + [[nodiscard,__gnu__::__always_inline__]] + constexpr _IntegerType + to_integer(__byte_op_t<_IntegerType> __b) noexcept + { return _IntegerType(__b); } + + +} + +} +# 18 "src/renderer/descriptors/vk_descriptor_pool.h" 2 + +namespace mlx +{ + class DescriptorPool + { + public: + void init(std::size_t n, VkDescriptorPoolSize* size); + void destroy() noexcept; + + inline VkDescriptorPool& operator()() noexcept { return _pool; } + inline VkDescriptorPool& get() noexcept { return _pool; } + + private: + VkDescriptorPool _pool = nullptr; + }; +} +# 15 "src/renderer/descriptors/vk_descriptor_set.cpp" 2 +# 1 "src/renderer/descriptors/vk_descriptor_set_layout.h" 1 +# 16 "src/renderer/descriptors/vk_descriptor_set_layout.h" +# 1 "third_party/volk.h" 1 +# 17 "src/renderer/descriptors/vk_descriptor_set_layout.h" 2 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 1 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 1 3 +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 1 3 +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 + + + +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 + class exception + { + public: + exception() noexcept { } + virtual ~exception() noexcept; + + exception(const exception&) = default; + exception& operator=(const exception&) = default; + exception(exception&&) = default; + exception& operator=(exception&&) = default; + + + + + virtual const char* + what() const noexcept; + }; + + + +} + +} +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 2 3 + +#pragma GCC visibility push(default) + +extern "C++" { + +namespace std +{ + + + + + + + class bad_alloc : public exception + { + public: + bad_alloc() throw() { } + + + bad_alloc(const bad_alloc&) = default; + bad_alloc& operator=(const bad_alloc&) = default; + + + + + virtual ~bad_alloc() throw(); + + + virtual const char* what() const throw(); + }; + + + class bad_array_new_length : public bad_alloc + { + public: + bad_array_new_length() throw() { } + + + + virtual ~bad_array_new_length() throw(); + + + virtual const char* what() const throw(); + }; + + + + enum class align_val_t: size_t {}; + + + struct nothrow_t + { + + explicit nothrow_t() = default; + + }; + + extern const nothrow_t nothrow; + + + + typedef void (*new_handler)(); + + + + new_handler set_new_handler(new_handler) throw(); + + + + new_handler get_new_handler() noexcept; + +} +# 126 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +[[__nodiscard__]] void* operator new(std::size_t) + __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t) + __attribute__((__externally_visible__)); +void operator delete(void*) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*) noexcept + __attribute__((__externally_visible__)); + + + + + + +[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); +void operator delete[](void*, const std::nothrow_t&) noexcept + __attribute__((__externally_visible__)); + +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete(void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete(void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) + __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); +void operator delete[](void*, std::align_val_t) + noexcept __attribute__((__externally_visible__)); +void operator delete[](void*, std::align_val_t, const std::nothrow_t&) + noexcept __attribute__((__externally_visible__)); +# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept +{ return __p; } +[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept +{ return __p; } + + +inline void operator delete (void*, void*) noexcept { } +inline void operator delete[](void*, void*) noexcept { } + +} + + +namespace std +{ + + + + template + [[nodiscard]] constexpr _Tp* + launder(_Tp* __p) noexcept + { return __builtin_launder(__p); } + + + + + template + void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; + template + void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; + + void launder(void*) = delete; + void launder(const void*) = delete; + void launder(volatile void*) = delete; + void launder(const volatile void*) = delete; + + + + + + + +} +# 236 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 +#pragma GCC visibility pop +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + template + class __new_allocator + { + public: + typedef _Tp value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + + template + struct rebind + { typedef __new_allocator<_Tp1> other; }; + + + + + + typedef std::true_type propagate_on_container_move_assignment; + + + __attribute__((__always_inline__)) + + __new_allocator() noexcept { } + + __attribute__((__always_inline__)) + + __new_allocator(const __new_allocator&) noexcept { } + + template + __attribute__((__always_inline__)) + + __new_allocator(const __new_allocator<_Tp1>&) noexcept { } + + + ~__new_allocator() noexcept { } + + pointer + address(reference __x) const noexcept + { return std::__addressof(__x); } + + const_pointer + address(const_reference __x) const noexcept + { return std::__addressof(__x); } +# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + [[__nodiscard__]] _Tp* + allocate(size_type __n, const void* = static_cast(0)) + { + + + + static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); + + + if (__builtin_expect(__n > this->_M_max_size(), false)) + { + + + if (__n > (std::size_t(-1) / sizeof(_Tp))) + std::__throw_bad_array_new_length(); + std::__throw_bad_alloc(); + } + + + if (alignof(_Tp) > 16UL) + { + std::align_val_t __al = std::align_val_t(alignof(_Tp)); + return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp), + __al)); + } + + return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp))); + } + + + void + deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) + { + + + + + + + + if (alignof(_Tp) > 16UL) + { + __builtin_operator_delete((__p), + std::align_val_t(alignof(_Tp))); + return; + } + + __builtin_operator_delete((__p)); + } + + + + + + + __attribute__((__always_inline__)) + size_type + max_size() const noexcept + { return _M_max_size(); } + + + template + __attribute__((__always_inline__)) + void + construct(_Up* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } + + template + __attribute__((__always_inline__)) + void + destroy(_Up* __p) + noexcept(std::is_nothrow_destructible<_Up>::value) + { __p->~_Up(); } +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 + template + friend __attribute__((__always_inline__)) bool + operator==(const __new_allocator&, const __new_allocator<_Up>&) + noexcept + { return true; } + + + template + friend __attribute__((__always_inline__)) bool + operator!=(const __new_allocator&, const __new_allocator<_Up>&) + noexcept + { return false; } + + + private: + __attribute__((__always_inline__)) + constexpr size_type + _M_max_size() const noexcept + { + + return std::size_t(9223372036854775807L) / sizeof(_Tp); + + + + } + }; + + +} +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3 + + +namespace std +{ +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 + template + using __allocator_base = __new_allocator<_Tp>; +} +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 1 3 +# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 + template + class allocator; + + template<> + class allocator; + + + + + template + struct uses_allocator; + + template + struct allocator_traits; + + + + + +} +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + template<> + class allocator + { + public: + typedef void value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + + + typedef void* pointer; + typedef const void* const_pointer; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + using propagate_on_container_move_assignment = true_type; + + using is_always_equal + + = true_type; +# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + }; +# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + template + class allocator : public __allocator_base<_Tp> + { + public: + typedef _Tp value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + + + + typedef _Tp* pointer; + typedef const _Tp* const_pointer; + typedef _Tp& reference; + typedef const _Tp& const_reference; + + template + struct rebind + { typedef allocator<_Tp1> other; }; + + + + + + using propagate_on_container_move_assignment = true_type; + + using is_always_equal + + = true_type; + + + + + __attribute__((__always_inline__)) + + allocator() noexcept { } + + __attribute__((__always_inline__)) + + allocator(const allocator& __a) noexcept + : __allocator_base<_Tp>(__a) { } + + + + allocator& operator=(const allocator&) = default; + + + template + __attribute__((__always_inline__)) + + allocator(const allocator<_Tp1>&) noexcept { } + + __attribute__((__always_inline__)) + + + + ~allocator() noexcept { } +# 214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 + friend __attribute__((__always_inline__)) + bool + operator==(const allocator&, const allocator&) noexcept + { return true; } + + + friend __attribute__((__always_inline__)) + bool + operator!=(const allocator&, const allocator&) noexcept + { return false; } + + + + }; + + + + + + + template + __attribute__((__always_inline__)) + inline bool + operator==(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return true; } + + + template + __attribute__((__always_inline__)) + inline bool + operator!=(const allocator<_T1>&, const allocator<_T2>&) + noexcept + { return false; } + + + + + + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + template + class allocator + { + public: + typedef _Tp value_type; + template allocator(const allocator<_Up>&) { } + }; + + + + + + + + extern template class allocator; + extern template class allocator; + + + + + + +} +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 1 3 +# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + inline void + destroy_at(_Tp* __location) + { + if constexpr (201703L > 201703L && is_array_v<_Tp>) + { + for (auto& __x : *__location) + std::destroy_at(std::__addressof(__x)); + } + else + __location->~_Tp(); + } +# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + template + + inline void + _Construct(_Tp* __p, _Args&&... __args) + { +# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + } +# 132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 + template + inline void + _Construct_novalue(_T1* __p) + { ::new((void*)__p) _T1; } + + template + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last); + + + + + template + constexpr inline void + _Destroy(_Tp* __pointer) + { + + + + __pointer->~_Tp(); + + } + + template + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator __first, _ForwardIterator __last) + { + for (; __first != __last; ++__first) + std::_Destroy(std::__addressof(*__first)); + } + }; + + template<> + struct _Destroy_aux + { + template + static void + __destroy(_ForwardIterator, _ForwardIterator) { } + }; + + + + + + + template + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: + __destroy(__first, __last); + } + + template + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + for (; __count > 0; (void)++__first, --__count) + std::_Destroy(std::__addressof(*__first)); + return __first; + } + }; + + template<> + struct _Destroy_n_aux + { + template + static _ForwardIterator + __destroy_n(_ForwardIterator __first, _Size __count) + { + std::advance(__first, __count); + return __first; + } + }; + + + + + + + template + inline _ForwardIterator + _Destroy_n(_ForwardIterator __first, _Size __count) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _Value_type; + + + static_assert(is_destructible<_Value_type>::value, + "value type is destructible"); + + + + + + return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: + __destroy_n(__first, __count); + } + + + template + inline void + destroy(_ForwardIterator __first, _ForwardIterator __last) + { + std::_Destroy(__first, __last); + } + + template + inline _ForwardIterator + destroy_n(_ForwardIterator __first, _Size __count) + { + return std::_Destroy_n(__first, __count); + } + + + +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 1 3 +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 1 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + struct __allocator_traits_base + { + template + struct __rebind : __replace_first_arg<_Tp, _Up> + { + static_assert(is_same< + typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, + _Tp>::value, + "allocator_traits::rebind_alloc must be A"); + }; + + template + struct __rebind<_Tp, _Up, + __void_t::other>> + { + using type = typename _Tp::template rebind<_Up>::other; + + static_assert(is_same< + typename _Tp::template rebind::other, + _Tp>::value, + "allocator_traits::rebind_alloc must be A"); + }; + + protected: + template + using __pointer = typename _Tp::pointer; + template + using __c_pointer = typename _Tp::const_pointer; + template + using __v_pointer = typename _Tp::void_pointer; + template + using __cv_pointer = typename _Tp::const_void_pointer; + template + using __pocca = typename _Tp::propagate_on_container_copy_assignment; + template + using __pocma = typename _Tp::propagate_on_container_move_assignment; + template + using __pocs = typename _Tp::propagate_on_container_swap; + template + using __equal = __type_identity; + }; + + template + using __alloc_rebind + = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; +# 104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct allocator_traits : __allocator_traits_base + { + + typedef _Alloc allocator_type; + + typedef typename _Alloc::value_type value_type; + + + + + + + using pointer = __detected_or_t; + + private: + + template class _Func, typename _Tp, typename = void> + struct _Ptr + { + using type = typename pointer_traits::template rebind<_Tp>; + }; + + template class _Func, typename _Tp> + struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> + { + using type = _Func<_Alloc>; + }; + + + template + struct _Diff + { using type = typename pointer_traits<_PtrT>::difference_type; }; + + template + struct _Diff<_A2, _PtrT, __void_t> + { using type = typename _A2::difference_type; }; + + + template + struct _Size : make_unsigned<_DiffT> { }; + + template + struct _Size<_A2, _DiffT, __void_t> + { using type = typename _A2::size_type; }; + + public: + + + + + + + using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; + + + + + + + + using void_pointer = typename _Ptr<__v_pointer, void>::type; + + + + + + + + using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; + + + + + + + + using difference_type = typename _Diff<_Alloc, pointer>::type; + + + + + + + + using size_type = typename _Size<_Alloc, difference_type>::type; + + + + + + + + using propagate_on_container_copy_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_move_assignment + = __detected_or_t; + + + + + + + + using propagate_on_container_swap + = __detected_or_t; + + + + + + + + using is_always_equal + = typename __detected_or_t, __equal, _Alloc>::type; + + template + using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; + template + using rebind_traits = allocator_traits>; + + private: + template + static constexpr auto + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) + -> decltype(__a.allocate(__n, __hint)) + { return __a.allocate(__n, __hint); } + + template + static constexpr pointer + _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) + { return __a.allocate(__n); } + + template + struct __construct_helper + { + template()->construct( + std::declval<_Tp*>(), std::declval<_Args>()...))> + static true_type __test(int); + + template + static false_type __test(...); + + using type = decltype(__test<_Alloc>(0)); + }; + + template + using __has_construct + = typename __construct_helper<_Tp, _Args...>::type; + + template + static constexpr _Require<__has_construct<_Tp, _Args...>> + _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) + { __a.construct(__p, std::forward<_Args>(__args)...); } + + template + static constexpr + _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, + is_constructible<_Tp, _Args...>>> + _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) + { + + ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); + + + + } + + template + static constexpr auto + _S_destroy(_Alloc2& __a, _Tp* __p, int) + noexcept(noexcept(__a.destroy(__p))) + -> decltype(__a.destroy(__p)) + { __a.destroy(__p); } + + template + static constexpr void + _S_destroy(_Alloc2&, _Tp* __p, ...) + noexcept(std::is_nothrow_destructible<_Tp>::value) + { std::_Destroy(__p); } + + template + static constexpr auto + _S_max_size(_Alloc2& __a, int) + -> decltype(__a.max_size()) + { return __a.max_size(); } + + template + static constexpr size_type + _S_max_size(_Alloc2&, ...) + { + + + return __gnu_cxx::__numeric_traits::__max + / sizeof(value_type); + } + + template + static constexpr auto + _S_select(_Alloc2& __a, int) + -> decltype(__a.select_on_container_copy_construction()) + { return __a.select_on_container_copy_construction(); } + + template + static constexpr _Alloc2 + _S_select(_Alloc2& __a, ...) + { return __a; } + + public: +# 331 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n) + { return __a.allocate(__n); } +# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__]] static pointer + allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) + { return _S_allocate(__a, __n, __hint, 0); } +# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static void + deallocate(_Alloc& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 373 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + static auto + construct(_Alloc& __a, _Tp* __p, _Args&&... __args) + noexcept(noexcept(_S_construct(__a, __p, + std::forward<_Args>(__args)...))) + -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) + { _S_construct(__a, __p, std::forward<_Args>(__args)...); } +# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + static void + destroy(_Alloc& __a, _Tp* __p) + noexcept(noexcept(_S_destroy(__a, __p, 0))) + { _S_destroy(__a, __p, 0); } +# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static size_type + max_size(const _Alloc& __a) noexcept + { return _S_max_size(__a, 0); } +# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + static _Alloc + select_on_container_copy_construction(const _Alloc& __rhs) + { return _S_select(__rhs, 0); } + }; +# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct allocator_traits> + { + + using allocator_type = allocator<_Tp>; + + + using value_type = _Tp; + + + using pointer = _Tp*; + + + using const_pointer = const _Tp*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + using propagate_on_container_copy_assignment = false_type; + + + using propagate_on_container_move_assignment = true_type; + + + using propagate_on_container_swap = false_type; + + + using is_always_equal = true_type; + + template + using rebind_alloc = allocator<_Up>; + + template + using rebind_traits = allocator_traits>; +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n) + { return __a.allocate(__n); } +# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__nodiscard__,__gnu__::__always_inline__]] + static pointer + allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) + { + + return __a.allocate(__n, __hint); + + + + } +# 513 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + [[__gnu__::__always_inline__]] + static void + deallocate(allocator_type& __a, pointer __p, size_type __n) + { __a.deallocate(__p, __n); } +# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, + _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { + + __a.construct(__p, std::forward<_Args>(__args)...); + + + + } +# 550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { + + __a.destroy(__p); + + + + } + + + + + + + [[__gnu__::__always_inline__]] + static size_type + max_size(const allocator_type& __a __attribute__((__unused__))) noexcept + { + + return __a.max_size(); + + + + } + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; + + + template<> + struct allocator_traits> + { + + using allocator_type = allocator; + + + using value_type = void; + + + using pointer = void*; + + + using const_pointer = const void*; + + + using void_pointer = void*; + + + using const_void_pointer = const void*; + + + using difference_type = std::ptrdiff_t; + + + using size_type = std::size_t; + + + using propagate_on_container_copy_assignment = false_type; + + + using propagate_on_container_move_assignment = true_type; + + + using propagate_on_container_swap = false_type; + + + using is_always_equal = true_type; + + template + using rebind_alloc = allocator<_Up>; + + template + using rebind_traits = allocator_traits>; + + + static void* + allocate(allocator_type&, size_type, const void* = nullptr) = delete; + + + static void + deallocate(allocator_type&, void*, size_type) = delete; +# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + construct(allocator_type&, _Up* __p, _Args&&... __args) + noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) + { std::_Construct(__p, std::forward<_Args>(__args)...); } +# 669 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + static void + destroy(allocator_type&, _Up* __p) + noexcept(is_nothrow_destructible<_Up>::value) + { std::_Destroy(__p); } + + + static size_type + max_size(const allocator_type&) = delete; + + + + + + + [[__gnu__::__always_inline__]] + static allocator_type + select_on_container_copy_construction(const allocator_type& __rhs) + { return __rhs; } + }; +# 707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_copy(_Alloc& __one, const _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocca = + typename __traits::propagate_on_container_copy_assignment::type; + + if constexpr (__pocca::value) + __one = __two; + + + + } + + template + [[__gnu__::__always_inline__]] + constexpr _Alloc + __alloc_on_copy(const _Alloc& __a) + { + typedef allocator_traits<_Alloc> __traits; + return __traits::select_on_container_copy_construction(__a); + } +# 744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_move(_Alloc& __one, _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocma + = typename __traits::propagate_on_container_move_assignment::type; + + if constexpr (__pocma::value) + __one = std::move(__two); + + + + } +# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + [[__gnu__::__always_inline__]] + constexpr inline void + __alloc_on_swap(_Alloc& __one, _Alloc& __two) + { + using __traits = allocator_traits<_Alloc>; + using __pocs = typename __traits::propagate_on_container_swap::type; + + if constexpr (__pocs::value) + { + using std::swap; + swap(__one, __two); + } + + + + } + + template, + typename = void> + struct __is_alloc_insertable_impl + : false_type + { }; + + template + struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, + __void_t::construct( + std::declval<_Alloc&>(), std::declval<_ValueT*>(), + std::declval<_Tp>()))>> + : true_type + { }; + + + + + template + struct __is_copy_insertable + : __is_alloc_insertable_impl<_Alloc, + typename _Alloc::value_type const&>::type + { }; + + + + template + struct __is_copy_insertable> + : is_copy_constructible<_Tp> + { }; + + + + + + template + struct __is_move_insertable + : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type + { }; + + + + template + struct __is_move_insertable> + : is_move_constructible<_Tp> + { }; + + + + template + struct __is_allocator : false_type { }; + + template + struct __is_allocator<_Alloc, + __void_t().allocate(size_t{}))>> + : true_type { }; + + template + using _RequireAllocator + = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; + + template + using _RequireNotAllocator + = typename enable_if::value, _Alloc>::type; +# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + struct __alloc_swap + { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; + + template + struct __alloc_swap<_Alloc, false> + { + static void + _S_do_it(_Alloc& __one, _Alloc& __two) noexcept + { + + if (__one != __two) + swap(__one, __two); + } + }; + + + template, + is_nothrow_move_constructible>::value> + struct __shrink_to_fit_aux + { static bool _S_do_it(_Tp&) noexcept { return false; } }; + + template + struct __shrink_to_fit_aux<_Tp, true> + { + + static bool + _S_do_it(_Tp& __c) noexcept + { + + try + { + _Tp(__make_move_if_noexcept_iterator(__c.begin()), + __make_move_if_noexcept_iterator(__c.end()), + __c.get_allocator()).swap(__c); + return true; + } + catch(...) + { return false; } + + + + } + }; +# 925 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 + template + + void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + _Allocator& __alloc) + { + for (; __first != __last; ++__first) + + + + allocator_traits<_Allocator>::destroy(__alloc, + std::__addressof(*__first)); + + } + + + template + __attribute__((__always_inline__)) + inline void + _Destroy(_ForwardIterator __first, _ForwardIterator __last, + allocator<_Tp>&) + { + std::_Destroy(__first, __last); + } + + + + +} +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 2 3 + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + + + +template + struct __alloc_traits + + : std::allocator_traits<_Alloc> + + { + typedef _Alloc allocator_type; + + typedef std::allocator_traits<_Alloc> _Base_type; + typedef typename _Base_type::value_type value_type; + typedef typename _Base_type::pointer pointer; + typedef typename _Base_type::const_pointer const_pointer; + typedef typename _Base_type::size_type size_type; + typedef typename _Base_type::difference_type difference_type; + + typedef value_type& reference; + typedef const value_type& const_reference; + using _Base_type::allocate; + using _Base_type::deallocate; + using _Base_type::construct; + using _Base_type::destroy; + using _Base_type::max_size; + + private: + template + using __is_custom_pointer + = std::__and_, + std::__not_>>; + + public: + + template + [[__gnu__::__always_inline__]] + static constexpr + std::__enable_if_t<__is_custom_pointer<_Ptr>::value> + construct(_Alloc& __a, _Ptr __p, _Args&&... __args) + noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), + std::forward<_Args>(__args)...))) + { + _Base_type::construct(__a, std::__to_address(__p), + std::forward<_Args>(__args)...); + } + + + template + [[__gnu__::__always_inline__]] + static constexpr + std::__enable_if_t<__is_custom_pointer<_Ptr>::value> + destroy(_Alloc& __a, _Ptr __p) + noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) + { _Base_type::destroy(__a, std::__to_address(__p)); } + + [[__gnu__::__always_inline__]] + static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) + { return _Base_type::select_on_container_copy_construction(__a); } + + [[__gnu__::__always_inline__]] + static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) + { std::__alloc_on_swap(__a, __b); } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_copy_assign() + { return _Base_type::propagate_on_container_copy_assignment::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_move_assign() + { return _Base_type::propagate_on_container_move_assignment::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_propagate_on_swap() + { return _Base_type::propagate_on_container_swap::value; } + + [[__gnu__::__always_inline__]] + static constexpr bool _S_always_equal() + { return _Base_type::is_always_equal::value; } + + __attribute__((__always_inline__)) + static constexpr bool _S_nothrow_move() + { return _S_propagate_on_move_assign() || _S_always_equal(); } + + template + struct rebind + { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; +# 180 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 + }; + + +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + constexpr bool + __check_constructible() + { + + + + + + static_assert(is_constructible<_ValueType, _Tp>::value, + "result type must be constructible from input type"); + + return true; + } +# 110 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + + _ForwardIterator + __do_uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + _ForwardIterator __cur = __result; + try + { + for (; __first != __last; ++__first, (void)++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + catch(...) + { + std::_Destroy(__result, __cur); + throw; + } + } + + template + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { return std::__do_uninit_copy(__first, __last, __result); } + }; + + template<> + struct __uninitialized_copy + { + template + static _ForwardIterator + __uninit_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { return std::copy(__first, __last, __result); } + }; +# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_copy(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + typedef typename iterator_traits<_InputIterator>::value_type + _ValueType1; + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType2; + + + + + const bool __can_memmove = __is_trivial(_ValueType1); + + + + + using _From = decltype(*__first); + + const bool __assignable + = __is_trivial(_ValueType2) && __is_assignable(_ValueType2&, _From) && std::__check_constructible<_ValueType2, _From>(); + + return std::__uninitialized_copy<__can_memmove && __assignable>:: + __uninit_copy(__first, __last, __result); + } + + + + template + void + __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + _ForwardIterator __cur = __first; + try + { + for (; __cur != __last; ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + + template + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { std::__do_uninit_fill(__first, __last, __x); } + }; + + template<> + struct __uninitialized_fill + { + template + static void + __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { std::fill(__first, __last, __x); } + }; +# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline void + uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + const bool __can_fill + = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>(); + + std::__uninitialized_fill<__can_fill>:: + __uninit_fill(__first, __last, __x); + } + + + + template + + _ForwardIterator + __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) + { + _ForwardIterator __cur = __first; + try + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct(std::__addressof(*__cur), __x); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + + template + struct __uninitialized_fill_n + { + template + static _ForwardIterator + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { return std::__do_uninit_fill_n(__first, __n, __x); } + }; + + template<> + struct __uninitialized_fill_n + { + template + static _ForwardIterator + __uninit_fill_n(_ForwardIterator __first, _Size __n, + const _Tp& __x) + { return std::fill_n(__first, __n, __x); } + }; +# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + + + const bool __can_fill + = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>() + + + + && __is_integer<_Size>::__value; + + return __uninitialized_fill_n<__can_fill>:: + __uninit_fill_n(__first, __n, __x); + } +# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + + _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + { + _ForwardIterator __cur = __result; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __first != __last; ++__first, (void)++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), *__first); + return __cur; + } + catch(...) + { + std::_Destroy(__result, __cur, __alloc); + throw; + } + } + + + template + + inline _ForwardIterator + __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, allocator<_Tp>&) + { + + + + + return std::uninitialized_copy(__first, __last, __result); + } + + + template + + inline _ForwardIterator + __uninitialized_move_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + { + return std::__uninitialized_copy_a(std::make_move_iterator(__first), + std::make_move_iterator(__last), + __result, __alloc); + } + + template + + inline _ForwardIterator + __uninitialized_move_if_noexcept_a(_InputIterator __first, + _InputIterator __last, + _ForwardIterator __result, + _Allocator& __alloc) + { + return std::__uninitialized_copy_a + (std::__make_move_if_noexcept_iterator(__first), + std::__make_move_if_noexcept_iterator(__last), __result, __alloc); + } + + template + + void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur != __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + template + + inline void + __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __x, allocator<_Tp2>&) + { + + + + + std::uninitialized_fill(__first, __last, __x); + } + + + template + + _ForwardIterator + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, (void) ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur), __x); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + template + + inline _ForwardIterator + __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, + const _Tp& __x, allocator<_Tp2>&) + { + + + + + return std::uninitialized_fill_n(__first, __n, __x); + } +# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + __uninitialized_copy_move(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _ForwardIterator __result, + _Allocator& __alloc) + { + _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, + __result, + __alloc); + try + { + return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); + } + catch(...) + { + std::_Destroy(__result, __mid, __alloc); + throw; + } + } + + + + + + template + inline _ForwardIterator + __uninitialized_move_copy(_InputIterator1 __first1, + _InputIterator1 __last1, + _InputIterator2 __first2, + _InputIterator2 __last2, + _ForwardIterator __result, + _Allocator& __alloc) + { + _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, + __result, + __alloc); + try + { + return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); + } + catch(...) + { + std::_Destroy(__result, __mid, __alloc); + throw; + } + } + + + + + template + inline _ForwardIterator + __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, + const _Tp& __x, _InputIterator __first, + _InputIterator __last, _Allocator& __alloc) + { + std::__uninitialized_fill_a(__result, __mid, __x, __alloc); + try + { + return std::__uninitialized_move_a(__first, __last, __mid, __alloc); + } + catch(...) + { + std::_Destroy(__result, __mid, __alloc); + throw; + } + } + + + + + template + inline void + __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, + _ForwardIterator __first2, + _ForwardIterator __last2, const _Tp& __x, + _Allocator& __alloc) + { + _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, + __first2, + __alloc); + try + { + std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); + } + catch(...) + { + std::_Destroy(__first2, __mid2, __alloc); + throw; + } + } +# 592 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + _ForwardIterator __cur = __first; + try + { + for (; __cur != __last; ++__cur) + std::_Construct(std::__addressof(*__cur)); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_1 + { + template + static void + __uninit_default(_ForwardIterator __first, _ForwardIterator __last) + { + if (__first == __last) + return; + + typename iterator_traits<_ForwardIterator>::value_type* __val + = std::__addressof(*__first); + std::_Construct(__val); + if (++__first != __last) + std::fill(__first, __last, *__val); + } + }; + + template + struct __uninitialized_default_n_1 + { + template + + static _ForwardIterator + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur = __first; + try + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct(std::__addressof(*__cur)); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_n_1 + { + template + + static _ForwardIterator + __uninit_default_n(_ForwardIterator __first, _Size __n) + { + if (__n > 0) + { + typename iterator_traits<_ForwardIterator>::value_type* __val + = std::__addressof(*__first); + std::_Construct(__val); + ++__first; + __first = std::fill_n(__first, __n - 1, *__val); + } + return __first; + } + }; + + + + template + inline void + __uninitialized_default(_ForwardIterator __first, + _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + const bool __assignable = is_copy_assignable<_ValueType>::value; + + std::__uninitialized_default_1<__is_trivial(_ValueType) + && __assignable>:: + __uninit_default(__first, __last); + } + + + + template + + inline _ForwardIterator + __uninitialized_default_n(_ForwardIterator __first, _Size __n) + { + + + + + + + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + constexpr bool __can_fill + = __and_, is_copy_assignable<_ValueType>>::value; + + return __uninitialized_default_n_1<__is_trivial(_ValueType) + && __can_fill>:: + __uninit_default_n(__first, __n); + } + + + + + + template + void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __cur != __last; ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + template + inline void + __uninitialized_default_a(_ForwardIterator __first, + _ForwardIterator __last, + allocator<_Tp>&) + { std::__uninitialized_default(__first, __last); } + + + + + + template + _ForwardIterator + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + _Allocator& __alloc) + { + _ForwardIterator __cur = __first; + try + { + typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; + for (; __n > 0; --__n, (void) ++__cur) + __traits::construct(__alloc, std::__addressof(*__cur)); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur, __alloc); + throw; + } + } + + + + + template + + inline _ForwardIterator + __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, + allocator<_Tp>&) + { return std::__uninitialized_default_n(__first, __n); } + + + template + struct __uninitialized_default_novalue_1 + { + template + static void + __uninit_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + _ForwardIterator __cur = __first; + try + { + for (; __cur != __last; ++__cur) + std::_Construct_novalue(std::__addressof(*__cur)); + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_novalue_1 + { + template + static void + __uninit_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + } + }; + + template + struct __uninitialized_default_novalue_n_1 + { + template + static _ForwardIterator + __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) + { + _ForwardIterator __cur = __first; + try + { + for (; __n > 0; --__n, (void) ++__cur) + std::_Construct_novalue(std::__addressof(*__cur)); + return __cur; + } + catch(...) + { + std::_Destroy(__first, __cur); + throw; + } + } + }; + + template<> + struct __uninitialized_default_novalue_n_1 + { + template + static _ForwardIterator + __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) + { return std::next(__first, __n); } + }; + + + + template + inline void + __uninitialized_default_novalue(_ForwardIterator __first, + _ForwardIterator __last) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + std::__uninitialized_default_novalue_1< + is_trivially_default_constructible<_ValueType>::value>:: + __uninit_default_novalue(__first, __last); + } + + + + template + inline _ForwardIterator + __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) + { + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType; + + return __uninitialized_default_novalue_n_1< + is_trivially_default_constructible<_ValueType>::value>:: + __uninit_default_novalue_n(__first, __n); + } + + template + _ForwardIterator + __uninitialized_copy_n(_InputIterator __first, _Size __n, + _ForwardIterator __result, input_iterator_tag) + { + _ForwardIterator __cur = __result; + try + { + for (; __n > 0; --__n, (void) ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return __cur; + } + catch(...) + { + std::_Destroy(__result, __cur); + throw; + } + } + + template + inline _ForwardIterator + __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, + _ForwardIterator __result, + random_access_iterator_tag) + { return std::uninitialized_copy(__first, __first + __n, __result); } + + template + pair<_InputIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, + _ForwardIterator __result, input_iterator_tag) + { + _ForwardIterator __cur = __result; + try + { + for (; __n > 0; --__n, (void) ++__first, ++__cur) + std::_Construct(std::__addressof(*__cur), *__first); + return {__first, __cur}; + } + catch(...) + { + std::_Destroy(__result, __cur); + throw; + } + } + + template + inline pair<_RandomAccessIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, + _ForwardIterator __result, + random_access_iterator_tag) + { + auto __second_res = uninitialized_copy(__first, __first + __n, __result); + auto __first_res = std::next(__first, __n); + return {__first_res, __second_res}; + } +# 947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_copy_n(_InputIterator __first, _Size __n, + _ForwardIterator __result) + { return std::__uninitialized_copy_n(__first, __n, __result, + std::__iterator_category(__first)); } + + + template + inline pair<_InputIterator, _ForwardIterator> + __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, + _ForwardIterator __result) + { + return + std::__uninitialized_copy_n_pair(__first, __n, __result, + std::__iterator_category(__first)); + } +# 976 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline void + uninitialized_default_construct(_ForwardIterator __first, + _ForwardIterator __last) + { + __uninitialized_default_novalue(__first, __last); + } +# 991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) + { + return __uninitialized_default_novalue_n(__first, __count); + } + + + + + + + + template + inline void + uninitialized_value_construct(_ForwardIterator __first, + _ForwardIterator __last) + { + return __uninitialized_default(__first, __last); + } +# 1019 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) + { + return __uninitialized_default_n(__first, __count); + } +# 1034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline _ForwardIterator + uninitialized_move(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result) + { + return std::uninitialized_copy + (std::make_move_iterator(__first), + std::make_move_iterator(__last), __result); + } +# 1052 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + template + inline pair<_InputIterator, _ForwardIterator> + uninitialized_move_n(_InputIterator __first, _Size __count, + _ForwardIterator __result) + { + auto __res = std::__uninitialized_copy_n_pair + (std::make_move_iterator(__first), + __count, __result); + return {__res.first.base(), __res.second}; + } + + + + + + template + + inline void + __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig, + _Allocator& __alloc) + noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, + __dest, std::move(*__orig))) + && noexcept(std::allocator_traits<_Allocator>::destroy( + __alloc, std::__addressof(*__orig)))) + { + typedef std::allocator_traits<_Allocator> __traits; + __traits::construct(__alloc, __dest, std::move(*__orig)); + __traits::destroy(__alloc, std::__addressof(*__orig)); + } + + + + template + struct __is_bitwise_relocatable + : is_trivial<_Tp> { }; + + template + + inline _ForwardIterator + __relocate_a_1(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), + std::addressof(*__first), + __alloc))) + { + typedef typename iterator_traits<_InputIterator>::value_type + _ValueType; + typedef typename iterator_traits<_ForwardIterator>::value_type + _ValueType2; + static_assert(std::is_same<_ValueType, _ValueType2>::value, + "relocation is only possible for values of the same type"); + _ForwardIterator __cur = __result; + for (; __first != __last; ++__first, (void)++__cur) + std::__relocate_object_a(std::__addressof(*__cur), + std::__addressof(*__first), __alloc); + return __cur; + } + + + template + + inline __enable_if_t::value, _Tp*> + __relocate_a_1(_Tp* __first, _Tp* __last, + _Tp* __result, + [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept + { + ptrdiff_t __count = __last - __first; + if (__count > 0) + { +# 1132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 + __builtin_memmove(__result, __first, __count * sizeof(_Tp)); + } + return __result + __count; + } + + + template + + inline _ForwardIterator + __relocate_a(_InputIterator __first, _InputIterator __last, + _ForwardIterator __result, _Allocator& __alloc) + noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result), __alloc))) + { + return std::__relocate_a_1(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result), __alloc); + } + + + + + + + +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 1 3 +# 78 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template + struct _Vector_base + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Tp>::other _Tp_alloc_type; + typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer + pointer; + + struct _Vector_impl_data + { + pointer _M_start; + pointer _M_finish; + pointer _M_end_of_storage; + + + _Vector_impl_data() noexcept + : _M_start(), _M_finish(), _M_end_of_storage() + { } + + + + _Vector_impl_data(_Vector_impl_data&& __x) noexcept + : _M_start(__x._M_start), _M_finish(__x._M_finish), + _M_end_of_storage(__x._M_end_of_storage) + { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); } + + + + void + _M_copy_data(_Vector_impl_data const& __x) noexcept + { + _M_start = __x._M_start; + _M_finish = __x._M_finish; + _M_end_of_storage = __x._M_end_of_storage; + } + + + void + _M_swap_data(_Vector_impl_data& __x) noexcept + { + + + _Vector_impl_data __tmp; + __tmp._M_copy_data(*this); + _M_copy_data(__x); + __x._M_copy_data(__tmp); + } + }; + + struct _Vector_impl + : public _Tp_alloc_type, public _Vector_impl_data + { + + _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value) + + : _Tp_alloc_type() + { } + + + _Vector_impl(_Tp_alloc_type const& __a) noexcept + : _Tp_alloc_type(__a) + { } + + + + + + _Vector_impl(_Vector_impl&& __x) noexcept + : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x)) + { } + + + _Vector_impl(_Tp_alloc_type&& __a) noexcept + : _Tp_alloc_type(std::move(__a)) + { } + + + _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept + : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv)) + { } +# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + }; + + public: + typedef _Alloc allocator_type; + + + _Tp_alloc_type& + _M_get_Tp_allocator() noexcept + { return this->_M_impl; } + + + const _Tp_alloc_type& + _M_get_Tp_allocator() const noexcept + { return this->_M_impl; } + + + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_get_Tp_allocator()); } + + + _Vector_base() = default; + + + + + + _Vector_base(const allocator_type& __a) noexcept + : _M_impl(__a) { } + + + + + _Vector_base(size_t __n) + : _M_impl() + { _M_create_storage(__n); } + + + + _Vector_base(size_t __n, const allocator_type& __a) + : _M_impl(__a) + { _M_create_storage(__n); } + + + _Vector_base(_Vector_base&&) = default; + + + + + _Vector_base(_Tp_alloc_type&& __a) noexcept + : _M_impl(std::move(__a)) { } + + + _Vector_base(_Vector_base&& __x, const allocator_type& __a) + : _M_impl(__a) + { + if (__x.get_allocator() == __a) + this->_M_impl._M_swap_data(__x._M_impl); + else + { + size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start; + _M_create_storage(__n); + } + } + + + + _Vector_base(const allocator_type& __a, _Vector_base&& __x) + : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl)) + { } + + + + ~_Vector_base() noexcept + { + _M_deallocate(_M_impl._M_start, + _M_impl._M_end_of_storage - _M_impl._M_start); + } + + public: + _Vector_impl _M_impl; + + + pointer + _M_allocate(size_t __n) + { + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; + return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer(); + } + + + void + _M_deallocate(pointer __p, size_t __n) + { + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; + if (__p) + _Tr::deallocate(_M_impl, __p, __n); + } + + protected: + + void + _M_create_storage(size_t __n) + { + this->_M_impl._M_start = this->_M_allocate(__n); + this->_M_impl._M_finish = this->_M_impl._M_start; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + } + }; +# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template > + class vector : protected _Vector_base<_Tp, _Alloc> + { +# 437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + static_assert(is_same::type, _Tp>::value, + "std::vector must have a non-const, non-volatile value_type"); + + static_assert(is_same::value, + "std::vector must have the same value_type as its allocator"); + + + + typedef _Vector_base<_Tp, _Alloc> _Base; + typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; + typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; + + public: + typedef _Tp value_type; + typedef typename _Base::pointer pointer; + typedef typename _Alloc_traits::const_pointer const_pointer; + typedef typename _Alloc_traits::reference reference; + typedef typename _Alloc_traits::const_reference const_reference; + typedef __gnu_cxx::__normal_iterator iterator; + typedef __gnu_cxx::__normal_iterator + const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Alloc allocator_type; + + private: + + static constexpr bool + _S_nothrow_relocate(true_type) + { + return noexcept(std::__relocate_a(std::declval(), + std::declval(), + std::declval(), + std::declval<_Tp_alloc_type&>())); + } + + static constexpr bool + _S_nothrow_relocate(false_type) + { return false; } + + static constexpr bool + _S_use_relocate() + { + + + + return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{}); + } + + static pointer + _S_do_relocate(pointer __first, pointer __last, pointer __result, + _Tp_alloc_type& __alloc, true_type) noexcept + { + return std::__relocate_a(__first, __last, __result, __alloc); + } + + static pointer + _S_do_relocate(pointer, pointer, pointer __result, + _Tp_alloc_type&, false_type) noexcept + { return __result; } + + static pointer + _S_relocate(pointer __first, pointer __last, pointer __result, + _Tp_alloc_type& __alloc) noexcept + { + + + return std::__relocate_a(__first, __last, __result, __alloc); + + + + + } + + + protected: + using _Base::_M_allocate; + using _Base::_M_deallocate; + using _Base::_M_impl; + using _Base::_M_get_Tp_allocator; + + public: + + + + + + + + vector() = default; +# 537 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + explicit + + vector(const allocator_type& __a) noexcept + : _Base(__a) { } +# 551 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + explicit + + vector(size_type __n, const allocator_type& __a = allocator_type()) + : _Base(_S_check_init_len(__n, __a), __a) + { _M_default_initialize(__n); } +# 566 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector(size_type __n, const value_type& __value, + const allocator_type& __a = allocator_type()) + : _Base(_S_check_init_len(__n, __a), __a) + { _M_fill_initialize(__n, __value); } +# 598 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector(const vector& __x) + : _Base(__x.size(), + _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator())) + { + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__x.begin(), __x.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } +# 617 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector(vector&&) noexcept = default; + + + + vector(const vector& __x, const __type_identity_t& __a) + : _Base(__x.size(), __a) + { + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__x.begin(), __x.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } + + private: + + vector(vector&& __rv, const allocator_type& __m, true_type) noexcept + : _Base(__m, std::move(__rv)) + { } + + + vector(vector&& __rv, const allocator_type& __m, false_type) + : _Base(__m) + { + if (__rv.get_allocator() == __m) + this->_M_impl._M_swap_data(__rv._M_impl); + else if (!__rv.empty()) + { + this->_M_create_storage(__rv.size()); + this->_M_impl._M_finish = + std::__uninitialized_move_a(__rv.begin(), __rv.end(), + this->_M_impl._M_start, + _M_get_Tp_allocator()); + __rv.clear(); + } + } + + public: + + + vector(vector&& __rv, const __type_identity_t& __m) + noexcept( noexcept( + vector(std::declval(), std::declval(), + std::declval())) ) + : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{}) + { } +# 675 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_range_initialize(__l.begin(), __l.end(), + random_access_iterator_tag()); + } +# 701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template> + + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_range_initialize(__first, __last, + std::__iterator_category(__first)); + } +# 730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + ~vector() noexcept + { + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + ; + } +# 747 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector& + operator=(const vector& __x); +# 762 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector& + operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) + { + constexpr bool __move_storage = + _Alloc_traits::_S_propagate_on_move_assign() + || _Alloc_traits::_S_always_equal(); + _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); + return *this; + } +# 784 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + vector& + operator=(initializer_list __l) + { + this->_M_assign_aux(__l.begin(), __l.end(), + random_access_iterator_tag()); + return *this; + } +# 804 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + assign(size_type __n, const value_type& __val) + { _M_fill_assign(__n, __val); } +# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template> + + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } +# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + assign(initializer_list __l) + { + this->_M_assign_aux(__l.begin(), __l.end(), + random_access_iterator_tag()); + } + + + + using _Base::get_allocator; + + + + + + + + [[__nodiscard__]] + iterator + begin() noexcept + { return iterator(this->_M_impl._M_start); } + + + + + + + [[__nodiscard__]] + const_iterator + begin() const noexcept + { return const_iterator(this->_M_impl._M_start); } + + + + + + + [[__nodiscard__]] + iterator + end() noexcept + { return iterator(this->_M_impl._M_finish); } + + + + + + + [[__nodiscard__]] + const_iterator + end() const noexcept + { return const_iterator(this->_M_impl._M_finish); } + + + + + + + [[__nodiscard__]] + reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + + + + + + [[__nodiscard__]] + reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + + + + + + + [[__nodiscard__]] + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_impl._M_start); } + + + + + + + [[__nodiscard__]] + const_iterator + cend() const noexcept + { return const_iterator(this->_M_impl._M_finish); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + + + + + + [[__nodiscard__]] + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + + + + [[__nodiscard__]] + size_type + size() const noexcept + { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } + + + [[__nodiscard__]] + size_type + max_size() const noexcept + { return _S_max_size(_M_get_Tp_allocator()); } +# 1009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + resize(size_type __new_size) + { + if (__new_size > size()) + _M_default_append(__new_size - size()); + else if (__new_size < size()) + _M_erase_at_end(this->_M_impl._M_start + __new_size); + } +# 1030 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + resize(size_type __new_size, const value_type& __x) + { + if (__new_size > size()) + _M_fill_insert(end(), __new_size - size(), __x); + else if (__new_size < size()) + _M_erase_at_end(this->_M_impl._M_start + __new_size); + } +# 1064 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + shrink_to_fit() + { _M_shrink_to_fit(); } + + + + + + + [[__nodiscard__]] + size_type + capacity() const noexcept + { return size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); } + + + + + + [[__nodiscard__]] + bool + empty() const noexcept + { return begin() == end(); } +# 1106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + reserve(size_type __n); +# 1121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + [[__nodiscard__]] + reference + operator[](size_type __n) noexcept + { + ; + return *(this->_M_impl._M_start + __n); + } +# 1140 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + [[__nodiscard__]] + const_reference + operator[](size_type __n) const noexcept + { + ; + return *(this->_M_impl._M_start + __n); + } + + protected: + + + void + _M_range_check(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"), + + + __n, this->size()); + } + + public: +# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + reference + at(size_type __n) + { + _M_range_check(__n); + return (*this)[__n]; + } +# 1193 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + const_reference + at(size_type __n) const + { + _M_range_check(__n); + return (*this)[__n]; + } + + + + + + [[__nodiscard__]] + reference + front() noexcept + { + ; + return *begin(); + } + + + + + + [[__nodiscard__]] + const_reference + front() const noexcept + { + ; + return *begin(); + } + + + + + + [[__nodiscard__]] + reference + back() noexcept + { + ; + return *(end() - 1); + } + + + + + + [[__nodiscard__]] + const_reference + back() const noexcept + { + ; + return *(end() - 1); + } +# 1255 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + [[__nodiscard__]] + _Tp* + data() noexcept + { return _M_data_ptr(this->_M_impl._M_start); } + + [[__nodiscard__]] + const _Tp* + data() const noexcept + { return _M_data_ptr(this->_M_impl._M_start); } +# 1277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + push_back(const value_type& __x) + { + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + __x); + ++this->_M_impl._M_finish; + ; + } + else + _M_realloc_insert(end(), __x); + } + + + + void + push_back(value_type&& __x) + { emplace_back(std::move(__x)); } + + template + + + reference + + + + emplace_back(_Args&&... __args); +# 1318 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + pop_back() noexcept + { + ; + --this->_M_impl._M_finish; + _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); + ; + } +# 1340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + + iterator + emplace(const_iterator __position, _Args&&... __args) + { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); } +# 1358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + insert(const_iterator __position, const value_type& __x); +# 1389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + insert(const_iterator __position, value_type&& __x) + { return _M_insert_rval(__position, std::move(__x)); } +# 1407 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + insert(const_iterator __position, initializer_list __l) + { + auto __offset = __position - cbegin(); + _M_range_insert(begin() + __offset, __l.begin(), __l.end(), + std::random_access_iterator_tag()); + return begin() + __offset; + } +# 1433 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + insert(const_iterator __position, size_type __n, const value_type& __x) + { + difference_type __offset = __position - cbegin(); + _M_fill_insert(begin() + __offset, __n, __x); + return begin() + __offset; + } +# 1475 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template> + + iterator + insert(const_iterator __position, _InputIterator __first, + _InputIterator __last) + { + difference_type __offset = __position - cbegin(); + _M_range_insert(begin() + __offset, __first, __last, + std::__iterator_category(__first)); + return begin() + __offset; + } +# 1529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + + erase(const_iterator __position) + { return _M_erase(begin() + (__position - cbegin())); } +# 1557 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + iterator + + erase(const_iterator __first, const_iterator __last) + { + const auto __beg = begin(); + const auto __cbeg = cbegin(); + return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg)); + } +# 1582 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + swap(vector& __x) noexcept + { + + do { if (std::__is_constant_evaluated() && !bool(_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator())) __builtin_unreachable(); } while (false); + + + this->_M_impl._M_swap_data(__x._M_impl); + _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(), + __x._M_get_Tp_allocator()); + } +# 1601 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + void + clear() noexcept + { _M_erase_at_end(this->_M_impl._M_start); } + + protected: + + + + + template + + pointer + _M_allocate_and_copy(size_type __n, + _ForwardIterator __first, _ForwardIterator __last) + { + pointer __result = this->_M_allocate(__n); + try + { + std::__uninitialized_copy_a(__first, __last, __result, + _M_get_Tp_allocator()); + return __result; + } + catch(...) + { + _M_deallocate(__result, __n); + throw; + } + } +# 1661 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + + void + _M_range_initialize(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + try { + for (; __first != __last; ++__first) + + emplace_back(*__first); + + + + } catch(...) { + clear(); + throw; + } + } + + + template + + void + _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __n = std::distance(__first, __last); + this->_M_impl._M_start + = this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator())); + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__first, __last, + this->_M_impl._M_start, + _M_get_Tp_allocator()); + } + + + + + void + _M_fill_initialize(size_type __n, const value_type& __value) + { + this->_M_impl._M_finish = + std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, + _M_get_Tp_allocator()); + } + + + + + void + _M_default_initialize(size_type __n) + { + this->_M_impl._M_finish = + std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, + _M_get_Tp_allocator()); + } +# 1727 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + + void + _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) + { _M_fill_assign(__n, __val); } + + + template + + void + _M_assign_dispatch(_InputIterator __first, _InputIterator __last, + __false_type) + { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } + + + template + + void + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag); + + + template + + void + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag); + + + + + void + _M_fill_assign(size_type __n, const value_type& __val); + + + + + + + + template + + void + _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, + __true_type) + { _M_fill_insert(__pos, __n, __val); } + + + template + + void + _M_insert_dispatch(iterator __pos, _InputIterator __first, + _InputIterator __last, __false_type) + { + _M_range_insert(__pos, __first, __last, + std::__iterator_category(__first)); + } + + + template + + void + _M_range_insert(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag); + + + template + + void + _M_range_insert(iterator __pos, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag); + + + + + void + _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); + + + + + void + _M_default_append(size_type __n); + + + bool + _M_shrink_to_fit(); +# 1826 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + struct _Temporary_value + { + template + explicit + _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec) + { + _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(), + std::forward<_Args>(__args)...); + } + + + ~_Temporary_value() + { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); } + + value_type& + _M_val() noexcept { return _M_storage._M_val; } + + private: + _Tp* + _M_ptr() noexcept { return std::__addressof(_M_storage._M_val); } + + union _Storage + { + constexpr _Storage() : _M_byte() { } + ~_Storage() { } + _Storage& operator=(const _Storage&) = delete; + unsigned char _M_byte; + _Tp _M_val; + }; + + vector* _M_this; + _Storage _M_storage; + }; + + + + template + + void + _M_insert_aux(iterator __position, _Arg&& __arg); + + template + + void + _M_realloc_insert(iterator __position, _Args&&... __args); + + + + iterator + _M_insert_rval(const_iterator __position, value_type&& __v); + + + template + + iterator + _M_emplace_aux(const_iterator __position, _Args&&... __args); + + + + iterator + _M_emplace_aux(const_iterator __position, value_type&& __v) + { return _M_insert_rval(__position, std::move(__v)); } + + + + + size_type + _M_check_len(size_type __n, const char* __s) const + { + if (max_size() - size() < __n) + __throw_length_error((__s)); + + const size_type __len = size() + (std::max)(size(), __n); + return (__len < size() || __len > max_size()) ? max_size() : __len; + } + + + static size_type + _S_check_init_len(size_type __n, const allocator_type& __a) + { + if (__n > _S_max_size(_Tp_alloc_type(__a))) + __throw_length_error( + ("cannot create std::vector larger than max_size()")); + return __n; + } + + static size_type + _S_max_size(const _Tp_alloc_type& __a) noexcept + { + + + + const size_t __diffmax + = __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); + const size_t __allocmax = _Alloc_traits::max_size(__a); + return (std::min)(__diffmax, __allocmax); + } + + + + + + + void + _M_erase_at_end(pointer __pos) noexcept + { + if (size_type __n = this->_M_impl._M_finish - __pos) + { + std::_Destroy(__pos, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish = __pos; + ; + } + } + + + iterator + _M_erase(iterator __position); + + + iterator + _M_erase(iterator __first, iterator __last); + + + private: + + + + + void + _M_move_assign(vector&& __x, true_type) noexcept + { + vector __tmp(get_allocator()); + this->_M_impl._M_swap_data(__x._M_impl); + __tmp._M_impl._M_swap_data(__x._M_impl); + std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); + } + + + + + void + _M_move_assign(vector&& __x, false_type) + { + if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) + _M_move_assign(std::move(__x), true_type()); + else + { + + + this->_M_assign_aux(std::make_move_iterator(__x.begin()), + std::make_move_iterator(__x.end()), + std::random_access_iterator_tag()); + __x.clear(); + } + } + + + template + + _Up* + _M_data_ptr(_Up* __ptr) const noexcept + { return __ptr; } + + + template + + typename std::pointer_traits<_Ptr>::element_type* + _M_data_ptr(_Ptr __ptr) const + { return empty() ? nullptr : std::__to_address(__ptr); } +# 2012 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + }; + + + template::value_type, + typename _Allocator = allocator<_ValT>, + typename = _RequireInputIter<_InputIterator>, + typename = _RequireAllocator<_Allocator>> + vector(_InputIterator, _InputIterator, _Allocator = _Allocator()) + -> vector<_ValT, _Allocator>; +# 2034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + + inline bool + operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return (__x.size() == __y.size() + && std::equal(__x.begin(), __x.end(), __y.begin())); } +# 2074 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 + template + inline bool + operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return std::lexicographical_compare(__x.begin(), __x.end(), + __y.begin(), __y.end()); } + + + template + inline bool + operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return !(__x == __y); } + + + template + inline bool + operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return __y < __x; } + + + template + inline bool + operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return !(__y < __x); } + + + template + inline bool + operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) + { return !(__x < __y); } + + + + template + + inline void + swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } + + + + + namespace __detail::__variant + { + template struct _Never_valueless_alt; + + + + template + struct _Never_valueless_alt> + : std::is_nothrow_move_assignable> + { }; + } + + + +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 1 3 +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hash_bytes.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template + struct __hash_base + { + typedef _Result result_type [[__deprecated__]]; + typedef _Arg argument_type [[__deprecated__]]; + }; + + + template + struct hash; + + template + struct __poison_hash + { + static constexpr bool __enable_hash_call = false; + private: + + __poison_hash(__poison_hash&&); + ~__poison_hash(); + }; + + template + struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> + { + static constexpr bool __enable_hash_call = true; + }; + + + template::value> + struct __hash_enum + { + private: + + __hash_enum(__hash_enum&&); + ~__hash_enum(); + }; + + + template + struct __hash_enum<_Tp, true> : public __hash_base + { + size_t + operator()(_Tp __val) const noexcept + { + using __type = typename underlying_type<_Tp>::type; + return hash<__type>{}(static_cast<__type>(__val)); + } + }; + + + + template + struct hash : __hash_enum<_Tp> + { }; + + + template + struct hash<_Tp*> : public __hash_base + { + size_t + operator()(_Tp* __p) const noexcept + { return reinterpret_cast(__p); } + }; +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; + + + + + + + + template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; + + + template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; +# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + struct _Hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(0xc70f6907UL)) + { return _Hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + + struct _Fnv_hash_impl + { + static size_t + hash(const void* __ptr, size_t __clength, + size_t __seed = static_cast(2166136261UL)) + { return _Fnv_hash_bytes(__ptr, __clength, __seed); } + + template + static size_t + hash(const _Tp& __val) + { return hash(&__val, sizeof(__val)); } + + template + static size_t + __hash_combine(const _Tp& __val, size_t __hash) + { return hash(&__val, sizeof(__val), __hash); } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(float __val) const noexcept + { + + return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(double __val) const noexcept + { + + return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; + } + }; + + + template<> + struct hash + : public __hash_base + { + __attribute__ ((__pure__)) size_t + operator()(long double __val) const noexcept; + }; + + + template<> + struct hash : public __hash_base + { + size_t + operator()(nullptr_t) const noexcept + { return 0; } + }; +# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 + template + struct __is_fast_hash : public std::true_type + { }; + + template<> + struct __is_fast_hash> : public std::false_type + { }; + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + typedef unsigned long _Bit_type; + enum { _S_word_bit = int(8 * sizeof(_Bit_type)) }; + + __attribute__((__nonnull__)) + + void + __fill_bvector_n(_Bit_type*, size_t, bool) noexcept; + + + + struct _Bit_reference + { + _Bit_type * _M_p; + _Bit_type _M_mask; + + + _Bit_reference(_Bit_type * __x, _Bit_type __y) + : _M_p(__x), _M_mask(__y) { } + + + _Bit_reference() noexcept : _M_p(0), _M_mask(0) { } + + + _Bit_reference(const _Bit_reference&) = default; + + + [[__nodiscard__]] + operator bool() const noexcept + { return !!(*_M_p & _M_mask); } + + + _Bit_reference& + operator=(bool __x) noexcept + { + if (__x) + *_M_p |= _M_mask; + else + *_M_p &= ~_M_mask; + return *this; + } +# 122 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + _Bit_reference& + operator=(const _Bit_reference& __x) noexcept + { return *this = bool(__x); } + + [[__nodiscard__]] + bool + operator==(const _Bit_reference& __x) const + { return bool(*this) == bool(__x); } + + [[__nodiscard__]] + bool + operator<(const _Bit_reference& __x) const + { return !bool(*this) && bool(__x); } + + + void + flip() noexcept + { *_M_p ^= _M_mask; } + + + + friend void + swap(_Bit_reference __x, _Bit_reference __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + + friend void + swap(_Bit_reference __x, bool& __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + + friend void + swap(bool& __x, _Bit_reference __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + struct _Bit_iterator_base + : public std::iterator + { + _Bit_type * _M_p; + unsigned int _M_offset; + + + _Bit_iterator_base(_Bit_type * __x, unsigned int __y) + : _M_p(__x), _M_offset(__y) { } + + + void + _M_bump_up() + { + if (_M_offset++ == int(_S_word_bit) - 1) + { + _M_offset = 0; + ++_M_p; + } + } + + + void + _M_bump_down() + { + if (_M_offset-- == 0) + { + _M_offset = int(_S_word_bit) - 1; + --_M_p; + } + } + + + void + _M_incr(ptrdiff_t __i) + { + difference_type __n = __i + _M_offset; + _M_p += __n / int(_S_word_bit); + __n = __n % int(_S_word_bit); + if (__n < 0) + { + __n += int(_S_word_bit); + --_M_p; + } + _M_offset = static_cast(__n); + } + + [[__nodiscard__]] + friend bool + operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; } +# 237 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + [[__nodiscard__]] + friend bool + operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { + return __x._M_p < __y._M_p + || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset); + } + + [[__nodiscard__]] + friend bool + operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return !(__x == __y); } + + [[__nodiscard__]] + friend bool + operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return __y < __x; } + + [[__nodiscard__]] + friend bool + operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return !(__y < __x); } + + [[__nodiscard__]] + friend bool + operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { return !(__x < __y); } + + + friend ptrdiff_t + operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) + { + return (int(_S_word_bit) * (__x._M_p - __y._M_p) + + __x._M_offset - __y._M_offset); + } + }; +#pragma GCC diagnostic pop + + struct _Bit_iterator : public _Bit_iterator_base + { + typedef _Bit_reference reference; + + + + typedef _Bit_reference* pointer; + + typedef _Bit_iterator iterator; + + + _Bit_iterator() : _Bit_iterator_base(0, 0) { } + + + _Bit_iterator(_Bit_type * __x, unsigned int __y) + : _Bit_iterator_base(__x, __y) { } + + + iterator + _M_const_cast() const + { return *this; } + + [[__nodiscard__]] + reference + operator*() const + { return reference(_M_p, 1UL << _M_offset); } + + + iterator& + operator++() + { + _M_bump_up(); + return *this; + } + + + iterator + operator++(int) + { + iterator __tmp = *this; + _M_bump_up(); + return __tmp; + } + + + iterator& + operator--() + { + _M_bump_down(); + return *this; + } + + + iterator + operator--(int) + { + iterator __tmp = *this; + _M_bump_down(); + return __tmp; + } + + + iterator& + operator+=(difference_type __i) + { + _M_incr(__i); + return *this; + } + + + iterator& + operator-=(difference_type __i) + { + *this += -__i; + return *this; + } + + [[__nodiscard__]] + reference + operator[](difference_type __i) const + { return *(*this + __i); } + + [[__nodiscard__]] + friend iterator + operator+(const iterator& __x, difference_type __n) + { + iterator __tmp = __x; + __tmp += __n; + return __tmp; + } + + [[__nodiscard__]] + friend iterator + operator+(difference_type __n, const iterator& __x) + { return __x + __n; } + + [[__nodiscard__]] + friend iterator + operator-(const iterator& __x, difference_type __n) + { + iterator __tmp = __x; + __tmp -= __n; + return __tmp; + } + }; + + struct _Bit_const_iterator : public _Bit_iterator_base + { + typedef bool reference; + typedef bool const_reference; + + + + typedef const bool* pointer; + + typedef _Bit_const_iterator const_iterator; + + + _Bit_const_iterator() : _Bit_iterator_base(0, 0) { } + + + _Bit_const_iterator(_Bit_type * __x, unsigned int __y) + : _Bit_iterator_base(__x, __y) { } + + + _Bit_const_iterator(const _Bit_iterator& __x) + : _Bit_iterator_base(__x._M_p, __x._M_offset) { } + + + _Bit_iterator + _M_const_cast() const + { return _Bit_iterator(_M_p, _M_offset); } + + [[__nodiscard__]] + const_reference + operator*() const + { return _Bit_reference(_M_p, 1UL << _M_offset); } + + + const_iterator& + operator++() + { + _M_bump_up(); + return *this; + } + + + const_iterator + operator++(int) + { + const_iterator __tmp = *this; + _M_bump_up(); + return __tmp; + } + + + const_iterator& + operator--() + { + _M_bump_down(); + return *this; + } + + + const_iterator + operator--(int) + { + const_iterator __tmp = *this; + _M_bump_down(); + return __tmp; + } + + + const_iterator& + operator+=(difference_type __i) + { + _M_incr(__i); + return *this; + } + + + const_iterator& + operator-=(difference_type __i) + { + *this += -__i; + return *this; + } + + [[__nodiscard__]] + const_reference + operator[](difference_type __i) const + { return *(*this + __i); } + + [[__nodiscard__]] + friend const_iterator + operator+(const const_iterator& __x, difference_type __n) + { + const_iterator __tmp = __x; + __tmp += __n; + return __tmp; + } + + [[__nodiscard__]] + friend const_iterator + operator-(const const_iterator& __x, difference_type __n) + { + const_iterator __tmp = __x; + __tmp -= __n; + return __tmp; + } + + [[__nodiscard__]] + friend const_iterator + operator+(difference_type __n, const const_iterator& __x) + { return __x + __n; } + }; + + template + struct _Bvector_base + { + typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template + rebind<_Bit_type>::other _Bit_alloc_type; + typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type> + _Bit_alloc_traits; + typedef typename _Bit_alloc_traits::pointer _Bit_pointer; + + struct _Bvector_impl_data + { + + _Bit_iterator _M_start; +# 514 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + _Bit_iterator _M_finish; + _Bit_pointer _M_end_of_storage; + + + _Bvector_impl_data() noexcept + : _M_start(), _M_finish(), _M_end_of_storage() + { } + + + _Bvector_impl_data(const _Bvector_impl_data&) = default; + + _Bvector_impl_data& + operator=(const _Bvector_impl_data&) = default; + + + _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept + : _Bvector_impl_data(__x) + { __x._M_reset(); } + + + void + _M_move_data(_Bvector_impl_data&& __x) noexcept + { + *this = __x; + __x._M_reset(); + } + + + + void + _M_reset() noexcept + { *this = _Bvector_impl_data(); } + + + void + _M_swap_data(_Bvector_impl_data& __x) noexcept + { + + + std::swap(*this, __x); + } + }; + + struct _Bvector_impl + : public _Bit_alloc_type, public _Bvector_impl_data + { + + _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value) + + : _Bit_alloc_type() + { } + + + _Bvector_impl(const _Bit_alloc_type& __a) noexcept + : _Bit_alloc_type(__a) + { } + + + + + + _Bvector_impl(_Bvector_impl&& __x) noexcept + : _Bit_alloc_type(std::move(__x)), _Bvector_impl_data(std::move(__x)) + { } + + + _Bvector_impl(_Bit_alloc_type&& __a, _Bvector_impl&& __x) noexcept + : _Bit_alloc_type(std::move(__a)), _Bvector_impl_data(std::move(__x)) + { } + + + + _Bit_type* + _M_end_addr() const noexcept + { + if (this->_M_end_of_storage) + return std::__addressof(this->_M_end_of_storage[-1]) + 1; + return 0; + } + }; + + public: + typedef _Alloc allocator_type; + + + _Bit_alloc_type& + _M_get_Bit_allocator() noexcept + { return this->_M_impl; } + + + const _Bit_alloc_type& + _M_get_Bit_allocator() const noexcept + { return this->_M_impl; } + + + allocator_type + get_allocator() const noexcept + { return allocator_type(_M_get_Bit_allocator()); } + + + _Bvector_base() = default; + + + + + + _Bvector_base(const allocator_type& __a) + : _M_impl(__a) { } + + + _Bvector_base(_Bvector_base&&) = default; + + + _Bvector_base(_Bvector_base&& __x, const allocator_type& __a) noexcept + : _M_impl(_Bit_alloc_type(__a), std::move(__x._M_impl)) + { } + + + + ~_Bvector_base() + { this->_M_deallocate(); } + + protected: + _Bvector_impl _M_impl; + + + _Bit_pointer + _M_allocate(size_t __n) + { + _Bit_pointer __p = _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); +# 652 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + return __p; + } + + + void + _M_deallocate() + { + if (_M_impl._M_start._M_p) + { + const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p; + _Bit_alloc_traits::deallocate(_M_impl, + _M_impl._M_end_of_storage - __n, + __n); + _M_impl._M_reset(); + } + } + + + + void + _M_move_data(_Bvector_base&& __x) noexcept + { _M_impl._M_move_data(std::move(__x._M_impl)); } + + + constexpr + static size_t + _S_nword(size_t __n) + { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); } + }; +# 703 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + template + class vector : protected _Bvector_base<_Alloc> + { + typedef _Bvector_base<_Alloc> _Base; + typedef typename _Base::_Bit_pointer _Bit_pointer; + typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits; + + + friend struct std::hash; + + + public: + typedef bool value_type; + typedef size_t size_type; + typedef ptrdiff_t difference_type; + typedef _Bit_reference reference; + typedef bool const_reference; + typedef _Bit_reference* pointer; + typedef const bool* const_pointer; + typedef _Bit_iterator iterator; + typedef _Bit_const_iterator const_iterator; + typedef std::reverse_iterator const_reverse_iterator; + typedef std::reverse_iterator reverse_iterator; + typedef _Alloc allocator_type; + + + allocator_type + get_allocator() const + { return _Base::get_allocator(); } + + protected: + using _Base::_M_allocate; + using _Base::_M_deallocate; + using _Base::_S_nword; + using _Base::_M_get_Bit_allocator; + + public: + + vector() = default; + + + + + + explicit + vector(const allocator_type& __a) + : _Base(__a) { } + + + + explicit + vector(size_type __n, const allocator_type& __a = allocator_type()) + : vector(__n, false, __a) + { } + + + vector(size_type __n, const bool& __value, + const allocator_type& __a = allocator_type()) + + + + + + : _Base(__a) + { + _M_initialize(__n); + _M_initialize_value(__value); + } + + + vector(const vector& __x) + : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator())) + { + const_iterator __xbegin = __x.begin(), __xend = __x.end(); + _M_initialize(__x.size()); + _M_copy_aligned(__xbegin, __xend, begin()); + } + + + vector(vector&&) = default; + + private: + + vector(vector&& __x, const allocator_type& __a, true_type) noexcept + : _Base(std::move(__x), __a) + { } + + + vector(vector&& __x, const allocator_type& __a, false_type) + : _Base(__a) + { + if (__x.get_allocator() == __a) + this->_M_move_data(std::move(__x)); + else + { + _M_initialize(__x.size()); + _M_copy_aligned(__x.begin(), __x.end(), begin()); + __x.clear(); + } + } + + public: + + vector(vector&& __x, const __type_identity_t& __a) + noexcept(_Bit_alloc_traits::_S_always_equal()) + : vector(std::move(__x), __a, + typename _Bit_alloc_traits::is_always_equal{}) + { } + + + vector(const vector& __x, const __type_identity_t& __a) + : _Base(__a) + { + _M_initialize(__x.size()); + _M_copy_aligned(__x.begin(), __x.end(), begin()); + } + + + vector(initializer_list __l, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_initialize_range(__l.begin(), __l.end(), + random_access_iterator_tag()); + } + + + + template> + + vector(_InputIterator __first, _InputIterator __last, + const allocator_type& __a = allocator_type()) + : _Base(__a) + { + _M_initialize_range(__first, __last, + std::__iterator_category(__first)); + } +# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + ~vector() noexcept { } + + + vector& + operator=(const vector& __x) + { + if (&__x == this) + return *this; + + if (_Bit_alloc_traits::_S_propagate_on_copy_assign()) + { + if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator()) + { + this->_M_deallocate(); + std::__alloc_on_copy(_M_get_Bit_allocator(), + __x._M_get_Bit_allocator()); + _M_initialize(__x.size()); + } + else + std::__alloc_on_copy(_M_get_Bit_allocator(), + __x._M_get_Bit_allocator()); + } + + if (__x.size() > capacity()) + { + this->_M_deallocate(); + _M_initialize(__x.size()); + } + this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), + begin()); + return *this; + } + + + + vector& + operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move()) + { + if (_Bit_alloc_traits::_S_propagate_on_move_assign() + || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator()) + { + this->_M_deallocate(); + this->_M_move_data(std::move(__x)); + std::__alloc_on_move(_M_get_Bit_allocator(), + __x._M_get_Bit_allocator()); + } + else + { + if (__x.size() > capacity()) + { + this->_M_deallocate(); + _M_initialize(__x.size()); + } + this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), + begin()); + __x.clear(); + } + return *this; + } + + + vector& + operator=(initializer_list __l) + { + this->assign(__l.begin(), __l.end()); + return *this; + } + + + + + + + + void + assign(size_type __n, const bool& __x) + { _M_fill_assign(__n, __x); } + + + template> + + void + assign(_InputIterator __first, _InputIterator __last) + { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } +# 952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + void + assign(initializer_list __l) + { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); } + + + [[__nodiscard__]] + iterator + begin() noexcept + { return iterator(this->_M_impl._M_start._M_p, 0); } + + [[__nodiscard__]] + const_iterator + begin() const noexcept + { return const_iterator(this->_M_impl._M_start._M_p, 0); } + + [[__nodiscard__]] + iterator + end() noexcept + { return this->_M_impl._M_finish; } + + [[__nodiscard__]] + const_iterator + end() const noexcept + { return this->_M_impl._M_finish; } + + [[__nodiscard__]] + reverse_iterator + rbegin() noexcept + { return reverse_iterator(end()); } + + [[__nodiscard__]] + const_reverse_iterator + rbegin() const noexcept + { return const_reverse_iterator(end()); } + + [[__nodiscard__]] + reverse_iterator + rend() noexcept + { return reverse_iterator(begin()); } + + [[__nodiscard__]] + const_reverse_iterator + rend() const noexcept + { return const_reverse_iterator(begin()); } + + + [[__nodiscard__]] + const_iterator + cbegin() const noexcept + { return const_iterator(this->_M_impl._M_start._M_p, 0); } + + [[__nodiscard__]] + const_iterator + cend() const noexcept + { return this->_M_impl._M_finish; } + + [[__nodiscard__]] + const_reverse_iterator + crbegin() const noexcept + { return const_reverse_iterator(end()); } + + [[__nodiscard__]] + const_reverse_iterator + crend() const noexcept + { return const_reverse_iterator(begin()); } + + + [[__nodiscard__]] + size_type + size() const noexcept + { return size_type(end() - begin()); } + + [[__nodiscard__]] + size_type + max_size() const noexcept + { + const size_type __isize = + __gnu_cxx::__numeric_traits::__max + - int(_S_word_bit) + 1; + const size_type __asize + = _Bit_alloc_traits::max_size(_M_get_Bit_allocator()); + return (__asize <= __isize / int(_S_word_bit) + ? __asize * int(_S_word_bit) : __isize); + } + + [[__nodiscard__]] + size_type + capacity() const noexcept + { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0) + - begin()); } + + [[__nodiscard__]] + bool + empty() const noexcept + { return begin() == end(); } + + [[__nodiscard__]] + reference + operator[](size_type __n) + { return begin()[__n]; } + + [[__nodiscard__]] + const_reference + operator[](size_type __n) const + { return begin()[__n]; } + + protected: + + void + _M_range_check(size_type __n) const + { + if (__n >= this->size()) + __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"), + + + __n, this->size()); + } + + public: + + reference + at(size_type __n) + { + _M_range_check(__n); + return (*this)[__n]; + } + + + const_reference + at(size_type __n) const + { + _M_range_check(__n); + return (*this)[__n]; + } + + + void + reserve(size_type __n) + { + if (__n > max_size()) + __throw_length_error(("vector::reserve")); + if (capacity() < __n) + _M_reallocate(__n); + } + + [[__nodiscard__]] + reference + front() + { return *begin(); } + + [[__nodiscard__]] + const_reference + front() const + { return *begin(); } + + [[__nodiscard__]] + reference + back() + { return *(end() - 1); } + + [[__nodiscard__]] + const_reference + back() const + { return *(end() - 1); } + + + void + push_back(bool __x) + { + if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) + *this->_M_impl._M_finish++ = __x; + else + _M_insert_aux(end(), __x); + } + + + void + swap(vector& __x) noexcept + { + + do { if (std::__is_constant_evaluated() && !bool(_Bit_alloc_traits::propagate_on_container_swap::value || _M_get_Bit_allocator() == __x._M_get_Bit_allocator())) __builtin_unreachable(); } while (false); + + + this->_M_impl._M_swap_data(__x._M_impl); + _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(), + __x._M_get_Bit_allocator()); + } + + + + static void + swap(reference __x, reference __y) noexcept + { + bool __tmp = __x; + __x = __y; + __y = __tmp; + } + + + iterator + + insert(const_iterator __position, const bool& __x) + + + + { + const difference_type __n = __position - begin(); + if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr() + && __position == end()) + *this->_M_impl._M_finish++ = __x; + else + _M_insert_aux(__position._M_const_cast(), __x); + return begin() + __n; + } + + + __attribute__ ((__deprecated__ ("use '" "insert(position, false)" "' instead"))) + iterator + insert(const_iterator __position) + { return this->insert(__position._M_const_cast(), false); } + + + + template> + + iterator + insert(const_iterator __position, + _InputIterator __first, _InputIterator __last) + { + difference_type __offset = __position - cbegin(); + _M_insert_range(__position._M_const_cast(), + __first, __last, + std::__iterator_category(__first)); + return begin() + __offset; + } +# 1202 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + iterator + insert(const_iterator __position, size_type __n, const bool& __x) + { + difference_type __offset = __position - cbegin(); + _M_fill_insert(__position._M_const_cast(), __n, __x); + return begin() + __offset; + } +# 1217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + iterator + insert(const_iterator __p, initializer_list __l) + { return this->insert(__p, __l.begin(), __l.end()); } + + + + void + pop_back() + { --this->_M_impl._M_finish; } + + + iterator + + erase(const_iterator __position) + + + + { return _M_erase(__position._M_const_cast()); } + + + iterator + + erase(const_iterator __first, const_iterator __last) + + + + { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } + + + void + resize(size_type __new_size, bool __x = bool()) + { + if (__new_size < size()) + _M_erase_at_end(begin() + difference_type(__new_size)); + else + insert(end(), __new_size - size(), __x); + } + + + + void + shrink_to_fit() + { _M_shrink_to_fit(); } + + + + void + flip() noexcept + { + _Bit_type * const __end = this->_M_impl._M_end_addr(); + for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p) + *__p = ~*__p; + } + + + void + clear() noexcept + { _M_erase_at_end(begin()); } + + + template + + + reference + + + + emplace_back(_Args&&... __args) + { + push_back(bool(__args...)); + + return back(); + + } + + template + + iterator + emplace(const_iterator __pos, _Args&&... __args) + { return insert(__pos, bool(__args...)); } + + + protected: + + + iterator + _M_copy_aligned(const_iterator __first, const_iterator __last, + iterator __result) + { + _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p); + return std::copy(const_iterator(__last._M_p, 0), __last, + iterator(__q, 0)); + } + + + void + _M_initialize(size_type __n) + { + if (__n) + { + _Bit_pointer __q = this->_M_allocate(__n); + this->_M_impl._M_end_of_storage = __q + _S_nword(__n); + iterator __start = iterator(std::__addressof(*__q), 0); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __start + difference_type(__n); + } + } + + + void + _M_initialize_value(bool __x) noexcept + { + if (_Bit_type* __p = this->_M_impl._M_start._M_p) + __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x); + } + + + void + _M_reallocate(size_type __n); + + + + bool + _M_shrink_to_fit(); +# 1362 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + template + + void + _M_initialize_range(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + for (; __first != __last; ++__first) + push_back(*__first); + } + + template + + void + _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __n = std::distance(__first, __last); + _M_initialize(__n); + std::copy(__first, __last, begin()); + } +# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + void + _M_fill_assign(size_t __n, bool __x) + { + if (__n > size()) + { + _M_initialize_value(__x); + insert(end(), __n - size(), __x); + } + else + { + _M_erase_at_end(begin() + __n); + _M_initialize_value(__x); + } + } + + template + + void + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + iterator __cur = begin(); + for (; __first != __last && __cur != end(); ++__cur, (void)++__first) + *__cur = *__first; + if (__first == __last) + _M_erase_at_end(__cur); + else + insert(end(), __first, __last); + } + + template + + void + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __len = std::distance(__first, __last); + if (__len < size()) + _M_erase_at_end(std::copy(__first, __last, begin())); + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, size()); + std::copy(__first, __mid, begin()); + insert(end(), __mid, __last); + } + } +# 1466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + void + _M_fill_insert(iterator __position, size_type __n, bool __x); + + template + + void + _M_insert_range(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag) + { + for (; __first != __last; ++__first) + { + __pos = insert(__pos, *__first); + ++__pos; + } + } + + template + + void + _M_insert_range(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag); + + + void + _M_insert_aux(iterator __position, bool __x); + + + size_type + _M_check_len(size_type __n, const char* __s) const + { + if (max_size() - size() < __n) + __throw_length_error((__s)); + + const size_type __len = size() + std::max(size(), __n); + return (__len < size() || __len > max_size()) ? max_size() : __len; + } + + + void + _M_erase_at_end(iterator __pos) + { this->_M_impl._M_finish = __pos; } + + + iterator + _M_erase(iterator __pos); + + + iterator + _M_erase(iterator __first, iterator __last); + + protected: + + + + + + + void data() = delete; + + + + }; + + + + + + inline void + __fill_bvector(_Bit_type* __v, unsigned int __first, unsigned int __last, + bool __x) noexcept + { + const _Bit_type __fmask = ~0ul << __first; + const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last); + const _Bit_type __mask = __fmask & __lmask; + + if (__x) + *__v |= __mask; + else + *__v &= ~__mask; + } + + + __attribute__((__nonnull__)) + + inline void + __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) noexcept + { +# 1561 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 + __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type)); + } + + + + inline void + __fill_a1(std::_Bit_iterator __first, + std::_Bit_iterator __last, const bool& __x) + { + if (__first._M_p != __last._M_p) + { + _Bit_type* __first_p = __first._M_p; + if (__first._M_offset != 0) + __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x); + + __fill_bvector_n(__first_p, __last._M_p - __first_p, __x); + + if (__last._M_offset != 0) + __fill_bvector(__last._M_p, 0, __last._M_offset, __x); + } + else if (__first._M_offset != __last._M_offset) + __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x); + } + + + + + template + struct hash> + : public __hash_base> + { + size_t + operator()(const std::vector&) const noexcept; + }; + + + +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 + + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 + template::type> + constexpr _Up&& + __invfwd(typename remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Up&&>(__t); } + + template + constexpr _Res + __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) + { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } + + template + constexpr _Res + __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } + + template + constexpr _Res + __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, + _Args&&... __args) + { + return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); + } + + template + constexpr _Res + __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) + { return __invfwd<_Tp>(__t).*__f; } + + template + constexpr _Res + __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) + { return (*std::forward<_Tp>(__t)).*__f; } + + + template + constexpr typename __invoke_result<_Callable, _Args...>::type + __invoke(_Callable&& __fn, _Args&&... __args) + noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) + { + using __result = __invoke_result<_Callable, _Args...>; + using __type = typename __result::type; + using __tag = typename __result::__invoke_type; + return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + } + + + + template + constexpr enable_if_t, _Res> + __invoke_r(_Callable&& __fn, _Args&&... __args) + noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) + { + using __result = __invoke_result<_Callable, _Args...>; + using __type = typename __result::type; + using __tag = typename __result::__invoke_type; + if constexpr (is_void_v<_Res>) + std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + else + return std::__invoke_impl<__type>(__tag{}, + std::forward<_Callable>(__fn), + std::forward<_Args>(__args)...); + } +# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 +} +# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct unary_function + { + + typedef _Arg argument_type; + + + typedef _Result result_type; + } __attribute__ ((__deprecated__)); + + + + + + template + struct binary_function + { + + typedef _Arg1 first_argument_type; + + + typedef _Arg2 second_argument_type; + + + typedef _Result result_type; + } __attribute__ ((__deprecated__)); +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + struct __is_transparent; + + template + struct plus; + + template + struct minus; + + template + struct multiplies; + + template + struct divides; + + template + struct modulus; + + template + struct negate; + + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct plus : public binary_function<_Tp, _Tp, _Tp> + { + + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x + __y; } + }; + + + template + struct minus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x - __y; } + }; + + + template + struct multiplies : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x * __y; } + }; + + + template + struct divides : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x / __y; } + }; + + + template + struct modulus : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x % __y; } + }; + + + template + struct negate : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return -__x; } + }; +#pragma GCC diagnostic pop + + + + + + template<> + struct plus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct minus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct multiplies + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct divides + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct modulus + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct negate + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(-std::forward<_Tp>(__t))) + -> decltype(-std::forward<_Tp>(__t)) + { return -std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; +# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct equal_to; + + template + struct not_equal_to; + + template + struct greater; + + template + struct less; + + template + struct greater_equal; + + template + struct less_equal; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x == __y; } + }; + + + template + struct not_equal_to : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x != __y; } + }; + + + template + struct greater : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x > __y; } + }; + + + template + struct less : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x < __y; } + }; + + + template + struct greater_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x >= __y; } + }; + + + template + struct less_equal : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x <= __y; } + }; + + + template + struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x > __y; + + return (long unsigned int)__x > (long unsigned int)__y; + } + }; + + + template + struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x < __y; + + return (long unsigned int)__x < (long unsigned int)__y; + } + }; + + + template + struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x >= __y; + + return (long unsigned int)__x >= (long unsigned int)__y; + } + }; + + + template + struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> + { + constexpr bool + operator()(_Tp* __x, _Tp* __y) const noexcept + { + + if (std::__is_constant_evaluated()) + return __x <= __y; + + return (long unsigned int)__x <= (long unsigned int)__y; + } + }; +#pragma GCC diagnostic pop + + + + template<> + struct equal_to + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct not_equal_to + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct greater + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return greater>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return greater{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct less + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return less>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return less{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct greater_equal + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return greater_equal>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return greater_equal{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; + + + template<> + struct less_equal + { + template + constexpr auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) + { + return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), + __ptr_cmp<_Tp, _Up>{}); + } + + template + constexpr bool + operator()(_Tp* __t, _Up* __u) const noexcept + { return less_equal>{}(__t, __u); } + + typedef __is_transparent is_transparent; + + private: + template + static constexpr decltype(auto) + _S_cmp(_Tp&& __t, _Up&& __u, false_type) + { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } + + template + static constexpr bool + _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept + { + return less_equal{}( + static_cast(std::forward<_Tp>(__t)), + static_cast(std::forward<_Up>(__u))); + } + + + template + struct __not_overloaded2 : true_type { }; + + + template + struct __not_overloaded2<_Tp, _Up, __void_t< + decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> + : false_type { }; + + + template + struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; + + + template + struct __not_overloaded<_Tp, _Up, __void_t< + decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> + : false_type { }; + + template + using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, + is_convertible<_Tp, const volatile void*>, + is_convertible<_Up, const volatile void*>>; + }; +# 781 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + struct logical_and; + + template + struct logical_or; + + template + struct logical_not; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct logical_and : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x && __y; } + }; + + + template + struct logical_or : public binary_function<_Tp, _Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x, const _Tp& __y) const + { return __x || __y; } + }; + + + template + struct logical_not : public unary_function<_Tp, bool> + { + constexpr + bool + operator()(const _Tp& __x) const + { return !__x; } + }; +#pragma GCC diagnostic pop + + + + template<> + struct logical_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + + template<> + struct logical_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(!std::forward<_Tp>(__t))) + -> decltype(!std::forward<_Tp>(__t)) + { return !std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; + + + + + template + struct bit_and; + + template + struct bit_or; + + template + struct bit_xor; + + template + struct bit_not; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + + template + struct bit_and : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x & __y; } + }; + + template + struct bit_or : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x | __y; } + }; + + template + struct bit_xor : public binary_function<_Tp, _Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x, const _Tp& __y) const + { return __x ^ __y; } + }; + + template + struct bit_not : public unary_function<_Tp, _Tp> + { + constexpr + _Tp + operator()(const _Tp& __x) const + { return ~__x; } + }; +#pragma GCC diagnostic pop + + + template <> + struct bit_and + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_or + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_xor + { + template + constexpr + auto + operator()(_Tp&& __t, _Up&& __u) const + noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) + -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) + { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } + + typedef __is_transparent is_transparent; + }; + + template <> + struct bit_not + { + template + constexpr + auto + operator()(_Tp&& __t) const + noexcept(noexcept(~std::forward<_Tp>(__t))) + -> decltype(~std::forward<_Tp>(__t)) + { return ~std::forward<_Tp>(__t); } + + typedef __is_transparent is_transparent; + }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class [[__deprecated__]] unary_negate + : public unary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + unary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::argument_type& __x) const + { return !_M_pred(__x); } + }; + + + template + __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) + constexpr + inline unary_negate<_Predicate> + not1(const _Predicate& __pred) + { return unary_negate<_Predicate>(__pred); } + + + template + class [[__deprecated__]] binary_negate + : public binary_function + { + protected: + _Predicate _M_pred; + + public: + constexpr + explicit + binary_negate(const _Predicate& __x) : _M_pred(__x) { } + + constexpr + bool + operator()(const typename _Predicate::first_argument_type& __x, + const typename _Predicate::second_argument_type& __y) const + { return !_M_pred(__x, __y); } + }; + + + template + __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) + constexpr + inline binary_negate<_Predicate> + not2(const _Predicate& __pred) + { return binary_negate<_Predicate>(__pred); } +# 1104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class pointer_to_unary_function : public unary_function<_Arg, _Result> + { + protected: + _Result (*_M_ptr)(_Arg); + + public: + pointer_to_unary_function() { } + + explicit + pointer_to_unary_function(_Result (*__x)(_Arg)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg __x) const + { return _M_ptr(__x); } + } __attribute__ ((__deprecated__)); + + + template + __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) + inline pointer_to_unary_function<_Arg, _Result> + ptr_fun(_Result (*__x)(_Arg)) + { return pointer_to_unary_function<_Arg, _Result>(__x); } + + + template + class pointer_to_binary_function + : public binary_function<_Arg1, _Arg2, _Result> + { + protected: + _Result (*_M_ptr)(_Arg1, _Arg2); + + public: + pointer_to_binary_function() { } + + explicit + pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) + : _M_ptr(__x) { } + + _Result + operator()(_Arg1 __x, _Arg2 __y) const + { return _M_ptr(__x, __y); } + } __attribute__ ((__deprecated__)); + + + template + __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) + inline pointer_to_binary_function<_Arg1, _Arg2, _Result> + ptr_fun(_Result (*__x)(_Arg1, _Arg2)) + { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } + + + template + struct _Identity + : public unary_function<_Tp, _Tp> + { + _Tp& + operator()(_Tp& __x) const + { return __x; } + + const _Tp& + operator()(const _Tp& __x) const + { return __x; } + }; + + + template struct _Identity : _Identity<_Tp> { }; + + template + struct _Select1st + : public unary_function<_Pair, typename _Pair::first_type> + { + typename _Pair::first_type& + operator()(_Pair& __x) const + { return __x.first; } + + const typename _Pair::first_type& + operator()(const _Pair& __x) const + { return __x.first; } + + + template + typename _Pair2::first_type& + operator()(_Pair2& __x) const + { return __x.first; } + + template + const typename _Pair2::first_type& + operator()(const _Pair2& __x) const + { return __x.first; } + + }; + + template + struct _Select2nd + : public unary_function<_Pair, typename _Pair::second_type> + { + typename _Pair::second_type& + operator()(_Pair& __x) const + { return __x.second; } + + const typename _Pair::second_type& + operator()(const _Pair& __x) const + { return __x.second; } + }; +# 1231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 + template + class mem_fun_t : public unary_function<_Tp*, _Ret> + { + public: + explicit + mem_fun_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun_t : public unary_function + { + public: + explicit + const_mem_fun_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p) const + { return (__p->*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + mem_fun_ref_t(_Ret (_Tp::*__pf)()) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)(); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> + { + public: + explicit + const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r) const + { return (__r.*_M_f)(); } + + private: + _Ret (_Tp::*_M_f)() const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> + { + public: + explicit + mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun1_t : public binary_function + { + public: + explicit + const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp* __p, _Arg __x) const + { return (__p->*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + } __attribute__ ((__deprecated__)); + + + template + class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) + : _M_f(__pf) { } + + _Ret + operator()(_Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg); + } __attribute__ ((__deprecated__)); + + + template + class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> + { + public: + explicit + const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) + : _M_f(__pf) { } + + _Ret + operator()(const _Tp& __r, _Arg __x) const + { return (__r.*_M_f)(__x); } + + private: + _Ret (_Tp::*_M_f)(_Arg) const; + } __attribute__ ((__deprecated__)); + + + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)()) + { return mem_fun_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun_t<_Ret, _Tp> + mem_fun(_Ret (_Tp::*__f)() const) + { return const_mem_fun_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)()) + { return mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun_ref_t<_Ret, _Tp> + mem_fun_ref(_Ret (_Tp::*__f)() const) + { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun1_t<_Ret, _Tp, _Arg> + mem_fun(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } + + template + __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) + inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> + mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } +#pragma GCC diagnostic pop + + + + + template> + struct __has_is_transparent + { }; + + template + struct __has_is_transparent<_Func, _SfinaeType, + __void_t> + { typedef void type; }; + + template + using __has_is_transparent_t + = typename __has_is_transparent<_Func, _SfinaeType>::type; + + + +} + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 1 3 +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 + template + class binder1st + : public unary_function + { + protected: + _Operation op; + typename _Operation::first_argument_type value; + + public: + binder1st(const _Operation& __x, + const typename _Operation::first_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + + + + typename _Operation::result_type + operator()(typename _Operation::second_argument_type& __x) const + { return op(value, __x); } + } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); + + + template + __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) + inline binder1st<_Operation> + bind1st(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::first_argument_type _Arg1_type; + return binder1st<_Operation>(__fn, _Arg1_type(__x)); + } + + + template + class binder2nd + : public unary_function + { + protected: + _Operation op; + typename _Operation::second_argument_type value; + + public: + binder2nd(const _Operation& __x, + const typename _Operation::second_argument_type& __y) + : op(__x), value(__y) { } + + typename _Operation::result_type + operator()(const typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + + + + typename _Operation::result_type + operator()(typename _Operation::first_argument_type& __x) const + { return op(__x, value); } + } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); + + + template + __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) + inline binder2nd<_Operation> + bind2nd(const _Operation& __fn, const _Tp& __x) + { + typedef typename _Operation::second_argument_type _Arg2_type; + return binder2nd<_Operation>(__fn, _Arg2_type(__x)); + } + + + +} + +#pragma GCC diagnostic pop +# 1439 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 2 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 + template + struct _Maybe_unary_or_binary_function { }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1> + : std::unary_function<_T1, _Res> { }; + + + template + struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> + : std::binary_function<_T1, _T2, _Res> { }; + +#pragma GCC diagnostic pop + + template + struct _Mem_fn_traits; + + template + struct _Mem_fn_traits_base + { + using __result_type = _Res; + using __maybe_type + = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; + using __arity = integral_constant; + }; +# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; + + +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; +template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; + + + + + + + template> + struct _Maybe_get_result_type + { }; + + template + struct _Maybe_get_result_type<_Functor, + __void_t> + { typedef typename _Functor::result_type result_type; }; + + + + + + template + struct _Weak_result_type_impl + : _Maybe_get_result_type<_Functor> + { }; + + + template + struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> + { typedef _Res result_type; }; + + + template + struct + _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)> + { typedef _Res result_type; }; + + + template::value> + struct _Weak_result_type_memfun + : _Weak_result_type_impl<_Functor> + { }; + + + template + struct _Weak_result_type_memfun<_MemFunPtr, true> + { + using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; + }; + + + template + struct _Weak_result_type_memfun<_Func _Class::*, false> + { }; + + + + + + template + struct _Weak_result_type + : _Weak_result_type_memfun::type> + { }; + + + + template> + struct _Refwrap_base_arg1 + { }; + + + template + struct _Refwrap_base_arg1<_Tp, + __void_t> + { + typedef typename _Tp::argument_type argument_type; + }; + + + template> + struct _Refwrap_base_arg2 + { }; + + + template + struct _Refwrap_base_arg2<_Tp, + __void_t> + { + typedef typename _Tp::first_argument_type first_argument_type; + typedef typename _Tp::second_argument_type second_argument_type; + }; + + + + + + + + template + struct _Reference_wrapper_base + : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> + { }; + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + + template + struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) volatile> + : unary_function<_T1, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1) const volatile> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> + : binary_function<_T1, _T2, _Res> + { }; + + template + struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> + : binary_function<_T1, _T2, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)> + : unary_function<_T1, _Res> + { }; + + + template + struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)> + : binary_function<_T1, _T2, _Res> + { }; + + template::value> + struct _Reference_wrapper_base_memfun + : _Reference_wrapper_base<_Tp> + { }; + + template + struct _Reference_wrapper_base_memfun<_MemFunPtr, true> + : _Mem_fn_traits<_MemFunPtr>::__maybe_type + { + using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; + }; +#pragma GCC diagnostic pop + + + + + + + + + template + class reference_wrapper + + + + : public _Reference_wrapper_base_memfun::type> + + { + _Tp* _M_data; + + + static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } + + static void _S_fun(_Tp&&) = delete; + + template> + using __not_same + = typename enable_if::value>::type; + + public: + typedef _Tp type; + + + + + template, typename + = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> + + reference_wrapper(_Up&& __uref) + noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) + : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) + { } + + reference_wrapper(const reference_wrapper&) = default; + + reference_wrapper& + operator=(const reference_wrapper&) = default; + + + operator _Tp&() const noexcept + { return this->get(); } + + + _Tp& + get() const noexcept + { return *_M_data; } + + template + + typename __invoke_result<_Tp&, _Args...>::type + operator()(_Args&&... __args) const + noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value) + { + + + + + return std::__invoke(get(), std::forward<_Args>(__args)...); + } + }; + + + template + reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; + + + + + + template + + inline reference_wrapper<_Tp> + ref(_Tp& __t) noexcept + { return reference_wrapper<_Tp>(__t); } + + + template + + inline reference_wrapper + cref(const _Tp& __t) noexcept + { return reference_wrapper(__t); } + + template + void ref(const _Tp&&) = delete; + + template + void cref(const _Tp&&) = delete; + + + template + + inline reference_wrapper<_Tp> + ref(reference_wrapper<_Tp> __t) noexcept + { return __t; } + + + template + + inline reference_wrapper + cref(reference_wrapper<_Tp> __t) noexcept + { return { __t.get() }; } + + + + +} +# 69 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/vector.tcc" 1 3 +# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/vector.tcc" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + + void + vector<_Tp, _Alloc>:: + reserve(size_type __n) + { + if (__n > this->max_size()) + __throw_length_error(("vector::reserve")); + if (this->capacity() < __n) + { + const size_type __old_size = size(); + pointer __tmp; + + if constexpr (_S_use_relocate()) + { + __tmp = this->_M_allocate(__n); + _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish, + __tmp, _M_get_Tp_allocator()); + } + else + + { + __tmp = _M_allocate_and_copy(__n, + std::__make_move_if_noexcept_iterator(this->_M_impl._M_start), + std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish)); + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + } + ; + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __tmp; + this->_M_impl._M_finish = __tmp + __old_size; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; + } + } + + + template + template + + + typename vector<_Tp, _Alloc>::reference + + + + vector<_Tp, _Alloc>:: + emplace_back(_Args&&... __args) + { + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::forward<_Args>(__args)...); + ++this->_M_impl._M_finish; + ; + } + else + _M_realloc_insert(end(), std::forward<_Args>(__args)...); + + return back(); + + } + + + template + + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + + insert(const_iterator __position, const value_type& __x) + + + + { + const size_type __n = __position - begin(); + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + { + do { if (std::__is_constant_evaluated() && !bool(__position != const_iterator())) __builtin_unreachable(); } while (false); + if (!(__position != const_iterator())) + __builtin_unreachable(); + + if (__position == end()) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + __x); + ++this->_M_impl._M_finish; + ; + } + else + { + + const auto __pos = begin() + (__position - cbegin()); + + + _Temporary_value __x_copy(this, __x); + _M_insert_aux(__pos, std::move(__x_copy._M_val())); + + + + } + } + else + + _M_realloc_insert(begin() + (__position - cbegin()), __x); + + + + + return iterator(this->_M_impl._M_start + __n); + } + + template + + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + _M_erase(iterator __position) + { + if (__position + 1 != end()) + std::move(__position + 1, end(), __position); + --this->_M_impl._M_finish; + _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); + ; + return __position; + } + + template + + typename vector<_Tp, _Alloc>::iterator + vector<_Tp, _Alloc>:: + _M_erase(iterator __first, iterator __last) + { + if (__first != __last) + { + if (__last != end()) + std::move(__last, end(), __first); + _M_erase_at_end(__first.base() + (end() - __last)); + } + return __first; + } + + template + + vector<_Tp, _Alloc>& + vector<_Tp, _Alloc>:: + operator=(const vector<_Tp, _Alloc>& __x) + { + if (std::__addressof(__x) != this) + { + ; + + if (_Alloc_traits::_S_propagate_on_copy_assign()) + { + if (!_Alloc_traits::_S_always_equal() + && _M_get_Tp_allocator() != __x._M_get_Tp_allocator()) + { + + this->clear(); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = nullptr; + this->_M_impl._M_finish = nullptr; + this->_M_impl._M_end_of_storage = nullptr; + } + std::__alloc_on_copy(_M_get_Tp_allocator(), + __x._M_get_Tp_allocator()); + } + + const size_type __xlen = __x.size(); + if (__xlen > capacity()) + { + pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), + __x.end()); + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __tmp; + this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen; + } + else if (size() >= __xlen) + { + std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), + end(), _M_get_Tp_allocator()); + } + else + { + std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(), + this->_M_impl._M_start); + std::__uninitialized_copy_a(__x._M_impl._M_start + size(), + __x._M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + } + this->_M_impl._M_finish = this->_M_impl._M_start + __xlen; + } + return *this; + } + + template + + void + vector<_Tp, _Alloc>:: + _M_fill_assign(size_t __n, const value_type& __val) + { + if (__n > capacity()) + { + vector __tmp(__n, __val, _M_get_Tp_allocator()); + __tmp._M_impl._M_swap_data(this->_M_impl); + } + else if (__n > size()) + { + std::fill(begin(), end(), __val); + const size_type __add = __n - size(); + ; + this->_M_impl._M_finish = + std::__uninitialized_fill_n_a(this->_M_impl._M_finish, + __add, __val, _M_get_Tp_allocator()); + ; + } + else + _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val)); + } + + template + template + + void + vector<_Tp, _Alloc>:: + _M_assign_aux(_InputIterator __first, _InputIterator __last, + std::input_iterator_tag) + { + pointer __cur(this->_M_impl._M_start); + for (; __first != __last && __cur != this->_M_impl._M_finish; + ++__cur, (void)++__first) + *__cur = *__first; + if (__first == __last) + _M_erase_at_end(__cur); + else + _M_range_insert(end(), __first, __last, + std::__iterator_category(__first)); + } + + template + template + + void + vector<_Tp, _Alloc>:: + _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, + std::forward_iterator_tag) + { + const size_type __len = std::distance(__first, __last); + + if (__len > capacity()) + { + _S_check_init_len(__len, _M_get_Tp_allocator()); + pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); + std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, + _M_get_Tp_allocator()); + ; + _M_deallocate(this->_M_impl._M_start, + this->_M_impl._M_end_of_storage + - this->_M_impl._M_start); + this->_M_impl._M_start = __tmp; + this->_M_impl._M_finish = this->_M_impl._M_start + __len; + this->_M_impl._M_end_of_storage = this->_M_impl._M_finish; + } + else if (size() >= __len) + _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, size()); + std::copy(__first, __mid, this->_M_impl._M_start); + const size_type __attribute__((__unused__)) __n = __len - size(); + ; + this->_M_impl._M_finish = + std::__uninitialized_copy_a(__mid, __last, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + ; + } + } + + + template + + auto + vector<_Tp, _Alloc>:: + _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator + { + const auto __n = __position - cbegin(); + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + if (__position == cend()) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::move(__v)); + ++this->_M_impl._M_finish; + ; + } + else + _M_insert_aux(begin() + __n, std::move(__v)); + else + _M_realloc_insert(begin() + __n, std::move(__v)); + + return iterator(this->_M_impl._M_start + __n); + } + + template + template + + auto + vector<_Tp, _Alloc>:: + _M_emplace_aux(const_iterator __position, _Args&&... __args) + -> iterator + { + const auto __n = __position - cbegin(); + if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) + if (__position == cend()) + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::forward<_Args>(__args)...); + ++this->_M_impl._M_finish; + ; + } + else + { + + + + _Temporary_value __tmp(this, std::forward<_Args>(__args)...); + _M_insert_aux(begin() + __n, std::move(__tmp._M_val())); + } + else + _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...); + + return iterator(this->_M_impl._M_start + __n); + } + + template + template + + void + vector<_Tp, _Alloc>:: + _M_insert_aux(iterator __position, _Arg&& __arg) + + + + + + + { + ; + _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, + std::move(*(this->_M_impl._M_finish - 1))); + ++this->_M_impl._M_finish; + ; + + + + std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1); + + + + + + *__position = std::forward<_Arg>(__arg); + + } + + + template + template + + void + vector<_Tp, _Alloc>:: + _M_realloc_insert(iterator __position, _Args&&... __args) + + + + + + + { + const size_type __len = + _M_check_len(size_type(1), "vector::_M_realloc_insert"); + pointer __old_start = this->_M_impl._M_start; + pointer __old_finish = this->_M_impl._M_finish; + const size_type __elems_before = __position - begin(); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + try + { + + + + + + _Alloc_traits::construct(this->_M_impl, + __new_start + __elems_before, + + std::forward<_Args>(__args)...); + + + + __new_finish = pointer(); + + + if constexpr (_S_use_relocate()) + { + __new_finish = _S_relocate(__old_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + + ++__new_finish; + + __new_finish = _S_relocate(__position.base(), __old_finish, + __new_finish, _M_get_Tp_allocator()); + } + else + + { + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__old_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + + ++__new_finish; + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__position.base(), __old_finish, + __new_finish, _M_get_Tp_allocator()); + } + } + catch(...) + { + if (!__new_finish) + _Alloc_traits::destroy(this->_M_impl, + __new_start + __elems_before); + else + std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + throw; + } + + if constexpr (!_S_use_relocate()) + + std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); + ; + _M_deallocate(__old_start, + this->_M_impl._M_end_of_storage - __old_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + + template + + void + vector<_Tp, _Alloc>:: + _M_fill_insert(iterator __position, size_type __n, const value_type& __x) + { + if (__n != 0) + { + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >= __n) + { + + + + _Temporary_value __tmp(this, __x); + value_type& __x_copy = __tmp._M_val(); + + const size_type __elems_after = end() - __position; + pointer __old_finish(this->_M_impl._M_finish); + if (__elems_after > __n) + { + ; + std::__uninitialized_move_a(__old_finish - __n, + __old_finish, + __old_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n; + ; + std::move_backward(__position.base(), __old_finish - __n, __old_finish); + + std::fill(__position.base(), __position.base() + __n, + __x_copy); + } + else + { + ; + this->_M_impl._M_finish = + std::__uninitialized_fill_n_a(__old_finish, + __n - __elems_after, + __x_copy, + _M_get_Tp_allocator()); + ; + std::__uninitialized_move_a(__position.base(), __old_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __elems_after; + ; + std::fill(__position.base(), __old_finish, __x_copy); + } + } + else + { + + + pointer __old_start = this->_M_impl._M_start; + pointer __old_finish = this->_M_impl._M_finish; + const pointer __pos = __position.base(); + + const size_type __len = + _M_check_len(__n, "vector::_M_fill_insert"); + const size_type __elems_before = __pos - __old_start; + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + try + { + + std::__uninitialized_fill_n_a(__new_start + __elems_before, + __n, __x, + _M_get_Tp_allocator()); + __new_finish = pointer(); + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__old_start, __pos, __new_start, _M_get_Tp_allocator()); + + __new_finish += __n; + + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__pos, __old_finish, __new_finish, _M_get_Tp_allocator()); + } + catch(...) + { + if (!__new_finish) + std::_Destroy(__new_start + __elems_before, + __new_start + __elems_before + __n, + _M_get_Tp_allocator()); + else + std::_Destroy(__new_start, __new_finish, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + throw; + } + std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); + ; + _M_deallocate(__old_start, + this->_M_impl._M_end_of_storage - __old_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } + + + template + + void + vector<_Tp, _Alloc>:: + _M_default_append(size_type __n) + { + if (__n != 0) + { + const size_type __size = size(); + size_type __navail = size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish); + + if (__size > max_size() || __navail > max_size() - __size) + __builtin_unreachable(); + + if (__navail >= __n) + { + ; + this->_M_impl._M_finish = + std::__uninitialized_default_n_a(this->_M_impl._M_finish, + __n, _M_get_Tp_allocator()); + ; + } + else + { + + + pointer __old_start = this->_M_impl._M_start; + pointer __old_finish = this->_M_impl._M_finish; + + const size_type __len = + _M_check_len(__n, "vector::_M_default_append"); + pointer __new_start(this->_M_allocate(__len)); + if constexpr (_S_use_relocate()) + { + try + { + std::__uninitialized_default_n_a(__new_start + __size, + __n, _M_get_Tp_allocator()); + } + catch(...) + { + _M_deallocate(__new_start, __len); + throw; + } + _S_relocate(__old_start, __old_finish, + __new_start, _M_get_Tp_allocator()); + } + else + { + pointer __destroy_from = pointer(); + try + { + std::__uninitialized_default_n_a(__new_start + __size, + __n, _M_get_Tp_allocator()); + __destroy_from = __new_start + __size; + std::__uninitialized_move_if_noexcept_a( + __old_start, __old_finish, + __new_start, _M_get_Tp_allocator()); + } + catch(...) + { + if (__destroy_from) + std::_Destroy(__destroy_from, __destroy_from + __n, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + throw; + } + std::_Destroy(__old_start, __old_finish, + _M_get_Tp_allocator()); + } + ; + _M_deallocate(__old_start, + this->_M_impl._M_end_of_storage - __old_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_start + __size + __n; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } + + template + + bool + vector<_Tp, _Alloc>:: + _M_shrink_to_fit() + { + if (capacity() == size()) + return false; + ; + return std::__shrink_to_fit_aux::_S_do_it(*this); + } + + + template + template + + void + vector<_Tp, _Alloc>:: + _M_range_insert(iterator __pos, _InputIterator __first, + _InputIterator __last, std::input_iterator_tag) + { + if (__pos == end()) + { + for (; __first != __last; ++__first) + insert(end(), *__first); + } + else if (__first != __last) + { + vector __tmp(__first, __last, _M_get_Tp_allocator()); + insert(__pos, + std::make_move_iterator(__tmp.begin()), + std::make_move_iterator(__tmp.end())); + } + } + + template + template + + void + vector<_Tp, _Alloc>:: + _M_range_insert(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag) + { + if (__first != __last) + { + const size_type __n = std::distance(__first, __last); + if (size_type(this->_M_impl._M_end_of_storage + - this->_M_impl._M_finish) >= __n) + { + const size_type __elems_after = end() - __position; + pointer __old_finish(this->_M_impl._M_finish); + if (__elems_after > __n) + { + ; + std::__uninitialized_move_a(this->_M_impl._M_finish - __n, + this->_M_impl._M_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n; + ; + std::move_backward(__position.base(), __old_finish - __n, __old_finish); + + std::copy(__first, __last, __position); + } + else + { + _ForwardIterator __mid = __first; + std::advance(__mid, __elems_after); + ; + std::__uninitialized_copy_a(__mid, __last, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __n - __elems_after; + ; + std::__uninitialized_move_a(__position.base(), + __old_finish, + this->_M_impl._M_finish, + _M_get_Tp_allocator()); + this->_M_impl._M_finish += __elems_after; + ; + std::copy(__first, __mid, __position); + } + } + else + { + + + + pointer __old_start = this->_M_impl._M_start; + pointer __old_finish = this->_M_impl._M_finish; + + const size_type __len = + _M_check_len(__n, "vector::_M_range_insert"); + pointer __new_start(this->_M_allocate(__len)); + pointer __new_finish(__new_start); + try + { + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__old_start, __position.base(), + __new_start, _M_get_Tp_allocator()); + __new_finish + = std::__uninitialized_copy_a(__first, __last, + __new_finish, + _M_get_Tp_allocator()); + __new_finish + = std::__uninitialized_move_if_noexcept_a + (__position.base(), __old_finish, + __new_finish, _M_get_Tp_allocator()); + } + catch(...) + { + std::_Destroy(__new_start, __new_finish, + _M_get_Tp_allocator()); + _M_deallocate(__new_start, __len); + throw; + } + std::_Destroy(__old_start, __old_finish, + _M_get_Tp_allocator()); + ; + _M_deallocate(__old_start, + this->_M_impl._M_end_of_storage - __old_start); + this->_M_impl._M_start = __new_start; + this->_M_impl._M_finish = __new_finish; + this->_M_impl._M_end_of_storage = __new_start + __len; + } + } + } + + + + template + + void + vector:: + _M_reallocate(size_type __n) + { + _Bit_pointer __q = this->_M_allocate(__n); + iterator __start(std::__addressof(*__q), 0); + iterator __finish(_M_copy_aligned(begin(), end(), __start)); + this->_M_deallocate(); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __finish; + this->_M_impl._M_end_of_storage = __q + _S_nword(__n); + } + + template + + void + vector:: + _M_fill_insert(iterator __position, size_type __n, bool __x) + { + if (__n == 0) + return; + if (capacity() - size() >= __n) + { + std::copy_backward(__position, end(), + this->_M_impl._M_finish + difference_type(__n)); + std::fill(__position, __position + difference_type(__n), __x); + this->_M_impl._M_finish += difference_type(__n); + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_fill_insert"); + _Bit_pointer __q = this->_M_allocate(__len); + iterator __start(std::__addressof(*__q), 0); + iterator __i = _M_copy_aligned(begin(), __position, __start); + std::fill(__i, __i + difference_type(__n), __x); + iterator __finish = std::copy(__position, end(), + __i + difference_type(__n)); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage = __q + _S_nword(__len); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __finish; + } + } + + template + template + + void + vector:: + _M_insert_range(iterator __position, _ForwardIterator __first, + _ForwardIterator __last, std::forward_iterator_tag) + { + if (__first != __last) + { + size_type __n = std::distance(__first, __last); + if (capacity() - size() >= __n) + { + std::copy_backward(__position, end(), + this->_M_impl._M_finish + + difference_type(__n)); + std::copy(__first, __last, __position); + this->_M_impl._M_finish += difference_type(__n); + } + else + { + const size_type __len = + _M_check_len(__n, "vector::_M_insert_range"); + const iterator __begin = begin(), __end = end(); + _Bit_pointer __q = this->_M_allocate(__len); + iterator __start(std::__addressof(*__q), 0); + iterator __i = _M_copy_aligned(__begin, __position, __start); + __i = std::copy(__first, __last, __i); + iterator __finish = std::copy(__position, __end, __i); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage = __q + _S_nword(__len); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __finish; + } + } + } + + template + + void + vector:: + _M_insert_aux(iterator __position, bool __x) + { + if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) + { + std::copy_backward(__position, this->_M_impl._M_finish, + this->_M_impl._M_finish + 1); + *__position = __x; + ++this->_M_impl._M_finish; + } + else + { + const size_type __len = + _M_check_len(size_type(1), "vector::_M_insert_aux"); + _Bit_pointer __q = this->_M_allocate(__len); + iterator __start(std::__addressof(*__q), 0); + iterator __i = _M_copy_aligned(begin(), __position, __start); + *__i++ = __x; + iterator __finish = std::copy(__position, end(), __i); + this->_M_deallocate(); + this->_M_impl._M_end_of_storage = __q + _S_nword(__len); + this->_M_impl._M_start = __start; + this->_M_impl._M_finish = __finish; + } + } + + template + + typename vector::iterator + vector:: + _M_erase(iterator __position) + { + if (__position + 1 != end()) + std::copy(__position + 1, end(), __position); + --this->_M_impl._M_finish; + return __position; + } + + template + + typename vector::iterator + vector:: + _M_erase(iterator __first, iterator __last) + { + if (__first != __last) + _M_erase_at_end(std::copy(__last, end(), __first)); + return __first; + } + + + template + + bool + vector:: + _M_shrink_to_fit() + { + if (capacity() - size() < int(_S_word_bit)) + return false; + try + { + if (size_type __n = size()) + _M_reallocate(__n); + else + { + this->_M_deallocate(); + this->_M_impl._M_reset(); + } + return true; + } + catch(...) + { return false; } + } + + + + +} + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + size_t + hash>:: + operator()(const std::vector& __b) const noexcept + { + size_t __hash = 0; + const size_t __words = __b.size() / _S_word_bit; + if (__words) + { + const size_t __clength = __words * sizeof(_Bit_type); + __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength); + } + + const size_t __extrabits = __b.size() % _S_word_bit; + if (__extrabits) + { + _Bit_type __hiword = *__b._M_impl._M_finish._M_p; + __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits); + + const size_t __clength + = (__extrabits + 8 - 1) / 8; + if (__words) + __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash); + else + __hash = std::_Hash_impl::hash(&__hiword, __clength); + } + + return __hash; + } + + +} +# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 + + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 + + + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + struct __erased_type { }; + + + + + template + using __is_erased_or_convertible + = __or_, is_same<_Tp, __erased_type>>; + + + struct allocator_arg_t { explicit allocator_arg_t() = default; }; + + inline constexpr allocator_arg_t allocator_arg = + allocator_arg_t(); + + template> + struct __uses_allocator_helper + : false_type { }; + + template + struct __uses_allocator_helper<_Tp, _Alloc, + __void_t> + : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type + { }; + + + template + struct uses_allocator + : __uses_allocator_helper<_Tp, _Alloc>::type + { }; + + struct __uses_alloc_base { }; + + struct __uses_alloc0 : __uses_alloc_base + { + struct _Sink { void operator=(const void*) { } } _M_a; + }; + + template + struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; + + template + struct __uses_alloc; + + template + struct __uses_alloc + : __conditional_t< + is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, + __uses_alloc1<_Alloc>, + __uses_alloc2<_Alloc>> + { + + + static_assert(__or_< + is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, + is_constructible<_Tp, _Args..., const _Alloc&>>::value, + "construction with an allocator must be possible" + " if uses_allocator is true"); + }; + + template + struct __uses_alloc + : __uses_alloc0 { }; + + template + using __uses_alloc_t = + __uses_alloc::value, _Tp, _Alloc, _Args...>; + + template + + inline __uses_alloc_t<_Tp, _Alloc, _Args...> + __use_alloc(const _Alloc& __a) + { + __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; + __ret._M_a = std::__addressof(__a); + return __ret; + } + + template + void + __use_alloc(const _Alloc&&) = delete; + + + template + inline constexpr bool uses_allocator_v = + uses_allocator<_Tp, _Alloc>::value; + + + template class _Predicate, + typename _Tp, typename _Alloc, typename... _Args> + struct __is_uses_allocator_predicate + : __conditional_t::value, + __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, + _Predicate<_Tp, _Args..., _Alloc>>, + _Predicate<_Tp, _Args...>> { }; + + template + struct __is_uses_allocator_constructible + : __is_uses_allocator_predicate + { }; + + + template + inline constexpr bool __is_uses_allocator_constructible_v = + __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; + + + template + struct __is_nothrow_uses_allocator_constructible + : __is_uses_allocator_predicate + { }; + + + + template + inline constexpr bool + __is_nothrow_uses_allocator_constructible_v = + __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; + + + template + void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr, + _Args&&... __args) + { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } + + template + void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr, + _Args&&... __args) + { + ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a, + std::forward<_Args>(__args)...); + } + + template + void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr, + _Args&&... __args) + { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); } + + template + void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr, + _Args&&... __args) + { + std::__uses_allocator_construct_impl( + std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr, + std::forward<_Args>(__args)...); + } + + + +} +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2 \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/swapchain/__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/swapchain/__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp new file mode 100644 index 0000000..3cc788a --- /dev/null +++ b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/swapchain/__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp @@ -0,0 +1,18406 @@ +# 1 "src/renderer/swapchain/vk_swapchain.cpp" +# 1 "" 1 +# 1 "" 3 +# 433 "" 3 +# 1 "" 1 +# 1 "" 2 +# 1 "src/renderer/swapchain/vk_swapchain.cpp" 2 +# 16 "src/renderer/swapchain/vk_swapchain.cpp" +# 1 "/usr/include/SDL2/SDL_vulkan.h" 1 3 4 +# 31 "/usr/include/SDL2/SDL_vulkan.h" 3 4 +# 1 "/usr/include/SDL2/SDL_video.h" 1 3 4 +# 31 "/usr/include/SDL2/SDL_video.h" 3 4 +# 1 "/usr/include/SDL2/SDL_stdinc.h" 1 3 4 +# 31 "/usr/include/SDL2/SDL_stdinc.h" 3 4 +# 1 "/usr/include/SDL2/SDL_config.h" 1 3 4 +# 32 "/usr/include/SDL2/SDL_config.h" 3 4 +# 1 "/usr/include/SDL2/SDL_platform.h" 1 3 4 +# 229 "/usr/include/SDL2/SDL_platform.h" 3 4 +# 1 "/usr/include/SDL2/begin_code.h" 1 3 4 +# 230 "/usr/include/SDL2/SDL_platform.h" 2 3 4 + + +extern "C" { +# 251 "/usr/include/SDL2/SDL_platform.h" 3 4 +extern __attribute__ ((visibility("default"))) const char * SDL_GetPlatform (void); + + + +} + +# 1 "/usr/include/SDL2/close_code.h" 1 3 4 +# 258 "/usr/include/SDL2/SDL_platform.h" 2 3 4 +# 33 "/usr/include/SDL2/SDL_config.h" 2 3 4 +# 32 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + +# 1 "/usr/include/sys/types.h" 1 3 4 +# 25 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/features.h" 1 3 4 +# 394 "/usr/include/features.h" 3 4 +# 1 "/usr/include/features-time64.h" 1 3 4 +# 20 "/usr/include/features-time64.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 21 "/usr/include/features-time64.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 22 "/usr/include/features-time64.h" 2 3 4 +# 395 "/usr/include/features.h" 2 3 4 +# 481 "/usr/include/features.h" 3 4 +# 1 "/usr/include/stdc-predef.h" 1 3 4 +# 482 "/usr/include/features.h" 2 3 4 +# 503 "/usr/include/features.h" 3 4 +# 1 "/usr/include/sys/cdefs.h" 1 3 4 +# 576 "/usr/include/sys/cdefs.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 577 "/usr/include/sys/cdefs.h" 2 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 578 "/usr/include/sys/cdefs.h" 2 3 4 +# 504 "/usr/include/features.h" 2 3 4 +# 527 "/usr/include/features.h" 3 4 +# 1 "/usr/include/gnu/stubs.h" 1 3 4 +# 10 "/usr/include/gnu/stubs.h" 3 4 +# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 +# 11 "/usr/include/gnu/stubs.h" 2 3 4 +# 528 "/usr/include/features.h" 2 3 4 +# 26 "/usr/include/sys/types.h" 2 3 4 + +extern "C" { + +# 1 "/usr/include/bits/types.h" 1 3 4 +# 27 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 28 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/timesize.h" 1 3 4 +# 19 "/usr/include/bits/timesize.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 20 "/usr/include/bits/timesize.h" 2 3 4 +# 29 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned char __u_char; +typedef unsigned short int __u_short; +typedef unsigned int __u_int; +typedef unsigned long int __u_long; + + +typedef signed char __int8_t; +typedef unsigned char __uint8_t; +typedef signed short int __int16_t; +typedef unsigned short int __uint16_t; +typedef signed int __int32_t; +typedef unsigned int __uint32_t; + +typedef signed long int __int64_t; +typedef unsigned long int __uint64_t; + + + + + + +typedef __int8_t __int_least8_t; +typedef __uint8_t __uint_least8_t; +typedef __int16_t __int_least16_t; +typedef __uint16_t __uint_least16_t; +typedef __int32_t __int_least32_t; +typedef __uint32_t __uint_least32_t; +typedef __int64_t __int_least64_t; +typedef __uint64_t __uint_least64_t; + + + +typedef long int __quad_t; +typedef unsigned long int __u_quad_t; + + + + + + + +typedef long int __intmax_t; +typedef unsigned long int __uintmax_t; +# 141 "/usr/include/bits/types.h" 3 4 +# 1 "/usr/include/bits/typesizes.h" 1 3 4 +# 142 "/usr/include/bits/types.h" 2 3 4 +# 1 "/usr/include/bits/time64.h" 1 3 4 +# 143 "/usr/include/bits/types.h" 2 3 4 + + +typedef unsigned long int __dev_t; +typedef unsigned int __uid_t; +typedef unsigned int __gid_t; +typedef unsigned long int __ino_t; +typedef unsigned long int __ino64_t; +typedef unsigned int __mode_t; +typedef unsigned long int __nlink_t; +typedef long int __off_t; +typedef long int __off64_t; +typedef int __pid_t; +typedef struct { int __val[2]; } __fsid_t; +typedef long int __clock_t; +typedef unsigned long int __rlim_t; +typedef unsigned long int __rlim64_t; +typedef unsigned int __id_t; +typedef long int __time_t; +typedef unsigned int __useconds_t; +typedef long int __suseconds_t; +typedef long int __suseconds64_t; + +typedef int __daddr_t; +typedef int __key_t; + + +typedef int __clockid_t; + + +typedef void * __timer_t; + + +typedef long int __blksize_t; + + + + +typedef long int __blkcnt_t; +typedef long int __blkcnt64_t; + + +typedef unsigned long int __fsblkcnt_t; +typedef unsigned long int __fsblkcnt64_t; + + +typedef unsigned long int __fsfilcnt_t; +typedef unsigned long int __fsfilcnt64_t; + + +typedef long int __fsword_t; + +typedef long int __ssize_t; + + +typedef long int __syscall_slong_t; + +typedef unsigned long int __syscall_ulong_t; + + + +typedef __off64_t __loff_t; +typedef char *__caddr_t; + + +typedef long int __intptr_t; + + +typedef unsigned int __socklen_t; + + + + +typedef int __sig_atomic_t; +# 30 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __u_char u_char; +typedef __u_short u_short; +typedef __u_int u_int; +typedef __u_long u_long; +typedef __quad_t quad_t; +typedef __u_quad_t u_quad_t; +typedef __fsid_t fsid_t; + + +typedef __loff_t loff_t; + + + + +typedef __ino_t ino_t; + + + + + + +typedef __ino64_t ino64_t; + + + + +typedef __dev_t dev_t; + + + + +typedef __gid_t gid_t; + + + + +typedef __mode_t mode_t; + + + + +typedef __nlink_t nlink_t; + + + + +typedef __uid_t uid_t; + + + + + +typedef __off_t off_t; + + + + + + +typedef __off64_t off64_t; + + + + +typedef __pid_t pid_t; + + + + + +typedef __id_t id_t; + + + + +typedef __ssize_t ssize_t; + + + + + +typedef __daddr_t daddr_t; +typedef __caddr_t caddr_t; + + + + + +typedef __key_t key_t; + + + + +# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 + + + + + + +typedef __clock_t clock_t; +# 127 "/usr/include/sys/types.h" 2 3 4 + +# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 + + + + + + +typedef __clockid_t clockid_t; +# 129 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/time_t.h" 1 3 4 +# 10 "/usr/include/bits/types/time_t.h" 3 4 +typedef __time_t time_t; +# 130 "/usr/include/sys/types.h" 2 3 4 +# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 + + + + + + +typedef __timer_t timer_t; +# 131 "/usr/include/sys/types.h" 2 3 4 + + + +typedef __useconds_t useconds_t; + + + +typedef __suseconds_t suseconds_t; + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 +typedef long unsigned int size_t; +# 145 "/usr/include/sys/types.h" 2 3 4 + + + +typedef unsigned long int ulong; +typedef unsigned short int ushort; +typedef unsigned int uint; + + + + +# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-intn.h" 3 4 +typedef __int8_t int8_t; +typedef __int16_t int16_t; +typedef __int32_t int32_t; +typedef __int64_t int64_t; +# 156 "/usr/include/sys/types.h" 2 3 4 + + +typedef __uint8_t u_int8_t; +typedef __uint16_t u_int16_t; +typedef __uint32_t u_int32_t; +typedef __uint64_t u_int64_t; + + +typedef int register_t __attribute__ ((__mode__ (__word__))); +# 176 "/usr/include/sys/types.h" 3 4 +# 1 "/usr/include/endian.h" 1 3 4 +# 24 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/endian.h" 1 3 4 +# 35 "/usr/include/bits/endian.h" 3 4 +# 1 "/usr/include/bits/endianness.h" 1 3 4 +# 36 "/usr/include/bits/endian.h" 2 3 4 +# 25 "/usr/include/endian.h" 2 3 4 +# 35 "/usr/include/endian.h" 3 4 +# 1 "/usr/include/bits/byteswap.h" 1 3 4 +# 33 "/usr/include/bits/byteswap.h" 3 4 +static __inline __uint16_t +__bswap_16 (__uint16_t __bsx) +{ + + + + return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8))); + +} + + + + + + +static __inline __uint32_t +__bswap_32 (__uint32_t __bsx) +{ + + + + return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); + +} +# 69 "/usr/include/bits/byteswap.h" 3 4 +__extension__ static __inline __uint64_t +__bswap_64 (__uint64_t __bsx) +{ + + + + return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56)); + +} +# 36 "/usr/include/endian.h" 2 3 4 +# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 +# 32 "/usr/include/bits/uintn-identity.h" 3 4 +static __inline __uint16_t +__uint16_identity (__uint16_t __x) +{ + return __x; +} + +static __inline __uint32_t +__uint32_identity (__uint32_t __x) +{ + return __x; +} + +static __inline __uint64_t +__uint64_identity (__uint64_t __x) +{ + return __x; +} +# 37 "/usr/include/endian.h" 2 3 4 +# 177 "/usr/include/sys/types.h" 2 3 4 + + +# 1 "/usr/include/sys/select.h" 1 3 4 +# 30 "/usr/include/sys/select.h" 3 4 +# 1 "/usr/include/bits/select.h" 1 3 4 +# 31 "/usr/include/sys/select.h" 2 3 4 + + +# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 + + + +# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 + + + + +typedef struct +{ + unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; +} __sigset_t; +# 5 "/usr/include/bits/types/sigset_t.h" 2 3 4 + + +typedef __sigset_t sigset_t; +# 34 "/usr/include/sys/select.h" 2 3 4 + + + +# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 + + + + + + + +struct timeval +{ + + + + + __time_t tv_sec; + __suseconds_t tv_usec; + +}; +# 38 "/usr/include/sys/select.h" 2 3 4 + +# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 +# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 +struct timespec +{ + + + + __time_t tv_sec; + + + + + __syscall_slong_t tv_nsec; +# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 +}; +# 40 "/usr/include/sys/select.h" 2 3 4 +# 49 "/usr/include/sys/select.h" 3 4 +typedef long int __fd_mask; +# 59 "/usr/include/sys/select.h" 3 4 +typedef struct + { + + + + __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; + + + + + + } fd_set; + + + + + + +typedef __fd_mask fd_mask; +# 91 "/usr/include/sys/select.h" 3 4 +extern "C" { +# 102 "/usr/include/sys/select.h" 3 4 +extern int select (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + struct timeval *__restrict __timeout); +# 127 "/usr/include/sys/select.h" 3 4 +extern int pselect (int __nfds, fd_set *__restrict __readfds, + fd_set *__restrict __writefds, + fd_set *__restrict __exceptfds, + const struct timespec *__restrict __timeout, + const __sigset_t *__restrict __sigmask); +# 153 "/usr/include/sys/select.h" 3 4 +} +# 180 "/usr/include/sys/types.h" 2 3 4 + + + + + +typedef __blksize_t blksize_t; + + + + + + +typedef __blkcnt_t blkcnt_t; + + + +typedef __fsblkcnt_t fsblkcnt_t; + + + +typedef __fsfilcnt_t fsfilcnt_t; +# 219 "/usr/include/sys/types.h" 3 4 +typedef __blkcnt64_t blkcnt64_t; +typedef __fsblkcnt64_t fsblkcnt64_t; +typedef __fsfilcnt64_t fsfilcnt64_t; + + + + + +# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 +# 23 "/usr/include/bits/pthreadtypes.h" 3 4 +# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 +# 44 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 +# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 +# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 + +# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 +# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 +typedef union +{ + __extension__ unsigned long long int __value64; + struct + { + unsigned int __low; + unsigned int __high; + } __value32; +} __atomic_wide_counter; +# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +typedef struct __pthread_internal_list +{ + struct __pthread_internal_list *__prev; + struct __pthread_internal_list *__next; +} __pthread_list_t; + +typedef struct __pthread_internal_slist +{ + struct __pthread_internal_slist *__next; +} __pthread_slist_t; +# 76 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 +# 22 "/usr/include/bits/struct_mutex.h" 3 4 +struct __pthread_mutex_s +{ + int __lock; + unsigned int __count; + int __owner; + + unsigned int __nusers; + + + + int __kind; + + short __spins; + short __elision; + __pthread_list_t __list; +# 53 "/usr/include/bits/struct_mutex.h" 3 4 +}; +# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 +# 89 "/usr/include/bits/thread-shared-types.h" 3 4 +# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 +# 23 "/usr/include/bits/struct_rwlock.h" 3 4 +struct __pthread_rwlock_arch_t +{ + unsigned int __readers; + unsigned int __writers; + unsigned int __wrphase_futex; + unsigned int __writers_futex; + unsigned int __pad3; + unsigned int __pad4; + + int __cur_writer; + int __shared; + signed char __rwelision; + + + + + unsigned char __pad1[7]; + + + unsigned long int __pad2; + + + unsigned int __flags; +# 55 "/usr/include/bits/struct_rwlock.h" 3 4 +}; +# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 + + + + +struct __pthread_cond_s +{ + __atomic_wide_counter __wseq; + __atomic_wide_counter __g1_start; + unsigned int __g_refs[2] ; + unsigned int __g_size[2]; + unsigned int __g1_orig_size; + unsigned int __wrefs; + unsigned int __g_signals[2]; +}; + +typedef unsigned int __tss_t; +typedef unsigned long int __thrd_t; + +typedef struct +{ + int __data ; +} __once_flag; +# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 + + + +typedef unsigned long int pthread_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_mutexattr_t; + + + + +typedef union +{ + char __size[4]; + int __align; +} pthread_condattr_t; + + + +typedef unsigned int pthread_key_t; + + + +typedef int pthread_once_t; + + +union pthread_attr_t +{ + char __size[56]; + long int __align; +}; + +typedef union pthread_attr_t pthread_attr_t; + + + + +typedef union +{ + struct __pthread_mutex_s __data; + char __size[40]; + long int __align; +} pthread_mutex_t; + + +typedef union +{ + struct __pthread_cond_s __data; + char __size[48]; + __extension__ long long int __align; +} pthread_cond_t; + + + + + +typedef union +{ + struct __pthread_rwlock_arch_t __data; + char __size[56]; + long int __align; +} pthread_rwlock_t; + +typedef union +{ + char __size[8]; + long int __align; +} pthread_rwlockattr_t; + + + + + +typedef volatile int pthread_spinlock_t; + + + + +typedef union +{ + char __size[32]; + long int __align; +} pthread_barrier_t; + +typedef union +{ + char __size[4]; + int __align; +} pthread_barrierattr_t; +# 228 "/usr/include/sys/types.h" 2 3 4 + + +} +# 35 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + +# 1 "/usr/include/stdio.h" 1 3 4 +# 27 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/stdio.h" 2 3 4 + +extern "C" { + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 34 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 +# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 +typedef __builtin_va_list __gnuc_va_list; +# 37 "/usr/include/stdio.h" 2 3 4 + + +# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4 + + + + +# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 +# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 +typedef struct +{ + int __count; + union + { + unsigned int __wch; + char __wchb[4]; + } __value; +} __mbstate_t; +# 6 "/usr/include/bits/types/__fpos_t.h" 2 3 4 + + + + +typedef struct _G_fpos_t +{ + __off_t __pos; + __mbstate_t __state; +} __fpos_t; +# 40 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4 +# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4 +typedef struct _G_fpos64_t +{ + __off64_t __pos; + __mbstate_t __state; +} __fpos64_t; +# 41 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 + + + +struct _IO_FILE; +typedef struct _IO_FILE __FILE; +# 42 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/FILE.h" 1 3 4 + + + +struct _IO_FILE; + + +typedef struct _IO_FILE FILE; +# 43 "/usr/include/stdio.h" 2 3 4 +# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4 +# 35 "/usr/include/bits/types/struct_FILE.h" 3 4 +struct _IO_FILE; +struct _IO_marker; +struct _IO_codecvt; +struct _IO_wide_data; + + + + +typedef void _IO_lock_t; + + + + + +struct _IO_FILE +{ + int _flags; + + + char *_IO_read_ptr; + char *_IO_read_end; + char *_IO_read_base; + char *_IO_write_base; + char *_IO_write_ptr; + char *_IO_write_end; + char *_IO_buf_base; + char *_IO_buf_end; + + + char *_IO_save_base; + char *_IO_backup_base; + char *_IO_save_end; + + struct _IO_marker *_markers; + + struct _IO_FILE *_chain; + + int _fileno; + int _flags2; + __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/bits/types/cookie_io_functions_t.h" 1 3 4 +# 27 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4 +typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, + size_t __nbytes); + + + + + + + +typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, + size_t __nbytes); + + + + + + + +typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); + + +typedef int cookie_close_function_t (void *__cookie); + + + + + + +typedef struct _IO_cookie_io_functions_t +{ + cookie_read_function_t *read; + cookie_write_function_t *write; + cookie_seek_function_t *seek; + cookie_close_function_t *close; +} cookie_io_functions_t; +# 47 "/usr/include/stdio.h" 2 3 4 + + + + + +typedef __gnuc_va_list va_list; +# 84 "/usr/include/stdio.h" 3 4 +typedef __fpos_t fpos_t; + + + + +typedef __fpos64_t fpos64_t; +# 128 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 +# 129 "/usr/include/stdio.h" 2 3 4 +# 148 "/usr/include/stdio.h" 3 4 +extern FILE *stdin; +extern FILE *stdout; +extern FILE *stderr; + + + + + + +extern int remove (const char *__filename) noexcept (true); + +extern int rename (const char *__old, const char *__new) noexcept (true); + + + +extern int renameat (int __oldfd, const char *__old, int __newfd, + const char *__new) noexcept (true); +# 175 "/usr/include/stdio.h" 3 4 +extern int renameat2 (int __oldfd, const char *__old, int __newfd, + const char *__new, unsigned int __flags) noexcept (true); + + + + + + +extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); +# 193 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile (void) + __attribute__ ((__malloc__)) ; +# 205 "/usr/include/stdio.h" 3 4 +extern FILE *tmpfile64 (void) + __attribute__ ((__malloc__)) ; + + + +extern char *tmpnam (char[20]) noexcept (true) ; + + + + +extern char *tmpnam_r (char __s[20]) noexcept (true) ; +# 227 "/usr/include/stdio.h" 3 4 +extern char *tempnam (const char *__dir, const char *__pfx) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + + + +extern int fflush (FILE *__stream); +# 244 "/usr/include/stdio.h" 3 4 +extern int fflush_unlocked (FILE *__stream); +# 254 "/usr/include/stdio.h" 3 4 +extern int fcloseall (void); +# 263 "/usr/include/stdio.h" 3 4 +extern FILE *fopen (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) ; + + + + +extern FILE *freopen (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); +# 288 "/usr/include/stdio.h" 3 4 +extern FILE *fopen64 (const char *__restrict __filename, + const char *__restrict __modes) + __attribute__ ((__malloc__)) ; +extern FILE *freopen64 (const char *__restrict __filename, + const char *__restrict __modes, + FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); + + + + +extern FILE *fdopen (int __fd, const char *__modes) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern FILE *fopencookie (void *__restrict __magic_cookie, + const char *__restrict __modes, + cookie_io_functions_t __io_funcs) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + +extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + +extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) ; +# 333 "/usr/include/stdio.h" 3 4 +extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true); + + + +extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, + int __modes, size_t __n) noexcept (true); + + + + +extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, + size_t __size) noexcept (true); + + +extern void setlinebuf (FILE *__stream) noexcept (true); + + + + + + + +extern int fprintf (FILE *__restrict __stream, + const char *__restrict __format, ...); + + + + +extern int printf (const char *__restrict __format, ...); + +extern int sprintf (char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); + + + + + +extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg); + + + + +extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); + +extern int vsprintf (char *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) noexcept (true); + + + +extern int snprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); + +extern int vsnprintf (char *__restrict __s, size_t __maxlen, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); + + + + + +extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, + __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ; +extern int __asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; +extern int asprintf (char **__restrict __ptr, + const char *__restrict __fmt, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; + + + + +extern int vdprintf (int __fd, const char *__restrict __fmt, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__printf__, 2, 0))); +extern int dprintf (int __fd, const char *__restrict __fmt, ...) + __attribute__ ((__format__ (__printf__, 2, 3))); + + + + + + + +extern int fscanf (FILE *__restrict __stream, + const char *__restrict __format, ...) ; + + + + +extern int scanf (const char *__restrict __format, ...) ; + +extern int sscanf (const char *__restrict __s, + const char *__restrict __format, ...) noexcept (true); + + + + + +# 1 "/usr/include/bits/floatn.h" 1 3 4 +# 119 "/usr/include/bits/floatn.h" 3 4 +# 1 "/usr/include/bits/floatn-common.h" 1 3 4 +# 24 "/usr/include/bits/floatn-common.h" 3 4 +# 1 "/usr/include/bits/long-double.h" 1 3 4 +# 25 "/usr/include/bits/floatn-common.h" 2 3 4 +# 214 "/usr/include/bits/floatn-common.h" 3 4 +typedef float _Float32; +# 251 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float64; +# 268 "/usr/include/bits/floatn-common.h" 3 4 +typedef double _Float32x; +# 285 "/usr/include/bits/floatn-common.h" 3 4 +typedef long double _Float64x; +# 120 "/usr/include/bits/floatn.h" 2 3 4 +# 436 "/usr/include/stdio.h" 2 3 4 + + + + +extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") ; + + +extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") ; + +extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf"); +# 486 "/usr/include/stdio.h" 3 4 +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, + __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 2, 0))) ; + + + + + +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) + __attribute__ ((__format__ (__scanf__, 1, 0))) ; + + +extern int vsscanf (const char *__restrict __s, + const char *__restrict __format, __gnuc_va_list __arg) + noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0))); + + + + + + +extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))) ; +extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf") + + __attribute__ ((__format__ (__scanf__, 1, 0))) ; +extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf") + + + + __attribute__ ((__format__ (__scanf__, 2, 0))); +# 571 "/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); +# 596 "/usr/include/stdio.h" 3 4 +extern int fgetc_unlocked (FILE *__stream); +# 607 "/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); +# 623 "/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) + ; +# 673 "/usr/include/stdio.h" 3 4 +extern char *fgets_unlocked (char *__restrict __s, int __n, + FILE *__restrict __stream) + ; +# 690 "/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); +# 749 "/usr/include/stdio.h" 3 4 +extern int fputs_unlocked (const char *__restrict __s, + FILE *__restrict __stream); +# 760 "/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); +# 794 "/usr/include/stdio.h" 3 4 +extern int fseeko (FILE *__stream, __off_t __off, int __whence); + + + + +extern __off_t ftello (FILE *__stream) ; +# 818 "/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); +# 837 "/usr/include/stdio.h" 3 4 +extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); +extern __off64_t ftello64 (FILE *__stream) ; +extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); +extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); + + + +extern void clearerr (FILE *__stream) noexcept (true); + +extern int feof (FILE *__stream) noexcept (true) ; + +extern int ferror (FILE *__stream) noexcept (true) ; + + + +extern void clearerr_unlocked (FILE *__stream) noexcept (true); +extern int feof_unlocked (FILE *__stream) noexcept (true) ; +extern int ferror_unlocked (FILE *__stream) noexcept (true) ; + + + + + + + +extern void perror (const char *__s) __attribute__ ((__cold__)); + + + + +extern int fileno (FILE *__stream) noexcept (true) ; + + + + +extern int fileno_unlocked (FILE *__stream) noexcept (true) ; +# 881 "/usr/include/stdio.h" 3 4 +extern int pclose (FILE *__stream); + + + + + +extern FILE *popen (const char *__command, const char *__modes) + __attribute__ ((__malloc__)) ; + + + + + + +extern char *ctermid (char *__s) noexcept (true) + ; + + + + + +extern char *cuserid (char *__s) + ; + + + + +struct obstack; + + +extern int obstack_printf (struct obstack *__restrict __obstack, + const char *__restrict __format, ...) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); +extern int obstack_vprintf (struct obstack *__restrict __obstack, + const char *__restrict __format, + __gnuc_va_list __args) + noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); + + + + + + + +extern void flockfile (FILE *__stream) noexcept (true); + + + +extern int ftrylockfile (FILE *__stream) noexcept (true) ; + + +extern void funlockfile (FILE *__stream) noexcept (true); +# 943 "/usr/include/stdio.h" 3 4 +extern int __uflow (FILE *); +extern int __overflow (FILE *, int); +# 960 "/usr/include/stdio.h" 3 4 +# 1 "/usr/include/bits/stdio.h" 1 3 4 +# 38 "/usr/include/bits/stdio.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) int +vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) +{ + return vfprintf (stdout, __fmt, __arg); +} + + + +extern __inline __attribute__ ((__gnu_inline__)) int +getchar (void) +{ + return getc (stdin); +} + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +fgetc_unlocked (FILE *__fp) +{ + return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +getc_unlocked (FILE *__fp) +{ + return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int +getchar_unlocked (void) +{ + return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++); +} + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +putchar (int __c) +{ + return putc (__c, stdout); +} + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +fputc_unlocked (int __c, FILE *__stream) +{ + return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int +putc_unlocked (int __c, FILE *__stream) +{ + return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int +putchar_unlocked (int __c) +{ + return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c))); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) __ssize_t +getline (char **__lineptr, size_t *__n, FILE *__stream) +{ + return __getdelim (__lineptr, __n, '\n', __stream); +} + + + + + +extern __inline __attribute__ ((__gnu_inline__)) int + feof_unlocked (FILE *__stream) noexcept (true) +{ + return (((__stream)->_flags & 0x0010) != 0); +} + + +extern __inline __attribute__ ((__gnu_inline__)) int + ferror_unlocked (FILE *__stream) noexcept (true) +{ + return (((__stream)->_flags & 0x0020) != 0); +} +# 961 "/usr/include/stdio.h" 2 3 4 + + + + + + +} +# 38 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 1 3 4 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 3 4 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 1 3 4 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 +# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + typedef long unsigned int size_t; + typedef long int ptrdiff_t; + + + typedef decltype(nullptr) nullptr_t; + + +#pragma GCC visibility push(default) + + + extern "C++" __attribute__ ((__noreturn__, __always_inline__)) + inline void __terminate() noexcept + { + void terminate() noexcept __attribute__ ((__noreturn__)); + terminate(); + } +#pragma GCC visibility pop +} +# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +namespace __gnu_cxx +{ + inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } +} +# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +namespace std +{ +#pragma GCC visibility push(default) + + + + + constexpr inline bool + __is_constant_evaluated() noexcept + { + + + + + + return __builtin_is_constant_evaluated(); + + + + } +#pragma GCC visibility pop +} +# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 +# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 +# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 +# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 +# 1 "/usr/include/stdlib.h" 1 3 4 +# 26 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdlib.h" 2 3 4 + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 33 "/usr/include/stdlib.h" 2 3 4 + +extern "C" { + + + + + +# 1 "/usr/include/bits/waitflags.h" 1 3 4 +# 41 "/usr/include/stdlib.h" 2 3 4 +# 1 "/usr/include/bits/waitstatus.h" 1 3 4 +# 42 "/usr/include/stdlib.h" 2 3 4 +# 59 "/usr/include/stdlib.h" 3 4 +typedef struct + { + int quot; + int rem; + } div_t; + + + +typedef struct + { + long int quot; + long int rem; + } ldiv_t; + + + + + +__extension__ typedef struct + { + long long int quot; + long long int rem; + } lldiv_t; +# 98 "/usr/include/stdlib.h" 3 4 +extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; + + + +extern double atof (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern int atoi (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + +extern long int atol (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +__extension__ extern long long int atoll (const char *__nptr) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; + + + +extern double strtod (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern float strtof (const char *__restrict __nptr, + char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern long double strtold (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 141 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64 strtof64 (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 159 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern _Float64x strtof64x (const char *__restrict __nptr, + char **__restrict __endptr) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 177 "/usr/include/stdlib.h" 3 4 +extern long int strtol (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +extern unsigned long int strtoul (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, + char **__restrict __endptr, int __base) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") + + + __attribute__ ((__nonnull__ (1))); +extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); + +__extension__ +extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") + + + __attribute__ ((__nonnull__ (1))); +__extension__ +extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") + + + + __attribute__ ((__nonnull__ (1))); +# 278 "/usr/include/stdlib.h" 3 4 +extern int strfromd (char *__dest, size_t __size, const char *__format, + double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfromf (char *__dest, size_t __size, const char *__format, + float __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + +extern int strfroml (char *__dest, size_t __size, const char *__format, + long double __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 298 "/usr/include/stdlib.h" 3 4 +extern int strfromf32 (char *__dest, size_t __size, const char * __format, + _Float32 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64 (char *__dest, size_t __size, const char * __format, + _Float64 __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 316 "/usr/include/stdlib.h" 3 4 +extern int strfromf32x (char *__dest, size_t __size, const char * __format, + _Float32x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); + + + +extern int strfromf64x (char *__dest, size_t __size, const char * __format, + _Float64x __f) + noexcept (true) __attribute__ ((__nonnull__ (3))); +# 338 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 +# 22 "/usr/include/bits/types/locale_t.h" 3 4 +# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 +# 27 "/usr/include/bits/types/__locale_t.h" 3 4 +struct __locale_struct +{ + + struct __locale_data *__locales[13]; + + + const unsigned short int *__ctype_b; + const int *__ctype_tolower; + const int *__ctype_toupper; + + + const char *__names[13]; +}; + +typedef struct __locale_struct *__locale_t; +# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 + +typedef __locale_t locale_t; +# 339 "/usr/include/stdlib.h" 2 3 4 + +extern long int strtol_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +extern unsigned long int strtoul_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, + char **__restrict __endptr, int __base, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, + char **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 4))); + + + + + +extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") + + + + __attribute__ ((__nonnull__ (1, 4))); +extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +__extension__ +extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") + + + + + __attribute__ ((__nonnull__ (1, 4))); +# 415 "/usr/include/stdlib.h" 3 4 +extern double strtod_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern float strtof_l (const char *__restrict __nptr, + char **__restrict __endptr, locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + +extern long double strtold_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 436 "/usr/include/stdlib.h" 3 4 +extern _Float32 strtof32_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64 strtof64_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 457 "/usr/include/stdlib.h" 3 4 +extern _Float32x strtof32x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); + + + +extern _Float64x strtof64x_l (const char *__restrict __nptr, + char **__restrict __endptr, + locale_t __loc) + noexcept (true) __attribute__ ((__nonnull__ (1, 3))); +# 480 "/usr/include/stdlib.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) int + atoi (const char *__nptr) noexcept (true) +{ + return (int) strtol (__nptr, (char **) __null, 10); +} +extern __inline __attribute__ ((__gnu_inline__)) long int + atol (const char *__nptr) noexcept (true) +{ + return strtol (__nptr, (char **) __null, 10); +} + + +__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int + atoll (const char *__nptr) noexcept (true) +{ + return strtoll (__nptr, (char **) __null, 10); +} +# 505 "/usr/include/stdlib.h" 3 4 +extern char *l64a (long int __n) noexcept (true) ; + + +extern long int a64l (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; +# 521 "/usr/include/stdlib.h" 3 4 +extern long int random (void) noexcept (true); + + +extern void srandom (unsigned int __seed) noexcept (true); + + + + + +extern char *initstate (unsigned int __seed, char *__statebuf, + size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + + +struct random_data + { + int32_t *fptr; + int32_t *rptr; + int32_t *state; + int rand_type; + int rand_deg; + int rand_sep; + int32_t *end_ptr; + }; + +extern int random_r (struct random_data *__restrict __buf, + int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int srandom_r (unsigned int __seed, struct random_data *__buf) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, + size_t __statelen, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (2, 4))); + +extern int setstate_r (char *__restrict __statebuf, + struct random_data *__restrict __buf) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern int rand (void) noexcept (true); + +extern void srand (unsigned int __seed) noexcept (true); + + + +extern int rand_r (unsigned int *__seed) noexcept (true); + + + + + + + +extern double drand48 (void) noexcept (true); +extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int lrand48 (void) noexcept (true); +extern long int nrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern long int mrand48 (void) noexcept (true); +extern long int jrand48 (unsigned short int __xsubi[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void srand48 (long int __seedval) noexcept (true); +extern unsigned short int *seed48 (unsigned short int __seed16v[3]) + noexcept (true) __attribute__ ((__nonnull__ (1))); +extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +struct drand48_data + { + unsigned short int __x[3]; + unsigned short int __old_x[3]; + unsigned short int __c; + unsigned short int __init; + __extension__ unsigned long long int __a; + + }; + + +extern int drand48_r (struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int erand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int lrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int nrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int mrand48_r (struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern int jrand48_r (unsigned short int __xsubi[3], + struct drand48_data *__restrict __buffer, + long int *__restrict __result) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int srand48_r (long int __seedval, struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (2))); + +extern int seed48_r (unsigned short int __seed16v[3], + struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern int lcong48_r (unsigned short int __param[7], + struct drand48_data *__buffer) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern __uint32_t arc4random (void) + noexcept (true) ; + + +extern void arc4random_buf (void *__buf, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + +extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) + noexcept (true) ; + + + + +extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + ; + +extern void *calloc (size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) ; + + + + + + +extern void *realloc (void *__ptr, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) ; + + +extern void free (void *__ptr) noexcept (true); + + + + + + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) __attribute__ ((__warn_unused_result__)) + + ; + + +extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) + noexcept (true) ; + + + +# 1 "/usr/include/alloca.h" 1 3 4 +# 24 "/usr/include/alloca.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 25 "/usr/include/alloca.h" 2 3 4 + +extern "C" { + + + + + +extern void *alloca (size_t __size) noexcept (true); + + + + + +} +# 707 "/usr/include/stdlib.h" 2 3 4 + + + + + +extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) + ; + + + + +extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern void *aligned_alloc (size_t __alignment, size_t __size) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) + ; + + + +extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)); + + + +extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + +extern "C++" int at_quick_exit (void (*__func) (void)) + noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); +# 749 "/usr/include/stdlib.h" 3 4 +extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) + noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + + +extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); + + + + +extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + +extern char *secure_getenv (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) ; + + + + + + +extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + +extern int setenv (const char *__name, const char *__value, int __replace) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + +extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int clearenv (void) noexcept (true); +# 814 "/usr/include/stdlib.h" 3 4 +extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 827 "/usr/include/stdlib.h" 3 4 +extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 837 "/usr/include/stdlib.h" 3 4 +extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; +# 849 "/usr/include/stdlib.h" 3 4 +extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; +# 859 "/usr/include/stdlib.h" 3 4 +extern int mkstemps64 (char *__template, int __suffixlen) + __attribute__ ((__nonnull__ (1))) ; +# 870 "/usr/include/stdlib.h" 3 4 +extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 881 "/usr/include/stdlib.h" 3 4 +extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 891 "/usr/include/stdlib.h" 3 4 +extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; +# 901 "/usr/include/stdlib.h" 3 4 +extern int mkostemps (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 913 "/usr/include/stdlib.h" 3 4 +extern int mkostemps64 (char *__template, int __suffixlen, int __flags) + __attribute__ ((__nonnull__ (1))) ; +# 923 "/usr/include/stdlib.h" 3 4 +extern int system (const char *__command) ; + + + + + +extern char *canonicalize_file_name (const char *__name) + noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) + ; +# 940 "/usr/include/stdlib.h" 3 4 +extern char *realpath (const char *__restrict __name, + char *__restrict __resolved) noexcept (true) ; + + + + + + +typedef int (*__compar_fn_t) (const void *, const void *); + + +typedef __compar_fn_t comparison_fn_t; + + + +typedef int (*__compar_d_fn_t) (const void *, const void *, void *); + + + + +extern void *bsearch (const void *__key, const void *__base, + size_t __nmemb, size_t __size, __compar_fn_t __compar) + __attribute__ ((__nonnull__ (1, 2, 5))) ; + + +# 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4 +# 19 "/usr/include/bits/stdlib-bsearch.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) void * +bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) +{ + size_t __l, __u, __idx; + const void *__p; + int __comparison; + + __l = 0; + __u = __nmemb; + while (__l < __u) + { + __idx = (__l + __u) / 2; + __p = (const void *) (((const char *) __base) + (__idx * __size)); + __comparison = (*__compar) (__key, __p); + if (__comparison < 0) + __u = __idx; + else if (__comparison > 0) + __l = __idx + 1; + else + { + + + + + return (void *) __p; + + + + } + } + + return __null; +} +# 966 "/usr/include/stdlib.h" 2 3 4 + + + + +extern void qsort (void *__base, size_t __nmemb, size_t __size, + __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); + +extern void qsort_r (void *__base, size_t __nmemb, size_t __size, + __compar_d_fn_t __compar, void *__arg) + __attribute__ ((__nonnull__ (1, 4))); + + + + +extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; +extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern long long int llabs (long long int __x) + noexcept (true) __attribute__ ((__const__)) ; + + + + + + +extern div_t div (int __numer, int __denom) + noexcept (true) __attribute__ ((__const__)) ; +extern ldiv_t ldiv (long int __numer, long int __denom) + noexcept (true) __attribute__ ((__const__)) ; + + +__extension__ extern lldiv_t lldiv (long long int __numer, + long long int __denom) + noexcept (true) __attribute__ ((__const__)) ; +# 1012 "/usr/include/stdlib.h" 3 4 +extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; + + + + +extern char *gcvt (double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern char *qecvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qfcvt (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign) + noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; +extern char *qgcvt (long double __value, int __ndigit, char *__buf) + noexcept (true) __attribute__ ((__nonnull__ (3))) ; + + + + +extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, + int *__restrict __sign, char *__restrict __buf, + size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + +extern int qecvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); +extern int qfcvt_r (long double __value, int __ndigit, + int *__restrict __decpt, int *__restrict __sign, + char *__restrict __buf, size_t __len) + noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); + + + + + +extern int mblen (const char *__s, size_t __n) noexcept (true); + + +extern int mbtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n) noexcept (true); + + +extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); + + + +extern size_t mbstowcs (wchar_t *__restrict __pwcs, + const char *__restrict __s, size_t __n) noexcept (true) + ; + +extern size_t wcstombs (char *__restrict __s, + const wchar_t *__restrict __pwcs, size_t __n) + noexcept (true) + + ; + + + + + + +extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; +# 1099 "/usr/include/stdlib.h" 3 4 +extern int getsubopt (char **__restrict __optionp, + char *const *__restrict __tokens, + char **__restrict __valuep) + noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; + + + + + + + +extern int posix_openpt (int __oflag) ; + + + + + + + +extern int grantpt (int __fd) noexcept (true); + + + +extern int unlockpt (int __fd) noexcept (true); + + + + +extern char *ptsname (int __fd) noexcept (true) ; + + + + + + +extern int ptsname_r (int __fd, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) ; + + +extern int getpt (void); + + + + + + +extern int getloadavg (double __loadavg[], int __nelem) + noexcept (true) __attribute__ ((__nonnull__ (1))); +# 1155 "/usr/include/stdlib.h" 3 4 +# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 +# 24 "/usr/include/bits/stdlib-float.h" 3 4 +extern __inline __attribute__ ((__gnu_inline__)) double + atof (const char *__nptr) noexcept (true) +{ + return strtod (__nptr, (char **) __null); +} +# 1156 "/usr/include/stdlib.h" 2 3 4 +# 1167 "/usr/include/stdlib.h" 3 4 +} +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::abs; + + + inline long + abs(long __i) { return __builtin_labs(__i); } + + + + inline long long + abs(long long __x) { return __builtin_llabs (__x); } +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 + inline constexpr double + abs(double __x) + { return __builtin_fabs(__x); } + + inline constexpr float + abs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + abs(long double __x) + { return __builtin_fabsl(__x); } +# 151 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 +} +} +# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::div_t; + using ::ldiv_t; + + using ::abort; + + using ::aligned_alloc; + + using ::atexit; + + + using ::at_quick_exit; + + + using ::atof; + using ::atoi; + using ::atol; + using ::bsearch; + using ::calloc; + using ::div; + using ::exit; + using ::free; + using ::getenv; + using ::labs; + using ::ldiv; + using ::malloc; + + using ::mblen; + using ::mbstowcs; + using ::mbtowc; + + using ::qsort; + + + using ::quick_exit; + + + using ::rand; + using ::realloc; + using ::srand; + using ::strtod; + using ::strtol; + using ::strtoul; + using ::system; + + using ::wcstombs; + using ::wctomb; + + + + inline ldiv_t + div(long __i, long __j) noexcept { return ldiv(__i, __j); } + + + + +} +# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +# 231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 2 3 4 + +using std::abort; +using std::atexit; +using std::exit; + + + using std::at_quick_exit; + + + using std::quick_exit; + + + using std::_Exit; + + + + +using std::div_t; +using std::ldiv_t; + +using std::abs; +using std::atof; +using std::atoi; +using std::atol; +using std::bsearch; +using std::calloc; +using std::div; +using std::free; +using std::getenv; +using std::labs; +using std::ldiv; +using std::malloc; + +using std::mblen; +using std::mbstowcs; +using std::mbtowc; + +using std::qsort; +using std::rand; +using std::realloc; +using std::srand; +using std::strtod; +using std::strtol; +using std::strtoul; +using std::system; + +using std::wcstombs; +using std::wctomb; +# 41 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 35 "/usr/lib/clang/16/include/stddef.h" 3 4 +typedef long int ptrdiff_t; +# 109 "/usr/lib/clang/16/include/stddef.h" 3 4 +# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 4 +# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 4 +typedef struct { + long long __clang_max_align_nonce1 + __attribute__((__aligned__(__alignof__(long long)))); + long double __clang_max_align_nonce2 + __attribute__((__aligned__(__alignof__(long double)))); +} max_align_t; +# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 4 +# 42 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 +# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 +# 22 "/usr/lib/clang/16/include/stdarg.h" 3 4 +typedef __builtin_va_list va_list; +# 43 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 +# 60 "/usr/include/SDL2/SDL_stdinc.h" 3 4 +# 1 "/usr/include/string.h" 1 3 4 +# 26 "/usr/include/string.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/string.h" 2 3 4 + +extern "C" { + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 34 "/usr/include/string.h" 2 3 4 +# 43 "/usr/include/string.h" 3 4 +extern void *memcpy (void *__restrict __dest, const void *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void *memmove (void *__dest, const void *__src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + + +extern void *memccpy (void *__restrict __dest, const void *__restrict __src, + int __c, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + + +extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern int memcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 80 "/usr/include/string.h" 3 4 +extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern "C++" +{ +extern void *memchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const void *memchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void * +memchr (void *__s, int __c, size_t __n) noexcept (true) +{ + return __builtin_memchr (__s, __c, __n); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void * +memchr (const void *__s, int __c, size_t __n) noexcept (true) +{ + return __builtin_memchr (__s, __c, __n); +} + +} +# 115 "/usr/include/string.h" 3 4 +extern "C++" void *rawmemchr (void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const void *rawmemchr (const void *__s, int __c) + noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + + +extern "C++" void *memrchr (void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + ; +extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) + noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) + ; +# 141 "/usr/include/string.h" 3 4 +extern char *strcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strcat (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern char *strncat (char *__restrict __dest, const char *__restrict __src, + size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int strncmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strcoll (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern size_t strxfrm (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (2))) ; + + + + + + +extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + +extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, + locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) + ; + + + + + +extern char *strdup (const char *__s) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern char *strndup (const char *__string, size_t __n) + noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); +# 224 "/usr/include/string.h" 3 4 +extern "C++" +{ +extern char *strchr (char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strchr (const char *__s, int __c) + noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * +strchr (char *__s, int __c) noexcept (true) +{ + return __builtin_strchr (__s, __c); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * +strchr (const char *__s, int __c) noexcept (true) +{ + return __builtin_strchr (__s, __c); +} + +} + + + + + + +extern "C++" +{ +extern char *strrchr (char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern const char *strrchr (const char *__s, int __c) + noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * +strrchr (char *__s, int __c) noexcept (true) +{ + return __builtin_strrchr (__s, __c); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * +strrchr (const char *__s, int __c) noexcept (true) +{ + return __builtin_strrchr (__s, __c); +} + +} +# 281 "/usr/include/string.h" 3 4 +extern "C++" char *strchrnul (char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +extern "C++" const char *strchrnul (const char *__s, int __c) + noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 293 "/usr/include/string.h" 3 4 +extern size_t strcspn (const char *__s, const char *__reject) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern size_t strspn (const char *__s, const char *__accept) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern "C++" +{ +extern char *strpbrk (char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strpbrk (const char *__s, const char *__accept) + noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * +strpbrk (char *__s, const char *__accept) noexcept (true) +{ + return __builtin_strpbrk (__s, __accept); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * +strpbrk (const char *__s, const char *__accept) noexcept (true) +{ + return __builtin_strpbrk (__s, __accept); +} + +} + + + + + + +extern "C++" +{ +extern char *strstr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern const char *strstr (const char *__haystack, const char *__needle) + noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * +strstr (char *__haystack, const char *__needle) noexcept (true) +{ + return __builtin_strstr (__haystack, __needle); +} + +extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * +strstr (const char *__haystack, const char *__needle) noexcept (true) +{ + return __builtin_strstr (__haystack, __needle); +} + +} + + + + + + + +extern char *strtok (char *__restrict __s, const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (2))); + + + +extern char *__strtok_r (char *__restrict __s, + const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + +extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, + char **__restrict __save_ptr) + noexcept (true) __attribute__ ((__nonnull__ (2, 3))); + + + + + +extern "C++" char *strcasestr (char *__haystack, const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +extern "C++" const char *strcasestr (const char *__haystack, + const char *__needle) + noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); +# 389 "/usr/include/string.h" 3 4 +extern void *memmem (const void *__haystack, size_t __haystacklen, + const void *__needle, size_t __needlelen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) + + ; + + + +extern void *__mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern void *mempcpy (void *__restrict __dest, + const void *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlen (const char *__s) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern size_t strnlen (const char *__string, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + +extern char *strerror (int __errnum) noexcept (true); +# 444 "/usr/include/string.h" 3 4 +extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) + noexcept (true) __attribute__ ((__nonnull__ (2))) ; + + + + +extern const char *strerrordesc_np (int __err) noexcept (true); + +extern const char *strerrorname_np (int __err) noexcept (true); + + + + + +extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); + + + +# 1 "/usr/include/strings.h" 1 3 4 +# 23 "/usr/include/strings.h" 3 4 +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 24 "/usr/include/strings.h" 2 3 4 + + + + + + +extern "C" { + + + +extern int bcmp (const void *__s1, const void *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bcopy (const void *__src, void *__dest, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); +# 68 "/usr/include/strings.h" 3 4 +extern char *index (const char *__s, int __c) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); +# 96 "/usr/include/strings.h" 3 4 +extern char *rindex (const char *__s, int __c) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); + + + + + + +extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); + + + + + +extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); +__extension__ extern int ffsll (long long int __ll) + noexcept (true) __attribute__ ((__const__)); + + + +extern int strcasecmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + + + + +extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); + + + +extern int strncasecmp_l (const char *__s1, const char *__s2, + size_t __n, locale_t __loc) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); + + +} +# 463 "/usr/include/string.h" 2 3 4 + + + +extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + ; + + + +extern char *strsep (char **__restrict __stringp, + const char *__restrict __delim) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern char *strsignal (int __sig) noexcept (true); + + + +extern const char *sigabbrev_np (int __sig) noexcept (true); + + +extern const char *sigdescr_np (int __sig) noexcept (true); + + + +extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern char *__stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); +extern char *stpncpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + + +extern size_t strlcpy (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern size_t strlcat (char *__restrict __dest, + const char *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + + +extern int strverscmp (const char *__s1, const char *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + +extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); + + +extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) + ; + + + + + + + +extern "C++" char *basename (char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +extern "C++" const char *basename (const char *__filename) + noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); +# 552 "/usr/include/string.h" 3 4 +} +# 61 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + + + + +# 1 "/usr/include/wchar.h" 1 3 4 +# 27 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/wchar.h" 2 3 4 + + + + + + + +# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 +# 36 "/usr/include/wchar.h" 2 3 4 +# 51 "/usr/include/wchar.h" 3 4 +# 1 "/usr/include/bits/wchar.h" 1 3 4 +# 52 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 +# 20 "/usr/include/bits/types/wint_t.h" 3 4 +typedef unsigned int wint_t; +# 53 "/usr/include/wchar.h" 2 3 4 +# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 + + + + + +typedef __mbstate_t mbstate_t; +# 54 "/usr/include/wchar.h" 2 3 4 +# 90 "/usr/include/wchar.h" 3 4 +extern "C" { + + + +struct tm; + + + +extern wchar_t *wcscpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern wchar_t *wcsncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + + +extern size_t wcslcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern size_t wcslcat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; + + + +extern wchar_t *wcscat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + +extern wchar_t *wcsncat (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true) __attribute__ ((__nonnull__ (1, 2))); + + +extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + +extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); + + + +extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + +extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, + size_t __n) noexcept (true); + + + +extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + +extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + + + +extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); + + + +extern size_t wcsxfrm (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + + + + + +extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, + locale_t __loc) noexcept (true); + + + + +extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, + size_t __n, locale_t __loc) noexcept (true); + + +extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) + __attribute__ ((__malloc__)) ; +# 189 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); +# 199 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) + noexcept (true) __attribute__ ((__pure__)); + + + + +extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) + noexcept (true) __attribute__ ((__pure__)); + + +extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 226 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) + noexcept (true) __attribute__ ((__pure__)); +# 237 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + +extern wchar_t *wcstok (wchar_t *__restrict __s, + const wchar_t *__restrict __delim, + wchar_t **__restrict __ptr) noexcept (true); + + +extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); +# 258 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) + noexcept (true) __attribute__ ((__pure__)); + + + + + +extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) + noexcept (true) __attribute__ ((__pure__)); +# 278 "/usr/include/wchar.h" 3 4 +extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + + +extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true) __attribute__ ((__pure__)); + + +extern wchar_t *wmemcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) noexcept (true); + + + +extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) + noexcept (true); + + +extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); + + + + +extern wchar_t *wmempcpy (wchar_t *__restrict __s1, + const wchar_t *__restrict __s2, size_t __n) + noexcept (true); + + + + + +extern wint_t btowc (int __c) noexcept (true); + + + +extern int wctob (wint_t __c) noexcept (true); + + + +extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); + + + +extern size_t mbrtowc (wchar_t *__restrict __pwc, + const char *__restrict __s, size_t __n, + mbstate_t *__restrict __p) noexcept (true); + + +extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, + mbstate_t *__restrict __ps) noexcept (true); + + +extern size_t __mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); +extern size_t mbrlen (const char *__restrict __s, size_t __n, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + + +extern wint_t __btowc_alias (int __c) __asm ("btowc"); +extern __inline __attribute__ ((__gnu_inline__)) wint_t + btowc (int __c) noexcept (true) +{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' + ? (wint_t) __c : __btowc_alias (__c)); } + +extern int __wctob_alias (wint_t __c) __asm ("wctob"); +extern __inline __attribute__ ((__gnu_inline__)) int + wctob (wint_t __wc) noexcept (true) +{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' + ? (int) __wc : __wctob_alias (__wc)); } + +extern __inline __attribute__ ((__gnu_inline__)) size_t + mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) + +{ return (__ps != __null + ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } + + + + +extern size_t mbsrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + +extern size_t mbsnrtowcs (wchar_t *__restrict __dst, + const char **__restrict __src, size_t __nmc, + size_t __len, mbstate_t *__restrict __ps) noexcept (true); + + + +extern size_t wcsnrtombs (char *__restrict __dst, + const wchar_t **__restrict __src, + size_t __nwc, size_t __len, + mbstate_t *__restrict __ps) noexcept (true); + + + + + + +extern int wcwidth (wchar_t __c) noexcept (true); + + + +extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); + + + + + +extern double wcstod (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern float wcstof (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +extern long double wcstold (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 422 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 437 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); + + + +extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr) noexcept (true); +# 455 "/usr/include/wchar.h" 3 4 +extern long int wcstol (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) noexcept (true); + + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base) noexcept (true); + + + + + + +extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); + + +extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); + + + +__extension__ +extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + + +__extension__ +extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); + + + + +__extension__ +extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); + + +__extension__ +extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); +# 561 "/usr/include/wchar.h" 3 4 +extern long int wcstol_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base, + locale_t __loc) noexcept (true); + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) noexcept (true); + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + int __base, locale_t __loc) + noexcept (true); + + + + + +extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); + + + +extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); + + + + +__extension__ +extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); + + + + +__extension__ +extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); +# 630 "/usr/include/wchar.h" 3 4 +extern double wcstod_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern float wcstof_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, locale_t __loc) + noexcept (true); + +extern long double wcstold_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 649 "/usr/include/wchar.h" 3 4 +extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 667 "/usr/include/wchar.h" 3 4 +extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); + + + +extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, + locale_t __loc) noexcept (true); +# 689 "/usr/include/wchar.h" 3 4 +extern wchar_t *wcpcpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src) noexcept (true); + + + +extern wchar_t *wcpncpy (wchar_t *__restrict __dest, + const wchar_t *__restrict __src, size_t __n) + noexcept (true); +# 718 "/usr/include/wchar.h" 3 4 +extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) + __attribute__ ((__malloc__)) ; + + + + + +extern int fwide (__FILE *__fp, int __mode) noexcept (true); + + + + + + +extern int fwprintf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wprintf (const wchar_t *__restrict __format, ...) + ; + +extern int swprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, ...) + noexcept (true) ; + + + + + +extern int vfwprintf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwprintf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + +extern int vswprintf (wchar_t *__restrict __s, size_t __n, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; + + + + + + +extern int fwscanf (__FILE *__restrict __stream, + const wchar_t *__restrict __format, ...) + ; + + + + +extern int wscanf (const wchar_t *__restrict __format, ...) + ; + +extern int swscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, ...) + noexcept (true) ; +# 795 "/usr/include/wchar.h" 3 4 +extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") + + + ; +extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") + + ; +extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") + + + ; +# 851 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + + + + +extern int vwscanf (const wchar_t *__restrict __format, + __gnuc_va_list __arg) + ; + +extern int vswscanf (const wchar_t *__restrict __s, + const wchar_t *__restrict __format, + __gnuc_va_list __arg) + noexcept (true) ; +# 875 "/usr/include/wchar.h" 3 4 +extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") + + + ; +extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") + + ; +extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") + + + ; +# 935 "/usr/include/wchar.h" 3 4 +extern wint_t fgetwc (__FILE *__stream); +extern wint_t getwc (__FILE *__stream); + + + + + +extern wint_t getwchar (void); + + + + + + +extern wint_t fputwc (wchar_t __wc, __FILE *__stream); +extern wint_t putwc (wchar_t __wc, __FILE *__stream); + + + + + +extern wint_t putwchar (wchar_t __wc); + + + + + + + +extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + +extern int fputws (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern wint_t ungetwc (wint_t __wc, __FILE *__stream); +# 990 "/usr/include/wchar.h" 3 4 +extern wint_t getwc_unlocked (__FILE *__stream); +extern wint_t getwchar_unlocked (void); + + + + + + + +extern wint_t fgetwc_unlocked (__FILE *__stream); + + + + + + + +extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); +# 1016 "/usr/include/wchar.h" 3 4 +extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); +extern wint_t putwchar_unlocked (wchar_t __wc); +# 1026 "/usr/include/wchar.h" 3 4 +extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, + __FILE *__restrict __stream); + + + + + + + +extern int fputws_unlocked (const wchar_t *__restrict __ws, + __FILE *__restrict __stream); + + + + + + +extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp) noexcept (true); + + + + +extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, + const wchar_t *__restrict __format, + const struct tm *__restrict __tp, + locale_t __loc) noexcept (true); +# 1073 "/usr/include/wchar.h" 3 4 +} +# 67 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + +# 1 "/usr/lib/clang/16/include/inttypes.h" 1 3 4 +# 21 "/usr/lib/clang/16/include/inttypes.h" 3 4 +# 1 "/usr/include/inttypes.h" 1 3 4 +# 27 "/usr/include/inttypes.h" 3 4 +# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 4 +# 52 "/usr/lib/clang/16/include/stdint.h" 3 4 +# 1 "/usr/include/stdint.h" 1 3 4 +# 26 "/usr/include/stdint.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 27 "/usr/include/stdint.h" 2 3 4 + + +# 1 "/usr/include/bits/wordsize.h" 1 3 4 +# 30 "/usr/include/stdint.h" 2 3 4 + + + + + + + +# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 +# 24 "/usr/include/bits/stdint-uintn.h" 3 4 +typedef __uint8_t uint8_t; +typedef __uint16_t uint16_t; +typedef __uint32_t uint32_t; +typedef __uint64_t uint64_t; +# 38 "/usr/include/stdint.h" 2 3 4 + + + + + +typedef __int_least8_t int_least8_t; +typedef __int_least16_t int_least16_t; +typedef __int_least32_t int_least32_t; +typedef __int_least64_t int_least64_t; + + +typedef __uint_least8_t uint_least8_t; +typedef __uint_least16_t uint_least16_t; +typedef __uint_least32_t uint_least32_t; +typedef __uint_least64_t uint_least64_t; + + + + + +typedef signed char int_fast8_t; + +typedef long int int_fast16_t; +typedef long int int_fast32_t; +typedef long int int_fast64_t; +# 71 "/usr/include/stdint.h" 3 4 +typedef unsigned char uint_fast8_t; + +typedef unsigned long int uint_fast16_t; +typedef unsigned long int uint_fast32_t; +typedef unsigned long int uint_fast64_t; +# 87 "/usr/include/stdint.h" 3 4 +typedef long int intptr_t; + + +typedef unsigned long int uintptr_t; +# 101 "/usr/include/stdint.h" 3 4 +typedef __intmax_t intmax_t; +typedef __uintmax_t uintmax_t; +# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 4 +# 28 "/usr/include/inttypes.h" 2 3 4 +# 327 "/usr/include/inttypes.h" 3 4 +extern "C" { + + + + +typedef struct + { + long int quot; + long int rem; + } imaxdiv_t; +# 351 "/usr/include/inttypes.h" 3 4 +extern intmax_t imaxabs (intmax_t __n) noexcept (true) __attribute__ ((__const__)); + + +extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom) + noexcept (true) __attribute__ ((__const__)); + + +extern intmax_t strtoimax (const char *__restrict __nptr, + char **__restrict __endptr, int __base) noexcept (true); + + +extern uintmax_t strtoumax (const char *__restrict __nptr, + char ** __restrict __endptr, int __base) noexcept (true); + + +extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, + wchar_t **__restrict __endptr, int __base) + noexcept (true); + + +extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, + wchar_t ** __restrict __endptr, int __base) + noexcept (true); + + + + + +extern intmax_t strtoimax (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoimax"); + + +extern uintmax_t strtoumax (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoumax"); + + +extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoimax"); + + + +extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoumax"); +# 415 "/usr/include/inttypes.h" 3 4 +} +# 22 "/usr/lib/clang/16/include/inttypes.h" 2 3 4 +# 70 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 + + + + +# 1 "/usr/include/ctype.h" 1 3 4 +# 28 "/usr/include/ctype.h" 3 4 +extern "C" { +# 46 "/usr/include/ctype.h" 3 4 +enum +{ + _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), + _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), + _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), + _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), + _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), + _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), + _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), + _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), + _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), + _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), + _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), + _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) +}; +# 79 "/usr/include/ctype.h" 3 4 +extern const unsigned short int **__ctype_b_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_tolower_loc (void) + noexcept (true) __attribute__ ((__const__)); +extern const __int32_t **__ctype_toupper_loc (void) + noexcept (true) __attribute__ ((__const__)); +# 108 "/usr/include/ctype.h" 3 4 +extern int isalnum (int) noexcept (true); +extern int isalpha (int) noexcept (true); +extern int iscntrl (int) noexcept (true); +extern int isdigit (int) noexcept (true); +extern int islower (int) noexcept (true); +extern int isgraph (int) noexcept (true); +extern int isprint (int) noexcept (true); +extern int ispunct (int) noexcept (true); +extern int isspace (int) noexcept (true); +extern int isupper (int) noexcept (true); +extern int isxdigit (int) noexcept (true); + + + +extern int tolower (int __c) noexcept (true); + + +extern int toupper (int __c) noexcept (true); + + + + +extern int isblank (int) noexcept (true); + + + + +extern int isctype (int __c, int __mask) noexcept (true); + + + + + + +extern int isascii (int __c) noexcept (true); + + + +extern int toascii (int __c) noexcept (true); + + + +extern int _toupper (int) noexcept (true); +extern int _tolower (int) noexcept (true); +# 251 "/usr/include/ctype.h" 3 4 +extern int isalnum_l (int, locale_t) noexcept (true); +extern int isalpha_l (int, locale_t) noexcept (true); +extern int iscntrl_l (int, locale_t) noexcept (true); +extern int isdigit_l (int, locale_t) noexcept (true); +extern int islower_l (int, locale_t) noexcept (true); +extern int isgraph_l (int, locale_t) noexcept (true); +extern int isprint_l (int, locale_t) noexcept (true); +extern int ispunct_l (int, locale_t) noexcept (true); +extern int isspace_l (int, locale_t) noexcept (true); +extern int isupper_l (int, locale_t) noexcept (true); +extern int isxdigit_l (int, locale_t) noexcept (true); + +extern int isblank_l (int, locale_t) noexcept (true); + + + +extern int __tolower_l (int __c, locale_t __l) noexcept (true); +extern int tolower_l (int __c, locale_t __l) noexcept (true); + + +extern int __toupper_l (int __c, locale_t __l) noexcept (true); +extern int toupper_l (int __c, locale_t __l) noexcept (true); +# 327 "/usr/include/ctype.h" 3 4 +} +# 75 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 +# 86 "/usr/include/SDL2/SDL_stdinc.h" 3 4 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/math.h" 1 3 4 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/math.h" 3 4 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 1 3 4 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 +# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 +# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 +extern "C++" { + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + struct __true_type { }; + struct __false_type { }; + + template + struct __truth_type + { typedef __false_type __type; }; + + template<> + struct __truth_type + { typedef __true_type __type; }; + + + + template + struct __traitor + { + enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; + typedef typename __truth_type<__value>::__type __type; + }; + + + template + struct __are_same + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __are_same<_Tp, _Tp> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_void + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_void + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_integer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_integer + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; + }; +# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template + struct __is_pointer + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template + struct __is_pointer<_Tp*> + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + + + template + struct __is_arithmetic + : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > + { }; + + + + + template + struct __is_scalar + : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > + { }; + + + + + template + struct __is_char + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template<> + struct __is_char + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + template + struct __is_byte + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + + enum class byte : unsigned char; + + template<> + struct __is_byte + { + enum { __value = 1 }; + typedef __true_type __type; + }; +# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template struct iterator_traits; + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = __is_trivially_copyable(_Tp) }; + }; + + + + + template + struct __is_nonvolatile_trivially_copyable + { + enum { __value = 0 }; + }; + + + template + struct __memcpyable + { + enum { __value = 0 }; + }; + + template + struct __memcpyable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcpyable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + template + struct __memcmpable + { + enum { __value = 0 }; + }; + + + template + struct __memcmpable<_Tp*, _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + template + struct __memcmpable<_Tp*, const _Tp*> + : __is_nonvolatile_trivially_copyable<_Tp> + { }; + + + + + + + + template::__value + + > + struct __is_memcmp_ordered + { + static const bool __value = _Tp(-1) > _Tp(1); + }; + + template + struct __is_memcmp_ordered<_Tp, false> + { + static const bool __value = false; + }; + + + template + struct __is_memcmp_ordered_with + { + static const bool __value = __is_memcmp_ordered<_Tp>::__value + && __is_memcmp_ordered<_Up>::__value; + }; + + template + struct __is_memcmp_ordered_with<_Tp, _Up, false> + { + static const bool __value = false; + }; +# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 + template<> + struct __is_memcmp_ordered_with + { static constexpr bool __value = true; }; + + template + struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> + { static constexpr bool __value = false; }; + + template + struct __is_memcmp_ordered_with + { static constexpr bool __value = false; }; + + + + + + template + struct __is_move_iterator + { + enum { __value = 0 }; + typedef __false_type __type; + }; + + + + template + + inline _Iterator + __miter_base(_Iterator __it) + { return __it; } + + +} +} +# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + + + + +extern "C++" { + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct __enable_if + { }; + + template + struct __enable_if + { typedef _Tp __type; }; + + + + template + struct __conditional_type + { typedef _Iftrue __type; }; + + template + struct __conditional_type + { typedef _Iffalse __type; }; + + + + template + struct __add_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned char __type; }; + + template<> + struct __add_unsigned + { typedef unsigned short __type; }; + + template<> + struct __add_unsigned + { typedef unsigned int __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long __type; }; + + template<> + struct __add_unsigned + { typedef unsigned long long __type; }; + + + template<> + struct __add_unsigned; + + template<> + struct __add_unsigned; + + + + template + struct __remove_unsigned + { + private: + typedef __enable_if::__value, _Tp> __if_type; + + public: + typedef typename __if_type::__type __type; + }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef signed char __type; }; + + template<> + struct __remove_unsigned + { typedef short __type; }; + + template<> + struct __remove_unsigned + { typedef int __type; }; + + template<> + struct __remove_unsigned + { typedef long __type; }; + + template<> + struct __remove_unsigned + { typedef long long __type; }; + + + template<> + struct __remove_unsigned; + + template<> + struct __remove_unsigned; + + + + template + constexpr + inline bool + __is_null_pointer(_Type* __ptr) + { return __ptr == 0; } + + template + constexpr + inline bool + __is_null_pointer(_Type) + { return false; } + + + constexpr bool + __is_null_pointer(std::nullptr_t) + { return true; } + + + + + template::__value> + struct __promote + { typedef double __type; }; + + + + + template + struct __promote<_Tp, false> + { }; + + template<> + struct __promote + { typedef long double __type; }; + + template<> + struct __promote + { typedef double __type; }; + + template<> + struct __promote + { typedef float __type; }; +# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 + template + using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); + + + + template + using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; + + template + using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; + + template + using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 +} +} +# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 + +# 1 "/usr/include/math.h" 1 3 4 +# 27 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 +# 28 "/usr/include/math.h" 2 3 4 + + + + + + +extern "C" { + + + + + +# 1 "/usr/include/bits/math-vector.h" 1 3 4 +# 25 "/usr/include/bits/math-vector.h" 3 4 +# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4 +# 26 "/usr/include/bits/math-vector.h" 2 3 4 +# 41 "/usr/include/math.h" 2 3 4 +# 152 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4 +# 153 "/usr/include/math.h" 2 3 4 +# 163 "/usr/include/math.h" 3 4 +typedef float float_t; +typedef double double_t; +# 204 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-logb.h" 1 3 4 +# 205 "/usr/include/math.h" 2 3 4 +# 247 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/fp-fast.h" 1 3 4 +# 248 "/usr/include/math.h" 2 3 4 + + + +enum + { + FP_INT_UPWARD = + + 0, + FP_INT_DOWNWARD = + + 1, + FP_INT_TOWARDZERO = + + 2, + FP_INT_TONEARESTFROMZERO = + + 3, + FP_INT_TONEAREST = + + 4, + }; +# 312 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassify (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbit (double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinf (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnan (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsig (double __x, double __y) noexcept (true); + + +extern int __issignaling (double __value) noexcept (true) + __attribute__ ((__const__)); +# 313 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true); + + extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true); + + extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true); + + extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true); + + + extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true); + + extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true); + + extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true); + + + + + extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true); + + extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true); + + extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true); + + + + extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true); + + + + + + extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true); + + extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true); + + extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true); + + + + + + extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true); + + +extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true); + + +extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true); + + + extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true); + + + extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true); + + +extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true); + + + + + extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true); + + + extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true); + + +extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true); + + + + + extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true); + + + extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true); + + + + + + + extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true); + + +extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true); + + + + extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true); + + + + + extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true); + + + + + + +extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); extern double __ceil (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); extern double __fabs (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); extern double __floor (double __x) noexcept (true) __attribute__ ((__const__)); + + +extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true); +# 183 "/usr/include/bits/mathcalls.h" 3 4 +extern int finite (double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); + + + +extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); + + + + + + +extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true); +# 220 "/usr/include/bits/mathcalls.h" 3 4 +extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true); +extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true); +extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true); +extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true); +extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true); +extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true); + + + + + + extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true); + extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true); +extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true); + + + + +extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true); + + + + + +extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true); + + + + + + + +extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true); + + + + + + +extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true); + + +extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true); + +extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true); + + + + +extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true); + +extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true); + + + +extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true); + + + +extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true); + + + +extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true); + + + + +extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true); + + + + +extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true); + + + +extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true); + + + +extern double round (double __x) noexcept (true) __attribute__ ((__const__)); extern double __round (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); extern double __trunc (double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true); +__extension__ +extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true); + + + +extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true); +__extension__ +extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true); + + + +extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true); + + + +extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); + + + + +extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); extern double __roundeven (double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalize (double *__cx, const double *__x) noexcept (true); + + + + + + +extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + +extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorder (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermag (const double *__x, const double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true); + + +extern int setpayload (double *__x, double __payload) noexcept (true); + + +extern int setpayloadsig (double *__x, double __payload) noexcept (true); + + + + + + + +extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true); +# 314 "/usr/include/math.h" 2 3 4 +# 329 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigf (float __x, float __y) noexcept (true); + + +extern int __issignalingf (float __value) noexcept (true) + __attribute__ ((__const__)); +# 330 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true); + + extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true); + + extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true); + + extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true); + + + extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true); + + extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true); + + extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true); + + + + + extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true); + + extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true); + + extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true); + + + + extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); + + + + + + extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true); + + extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true); + + extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true); + + + + + + extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true); + + +extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true); + + +extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true); + + + extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true); + + + extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true); + + +extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true); + + + + + extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true); + + + extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true); + + +extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true); + + + + + extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true); + + + extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true); + + + + + + + extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true); + + +extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true); + + + + extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true); + + + + + extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true); + + + + + + +extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __ceilf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__)); + + +extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); +# 177 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinff (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitef (float __value) noexcept (true) + __attribute__ ((__const__)); + + +extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); + + + +extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); + + + + + + +extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); +# 213 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanf (float __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true); +extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true); +extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true); +extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true); +extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true); +extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true); + + + + + + extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true); + extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true); +extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true); + + + + +extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true); + + + + + +extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true); + + + + + + + +extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true); + + + + + + +extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true); + + +extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true); + +extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true); + + + + +extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true); + +extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true); + + + +extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true); + + + +extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true); + + + +extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true); + + + + +extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true); + + + + +extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true); + + + +extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true); + + + +extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __truncf (float __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true); +__extension__ +extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true); + + + +extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true); +__extension__ +extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true); + + + +extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true); + + + +extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + +extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); + + + + +extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalizef (float *__cx, const float *__x) noexcept (true); + + + + + + +extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + +extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf (const float *__x, const float *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true); + + +extern int setpayloadf (float *__x, float __payload) noexcept (true); + + +extern int setpayloadsigf (float *__x, float __payload) noexcept (true); + + + + + + + +extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true); +# 331 "/usr/include/math.h" 2 3 4 +# 398 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 +# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 +extern int __fpclassifyl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __signbitl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + +extern int __isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern int __iseqsigl (long double __x, long double __y) noexcept (true); + + +extern int __issignalingl (long double __value) noexcept (true) + __attribute__ ((__const__)); +# 399 "/usr/include/math.h" 2 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true); + + extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true); + + extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true); + + extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true); + + + extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true); + + extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true); + + extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true); + + + + + extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true); + + extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true); + + extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true); + + + + extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); + + + + + + extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true); + + extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true); + + extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true); + + + + + + extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true); + + +extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true); + + +extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true); + + + extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true); + + + extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true); + + +extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true); + + + + + extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true); + + + extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true); + + +extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true); + + + + + extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true); + + + extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true); + + + + + + + extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true); + + +extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true); + + + + extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true); + + + + + extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true); + + + + + + +extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __ceill (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); +# 177 "/usr/include/bits/mathcalls.h" 3 4 +extern int isinfl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + +extern int finitel (long double __value) noexcept (true) + __attribute__ ((__const__)); + + +extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); + + + +extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); + + + + + + +extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true); +# 213 "/usr/include/bits/mathcalls.h" 3 4 +extern int isnanl (long double __value) noexcept (true) + __attribute__ ((__const__)); + + + + + +extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); +extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); +extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true); +extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true); +extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true); +extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true); + + + + + + extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true); + extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true); +extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true); + + + + +extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true); + + + + + +extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true); + + + + + + + +extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true); + + + + + + +extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true); + + +extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true); + +extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true); + + + + +extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true); + +extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true); + + + +extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true); + + + +extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true); + + + +extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true); + + + + +extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true); + + + + +extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true); + + + +extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true); + + + +extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); +__extension__ +extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true); + + + +extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true); +__extension__ +extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true); + + + +extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true); + + + +extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + +extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); + + + + +extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true); + + + + + + +extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + +extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true); + + +extern int setpayloadl (long double *__x, long double __payload) noexcept (true); + + +extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true); + + + + + + + +extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true); +# 400 "/usr/include/math.h" 2 3 4 +# 450 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); + + extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); + + + extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true); + + extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true); + + + + extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); + + + + + + extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true); + + extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true); + + extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true); + + + + + + extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true); + + +extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); + + +extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); + + + extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true); + + + extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true); + + +extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true); + + +extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true); + + + + + extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true); + + + extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true); + + + + + + + extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); + + +extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true); + + + + extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true); + + + + + + +extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); +# 198 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true); +# 220 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); +extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); +extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true); +extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true); +extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true); +extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true); + + + + + + extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true); + extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true); +extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true); + + + + +extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true); +# 252 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); + + + + + + +extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true); + + +extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + + + + +extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true); + +extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); + + + +extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true); + + + + +extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true); + + + + +extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); + + + +extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true); + + + +extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true); +__extension__ +extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true); + + + +extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); + + + +extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); + + + + +extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true); + + + + + + +extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); + + +extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true); + + +extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true); +# 451 "/usr/include/math.h" 2 3 4 +# 467 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true); + + extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); + + + extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true); + + extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true); + + + + extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); + + + + + + extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true); + + extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true); + + extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true); + + + + + + extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true); + + +extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true); + + +extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true); + + + extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true); + + + extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true); + + +extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true); + + +extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true); + + + + + extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true); + + + extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true); + + + + + + + extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true); + + + + extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true); + + + + + + +extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 198 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true); +# 220 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true); +extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true); +extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true); +extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true); +extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true); +extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true); + + + + + + extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true); + extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true); +extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true); + + + + +extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true); +# 252 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true); + + + + + + +extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true); + + +extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + + + + +extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true); + +extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true); + + + +extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true); + + + + +extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true); + + + + +extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true); + + + +extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true); + + + +extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true); +__extension__ +extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true); + + + +extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); + + + +extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + + + +extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true); + + + + + + +extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true); + + +extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true); + + +extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true); +# 468 "/usr/include/math.h" 2 3 4 +# 501 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true); + + extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); + + + extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true); + + extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true); + + + + extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); + + + + + + extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true); + + extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true); + + extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true); + + + + + + extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true); + + +extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true); + + +extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true); + + + extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true); + + + extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true); + + +extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true); + + +extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true); + + + + + extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true); + + + extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true); + + + + + + + extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true); + + + + extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true); + + + + + + +extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 198 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true); +# 220 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true); +extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true); +extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true); +extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true); +extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true); +extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true); + + + + + + extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true); + extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true); +extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true); + + + + +extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true); +# 252 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); + + + + + + +extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true); + + +extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + + + + +extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true); + +extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true); + + + +extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true); + + + + +extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true); + + + + +extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true); + + + +extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true); + + + +extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true); +__extension__ +extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true); + + + +extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); + + + +extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + + + +extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true); + + + + + + +extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true); + + +extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true); + + +extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true); +# 502 "/usr/include/math.h" 2 3 4 +# 518 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls.h" 1 3 4 +# 53 "/usr/include/bits/mathcalls.h" 3 4 + extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true); + + extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); + + + extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true); + + extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true); + + + + extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); + + + + + + extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true); + + extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true); + + extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true); + + + + + + extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true); + + +extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true); + + +extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true); + + + extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true); + + + extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true); + + +extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); + + + + extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true); + + +extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true); + + + + + extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true); + + + extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true); + + + + + + + extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true); + + + + extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true); + + + + + + +extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 198 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true); +# 220 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true); +extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true); +extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true); +extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true); +extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true); +extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true); + + + + + + extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true); + extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true); +extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true); + + + + +extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true); +# 252 "/usr/include/bits/mathcalls.h" 3 4 +extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); + + + + + + +extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true); + + +extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + + + + +extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true); + +extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true); + + + +extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true); + + + + +extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true); + + + + +extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true); + + + +extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); + + + + + + +extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true); + + + +extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true); +__extension__ +extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true); + + + +extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); + + + +extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + +extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + + + +extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); + + + +extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); + + + + +extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); + + + + + +extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); + + + +extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true); + + + + + + +extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + +extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); + + + + +extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) + + __attribute__ ((__pure__)); + + +extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true); + + +extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true); + + +extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true); +# 519 "/usr/include/math.h" 2 3 4 +# 566 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float fadd (double __x, double __y) noexcept (true); + + +extern float fdiv (double __x, double __y) noexcept (true); + + +extern float ffma (double __x, double __y, double __z) noexcept (true); + + +extern float fmul (double __x, double __y) noexcept (true); + + +extern float fsqrt (double __x) noexcept (true); + + +extern float fsub (double __x, double __y) noexcept (true); +# 567 "/usr/include/math.h" 2 3 4 +# 587 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern float faddl (long double __x, long double __y) noexcept (true); + + +extern float fdivl (long double __x, long double __y) noexcept (true); + + +extern float ffmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern float fmull (long double __x, long double __y) noexcept (true); + + +extern float fsqrtl (long double __x) noexcept (true); + + +extern float fsubl (long double __x, long double __y) noexcept (true); +# 588 "/usr/include/math.h" 2 3 4 +# 616 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern double daddl (long double __x, long double __y) noexcept (true); + + +extern double ddivl (long double __x, long double __y) noexcept (true); + + +extern double dfmal (long double __x, long double __y, long double __z) noexcept (true); + + +extern double dmull (long double __x, long double __y) noexcept (true); + + +extern double dsqrtl (long double __x) noexcept (true); + + +extern double dsubl (long double __x, long double __y) noexcept (true); +# 617 "/usr/include/math.h" 2 3 4 +# 697 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); + + +extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true); + + +extern _Float32 f32sqrtf32x (_Float32x __x) noexcept (true); + + +extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true); +# 698 "/usr/include/math.h" 2 3 4 +# 707 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32 f32sqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 708 "/usr/include/math.h" 2 3 4 +# 717 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32 f32sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 718 "/usr/include/math.h" 2 3 4 +# 747 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); + + +extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true); + + +extern _Float32x f32xsqrtf64 (_Float64 __x) noexcept (true); + + +extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true); +# 748 "/usr/include/math.h" 2 3 4 +# 757 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 758 "/usr/include/math.h" 2 3 4 +# 787 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 +# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 +extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); + + +extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true); + + +extern _Float64 f64sqrtf64x (_Float64x __x) noexcept (true); + + +extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true); +# 788 "/usr/include/math.h" 2 3 4 +# 854 "/usr/include/math.h" 3 4 +extern int signgam; +# 934 "/usr/include/math.h" 3 4 +enum + { + FP_NAN = + + 0, + FP_INFINITE = + + 1, + FP_ZERO = + + 2, + FP_SUBNORMAL = + + 3, + FP_NORMAL = + + 4 + }; +# 1055 "/usr/include/math.h" 3 4 +# 1 "/usr/include/bits/iscanonical.h" 1 3 4 +# 23 "/usr/include/bits/iscanonical.h" 3 4 +extern int __iscanonicall (long double __x) + noexcept (true) __attribute__ ((__const__)); +# 46 "/usr/include/bits/iscanonical.h" 3 4 +extern "C++" { +inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); } +inline int iscanonical (long double __val) { return __iscanonicall (__val); } + + + +} +# 1056 "/usr/include/math.h" 2 3 4 +# 1067 "/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); + +} + + + + + +} +# 1098 "/usr/include/math.h" 3 4 +extern "C++" { +# 1129 "/usr/include/math.h" 3 4 +template inline bool +iszero (__T __val) +{ + return __val == 0; +} + +} +# 1364 "/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); + + + + } +}; +# 1455 "/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); +} + +} + + + + +} +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 +# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 +extern "C++" +{ +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + using ::acos; + + + inline constexpr float + acos(float __x) + { return __builtin_acosf(__x); } + + inline constexpr long double + acos(long double __x) + { return __builtin_acosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acos(_Tp __x) + { return __builtin_acos(__x); } + + using ::asin; + + + inline constexpr float + asin(float __x) + { return __builtin_asinf(__x); } + + inline constexpr long double + asin(long double __x) + { return __builtin_asinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asin(_Tp __x) + { return __builtin_asin(__x); } + + using ::atan; + + + inline constexpr float + atan(float __x) + { return __builtin_atanf(__x); } + + inline constexpr long double + atan(long double __x) + { return __builtin_atanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atan(_Tp __x) + { return __builtin_atan(__x); } + + using ::atan2; + + + inline constexpr float + atan2(float __y, float __x) + { return __builtin_atan2f(__y, __x); } + + inline constexpr long double + atan2(long double __y, long double __x) + { return __builtin_atan2l(__y, __x); } + + + using ::ceil; + + + inline constexpr float + ceil(float __x) + { return __builtin_ceilf(__x); } + + inline constexpr long double + ceil(long double __x) + { return __builtin_ceill(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ceil(_Tp __x) + { return __builtin_ceil(__x); } + + using ::cos; + + + inline constexpr float + cos(float __x) + { return __builtin_cosf(__x); } + + inline constexpr long double + cos(long double __x) + { return __builtin_cosl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cos(_Tp __x) + { return __builtin_cos(__x); } + + using ::cosh; + + + inline constexpr float + cosh(float __x) + { return __builtin_coshf(__x); } + + inline constexpr long double + cosh(long double __x) + { return __builtin_coshl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cosh(_Tp __x) + { return __builtin_cosh(__x); } + + using ::exp; + + + inline constexpr float + exp(float __x) + { return __builtin_expf(__x); } + + inline constexpr long double + exp(long double __x) + { return __builtin_expl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp(_Tp __x) + { return __builtin_exp(__x); } + + using ::fabs; + + + inline constexpr float + fabs(float __x) + { return __builtin_fabsf(__x); } + + inline constexpr long double + fabs(long double __x) + { return __builtin_fabsl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + fabs(_Tp __x) + { return __builtin_fabs(__x); } + + using ::floor; + + + inline constexpr float + floor(float __x) + { return __builtin_floorf(__x); } + + inline constexpr long double + floor(long double __x) + { return __builtin_floorl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + floor(_Tp __x) + { return __builtin_floor(__x); } + + using ::fmod; + + + inline constexpr float + fmod(float __x, float __y) + { return __builtin_fmodf(__x, __y); } + + inline constexpr long double + fmod(long double __x, long double __y) + { return __builtin_fmodl(__x, __y); } + + + using ::frexp; + + + inline float + frexp(float __x, int* __exp) + { return __builtin_frexpf(__x, __exp); } + + inline long double + frexp(long double __x, int* __exp) + { return __builtin_frexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + frexp(_Tp __x, int* __exp) + { return __builtin_frexp(__x, __exp); } + + using ::ldexp; + + + inline constexpr float + ldexp(float __x, int __exp) + { return __builtin_ldexpf(__x, __exp); } + + inline constexpr long double + ldexp(long double __x, int __exp) + { return __builtin_ldexpl(__x, __exp); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + ldexp(_Tp __x, int __exp) + { return __builtin_ldexp(__x, __exp); } + + using ::log; + + + inline constexpr float + log(float __x) + { return __builtin_logf(__x); } + + inline constexpr long double + log(long double __x) + { return __builtin_logl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log(_Tp __x) + { return __builtin_log(__x); } + + using ::log10; + + + inline constexpr float + log10(float __x) + { return __builtin_log10f(__x); } + + inline constexpr long double + log10(long double __x) + { return __builtin_log10l(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log10(_Tp __x) + { return __builtin_log10(__x); } + + using ::modf; + + + inline float + modf(float __x, float* __iptr) + { return __builtin_modff(__x, __iptr); } + + inline long double + modf(long double __x, long double* __iptr) + { return __builtin_modfl(__x, __iptr); } + + + using ::pow; + + + inline constexpr float + pow(float __x, float __y) + { return __builtin_powf(__x, __y); } + + inline constexpr long double + pow(long double __x, long double __y) + { return __builtin_powl(__x, __y); } +# 396 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 + using ::sin; + + + inline constexpr float + sin(float __x) + { return __builtin_sinf(__x); } + + inline constexpr long double + sin(long double __x) + { return __builtin_sinl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sin(_Tp __x) + { return __builtin_sin(__x); } + + using ::sinh; + + + inline constexpr float + sinh(float __x) + { return __builtin_sinhf(__x); } + + inline constexpr long double + sinh(long double __x) + { return __builtin_sinhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sinh(_Tp __x) + { return __builtin_sinh(__x); } + + using ::sqrt; + + + inline constexpr float + sqrt(float __x) + { return __builtin_sqrtf(__x); } + + inline constexpr long double + sqrt(long double __x) + { return __builtin_sqrtl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + sqrt(_Tp __x) + { return __builtin_sqrt(__x); } + + using ::tan; + + + inline constexpr float + tan(float __x) + { return __builtin_tanf(__x); } + + inline constexpr long double + tan(long double __x) + { return __builtin_tanl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tan(_Tp __x) + { return __builtin_tan(__x); } + + using ::tanh; + + + inline constexpr float + tanh(float __x) + { return __builtin_tanhf(__x); } + + inline constexpr long double + tanh(long double __x) + { return __builtin_tanhl(__x); } + + + template + inline constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tanh(_Tp __x) + { return __builtin_tanh(__x); } +# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + atan2(_Tp __y, _Up __x) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return atan2(__type(__y), __type(__x)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmod(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmod(__type(__x), __type(__y)); + } + + template + inline constexpr + typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + pow(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return pow(__type(__x), __type(__y)); + } +# 1096 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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)); + } +# 1881 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 + using ::double_t; + using ::float_t; + + + using ::acosh; + using ::acoshf; + using ::acoshl; + + using ::asinh; + using ::asinhf; + using ::asinhl; + + using ::atanh; + using ::atanhf; + using ::atanhl; + + using ::cbrt; + using ::cbrtf; + using ::cbrtl; + + using ::copysign; + using ::copysignf; + using ::copysignl; + + using ::erf; + using ::erff; + using ::erfl; + + using ::erfc; + using ::erfcf; + using ::erfcl; + + using ::exp2; + using ::exp2f; + using ::exp2l; + + using ::expm1; + using ::expm1f; + using ::expm1l; + + using ::fdim; + using ::fdimf; + using ::fdiml; + + using ::fma; + using ::fmaf; + using ::fmal; + + using ::fmax; + using ::fmaxf; + using ::fmaxl; + + using ::fmin; + using ::fminf; + using ::fminl; + + using ::hypot; + using ::hypotf; + using ::hypotl; + + using ::ilogb; + using ::ilogbf; + using ::ilogbl; + + using ::lgamma; + using ::lgammaf; + using ::lgammal; + + + using ::llrint; + using ::llrintf; + using ::llrintl; + + using ::llround; + using ::llroundf; + using ::llroundl; + + + using ::log1p; + using ::log1pf; + using ::log1pl; + + using ::log2; + using ::log2f; + using ::log2l; + + using ::logb; + using ::logbf; + using ::logbl; + + using ::lrint; + using ::lrintf; + using ::lrintl; + + using ::lround; + using ::lroundf; + using ::lroundl; + + using ::nan; + using ::nanf; + using ::nanl; + + using ::nearbyint; + using ::nearbyintf; + using ::nearbyintl; + + using ::nextafter; + using ::nextafterf; + using ::nextafterl; + + using ::nexttoward; + using ::nexttowardf; + using ::nexttowardl; + + using ::remainder; + using ::remainderf; + using ::remainderl; + + using ::remquo; + using ::remquof; + using ::remquol; + + using ::rint; + using ::rintf; + using ::rintl; + + using ::round; + using ::roundf; + using ::roundl; + + using ::scalbln; + using ::scalblnf; + using ::scalblnl; + + using ::scalbn; + using ::scalbnf; + using ::scalbnl; + + using ::tgamma; + using ::tgammaf; + using ::tgammal; + + using ::trunc; + using ::truncf; + using ::truncl; + + + + constexpr float + acosh(float __x) + { return __builtin_acoshf(__x); } + + constexpr long double + acosh(long double __x) + { return __builtin_acoshl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + acosh(_Tp __x) + { return __builtin_acosh(__x); } + + + + constexpr float + asinh(float __x) + { return __builtin_asinhf(__x); } + + constexpr long double + asinh(long double __x) + { return __builtin_asinhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + asinh(_Tp __x) + { return __builtin_asinh(__x); } + + + + constexpr float + atanh(float __x) + { return __builtin_atanhf(__x); } + + constexpr long double + atanh(long double __x) + { return __builtin_atanhl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + atanh(_Tp __x) + { return __builtin_atanh(__x); } + + + + constexpr float + cbrt(float __x) + { return __builtin_cbrtf(__x); } + + constexpr long double + cbrt(long double __x) + { return __builtin_cbrtl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + cbrt(_Tp __x) + { return __builtin_cbrt(__x); } + + + + constexpr float + copysign(float __x, float __y) + { return __builtin_copysignf(__x, __y); } + + constexpr long double + copysign(long double __x, long double __y) + { return __builtin_copysignl(__x, __y); } + + + + constexpr float + erf(float __x) + { return __builtin_erff(__x); } + + constexpr long double + erf(long double __x) + { return __builtin_erfl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erf(_Tp __x) + { return __builtin_erf(__x); } + + + + constexpr float + erfc(float __x) + { return __builtin_erfcf(__x); } + + constexpr long double + erfc(long double __x) + { return __builtin_erfcl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + erfc(_Tp __x) + { return __builtin_erfc(__x); } + + + + constexpr float + exp2(float __x) + { return __builtin_exp2f(__x); } + + constexpr long double + exp2(long double __x) + { return __builtin_exp2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + exp2(_Tp __x) + { return __builtin_exp2(__x); } + + + + constexpr float + expm1(float __x) + { return __builtin_expm1f(__x); } + + constexpr long double + expm1(long double __x) + { return __builtin_expm1l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + expm1(_Tp __x) + { return __builtin_expm1(__x); } + + + + constexpr float + fdim(float __x, float __y) + { return __builtin_fdimf(__x, __y); } + + constexpr long double + fdim(long double __x, long double __y) + { return __builtin_fdiml(__x, __y); } + + + + constexpr float + fma(float __x, float __y, float __z) + { return __builtin_fmaf(__x, __y, __z); } + + constexpr long double + fma(long double __x, long double __y, long double __z) + { return __builtin_fmal(__x, __y, __z); } + + + + constexpr float + fmax(float __x, float __y) + { return __builtin_fmaxf(__x, __y); } + + constexpr long double + fmax(long double __x, long double __y) + { return __builtin_fmaxl(__x, __y); } + + + + constexpr float + fmin(float __x, float __y) + { return __builtin_fminf(__x, __y); } + + constexpr long double + fmin(long double __x, long double __y) + { return __builtin_fminl(__x, __y); } + + + + constexpr float + hypot(float __x, float __y) + { return __builtin_hypotf(__x, __y); } + + constexpr long double + hypot(long double __x, long double __y) + { return __builtin_hypotl(__x, __y); } + + + + constexpr int + ilogb(float __x) + { return __builtin_ilogbf(__x); } + + constexpr int + ilogb(long double __x) + { return __builtin_ilogbl(__x); } + + + + template + constexpr + typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + int>::__type + ilogb(_Tp __x) + { return __builtin_ilogb(__x); } + + + + constexpr float + lgamma(float __x) + { return __builtin_lgammaf(__x); } + + constexpr long double + lgamma(long double __x) + { return __builtin_lgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + lgamma(_Tp __x) + { return __builtin_lgamma(__x); } + + + + constexpr long long + llrint(float __x) + { return __builtin_llrintf(__x); } + + constexpr long long + llrint(long double __x) + { return __builtin_llrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llrint(_Tp __x) + { return __builtin_llrint(__x); } + + + + constexpr long long + llround(float __x) + { return __builtin_llroundf(__x); } + + constexpr long long + llround(long double __x) + { return __builtin_llroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long long>::__type + llround(_Tp __x) + { return __builtin_llround(__x); } + + + + constexpr float + log1p(float __x) + { return __builtin_log1pf(__x); } + + constexpr long double + log1p(long double __x) + { return __builtin_log1pl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log1p(_Tp __x) + { return __builtin_log1p(__x); } + + + + + constexpr float + log2(float __x) + { return __builtin_log2f(__x); } + + constexpr long double + log2(long double __x) + { return __builtin_log2l(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + log2(_Tp __x) + { return __builtin_log2(__x); } + + + + constexpr float + logb(float __x) + { return __builtin_logbf(__x); } + + constexpr long double + logb(long double __x) + { return __builtin_logbl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + logb(_Tp __x) + { return __builtin_logb(__x); } + + + + constexpr long + lrint(float __x) + { return __builtin_lrintf(__x); } + + constexpr long + lrint(long double __x) + { return __builtin_lrintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lrint(_Tp __x) + { return __builtin_lrint(__x); } + + + + constexpr long + lround(float __x) + { return __builtin_lroundf(__x); } + + constexpr long + lround(long double __x) + { return __builtin_lroundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + long>::__type + lround(_Tp __x) + { return __builtin_lround(__x); } + + + + constexpr float + nearbyint(float __x) + { return __builtin_nearbyintf(__x); } + + constexpr long double + nearbyint(long double __x) + { return __builtin_nearbyintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nearbyint(_Tp __x) + { return __builtin_nearbyint(__x); } + + + + constexpr float + nextafter(float __x, float __y) + { return __builtin_nextafterf(__x, __y); } + + constexpr long double + nextafter(long double __x, long double __y) + { return __builtin_nextafterl(__x, __y); } + + + + constexpr float + nexttoward(float __x, long double __y) + { return __builtin_nexttowardf(__x, __y); } + + constexpr long double + nexttoward(long double __x, long double __y) + { return __builtin_nexttowardl(__x, __y); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + nexttoward(_Tp __x, long double __y) + { return __builtin_nexttoward(__x, __y); } + + + + constexpr float + remainder(float __x, float __y) + { return __builtin_remainderf(__x, __y); } + + constexpr long double + remainder(long double __x, long double __y) + { return __builtin_remainderl(__x, __y); } + + + + inline float + remquo(float __x, float __y, int* __pquo) + { return __builtin_remquof(__x, __y, __pquo); } + + inline long double + remquo(long double __x, long double __y, int* __pquo) + { return __builtin_remquol(__x, __y, __pquo); } + + + + constexpr float + rint(float __x) + { return __builtin_rintf(__x); } + + constexpr long double + rint(long double __x) + { return __builtin_rintl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + rint(_Tp __x) + { return __builtin_rint(__x); } + + + + constexpr float + round(float __x) + { return __builtin_roundf(__x); } + + constexpr long double + round(long double __x) + { return __builtin_roundl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + round(_Tp __x) + { return __builtin_round(__x); } + + + + constexpr float + scalbln(float __x, long __ex) + { return __builtin_scalblnf(__x, __ex); } + + constexpr long double + scalbln(long double __x, long __ex) + { return __builtin_scalblnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbln(_Tp __x, long __ex) + { return __builtin_scalbln(__x, __ex); } + + + + constexpr float + scalbn(float __x, int __ex) + { return __builtin_scalbnf(__x, __ex); } + + constexpr long double + scalbn(long double __x, int __ex) + { return __builtin_scalbnl(__x, __ex); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + scalbn(_Tp __x, int __ex) + { return __builtin_scalbn(__x, __ex); } + + + + constexpr float + tgamma(float __x) + { return __builtin_tgammaf(__x); } + + constexpr long double + tgamma(long double __x) + { return __builtin_tgammal(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + tgamma(_Tp __x) + { return __builtin_tgamma(__x); } + + + + constexpr float + trunc(float __x) + { return __builtin_truncf(__x); } + + constexpr long double + trunc(long double __x) + { return __builtin_truncl(__x); } + + + + template + constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, + double>::__type + trunc(_Tp __x) + { return __builtin_trunc(__x); } +# 3469 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + copysign(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return copysign(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fdim(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fdim(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmax(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmax(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + fmin(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return fmin(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + hypot(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return hypot(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + nextafter(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return nextafter(__type(__x), __type(__y)); + } + + template + constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remainder(_Tp __x, _Up __y) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remainder(__type(__x), __type(__y)); + } + + template + inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type + remquo(_Tp __x, _Up __y, int* __pquo) + { + typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; + return remquo(__type(__x), __type(__y), __pquo); + } + + template + constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type + fma(_Tp __x, _Up __y, _Vp __z) + { + typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; + return fma(__type(__x), __type(__y), __type(__z)); + } +# 3550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 + template + inline _Tp + __hypot3(_Tp __x, _Tp __y, _Tp __z) + { + __x = std::abs(__x); + __y = std::abs(__y); + __z = std::abs(__z); + if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) + return __a * std::sqrt((__x / __a) * (__x / __a) + + (__y / __a) * (__y / __a) + + (__z / __a) * (__z / __a)); + else + return {}; + } + + inline float + hypot(float __x, float __y, float __z) + { return std::__hypot3(__x, __y, __z); } + + inline double + hypot(double __x, double __y, double __z) + { return std::__hypot3(__x, __y, __z); } + + inline long double + hypot(long double __x, long double __y, long double __z) + { return std::__hypot3(__x, __y, __z); } + + template + __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> + hypot(_Tp __x, _Up __y, _Vp __z) + { + using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; + return std::__hypot3<__type>(__x, __y, __z); + } +# 3696 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 +} + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/specfun.h" 1 3 +# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/specfun.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 2 3 + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + void + __throw_bad_exception(void) __attribute__((__noreturn__)); + + + void + __throw_bad_alloc(void) __attribute__((__noreturn__)); + + void + __throw_bad_array_new_length(void) __attribute__((__noreturn__)); + + + void + __throw_bad_cast(void) __attribute__((__noreturn__)); + + void + __throw_bad_typeid(void) __attribute__((__noreturn__)); + + + void + __throw_logic_error(const char*) __attribute__((__noreturn__)); + + void + __throw_domain_error(const char*) __attribute__((__noreturn__)); + + void + __throw_invalid_argument(const char*) __attribute__((__noreturn__)); + + void + __throw_length_error(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range(const char*) __attribute__((__noreturn__)); + + void + __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) + __attribute__((__format__(__gnu_printf__, 1, 2))); + + void + __throw_runtime_error(const char*) __attribute__((__noreturn__)); + + void + __throw_range_error(const char*) __attribute__((__noreturn__)); + + void + __throw_overflow_error(const char*) __attribute__((__noreturn__)); + + void + __throw_underflow_error(const char*) __attribute__((__noreturn__)); + + + void + __throw_ios_failure(const char*) __attribute__((__noreturn__)); + + void + __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); + + + void + __throw_system_error(int) __attribute__((__noreturn__)); + + + void + __throw_future_error(int) __attribute__((__noreturn__)); + + + void + __throw_bad_function_call() __attribute__((__noreturn__)); +# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 +} +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + + + + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __is_integer_nonstrict + : public std::__is_integer<_Tp> + { + using std::__is_integer<_Tp>::__value; + + + enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; + }; + + template + struct __numeric_traits_integer + { + + static_assert(__is_integer_nonstrict<_Value>::__value, + "invalid specialization"); + + + + + static const bool __is_signed = (_Value)(-1) < 0; + static const int __digits + = __is_integer_nonstrict<_Value>::__width - __is_signed; + + + static const _Value __max = __is_signed + ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) + : ~(_Value)0; + static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; + }; + + template + const _Value __numeric_traits_integer<_Value>::__min; + + template + const _Value __numeric_traits_integer<_Value>::__max; + + template + const bool __numeric_traits_integer<_Value>::__is_signed; + + template + const int __numeric_traits_integer<_Value>::__digits; +# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; + + + + + + + template + using __int_traits = __numeric_traits_integer<_Tp>; +# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 + template + struct __numeric_traits_floating + { + + static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); + + + static const bool __is_signed = true; + static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); + static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); + }; + + template + const int __numeric_traits_floating<_Value>::__max_digits10; + + template + const bool __numeric_traits_floating<_Value>::__is_signed; + + template + const int __numeric_traits_floating<_Value>::__digits10; + + template + const int __numeric_traits_floating<_Value>::__max_exponent10; + + + + + + + template + struct __numeric_traits + : public __numeric_traits_integer<_Value> + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; + + template<> + struct __numeric_traits + : public __numeric_traits_floating + { }; +# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 +} +# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 +# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + class reference_wrapper; +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } + + }; + + + + + + + + using true_type = integral_constant; + + + using false_type = integral_constant; + + + + template + using __bool_constant = integral_constant; + + + + + + + template + using bool_constant = integral_constant; + + + + + + + template + struct enable_if + { }; + + + template + struct enable_if + { typedef _Tp type; }; + + + template + using __enable_if_t = typename enable_if<_Cond, _Tp>::type; + + template + struct __conditional + { + template + using type = _Tp; + }; + + template<> + struct __conditional + { + template + using type = _Up; + }; + + + template + using __conditional_t + = typename __conditional<_Cond>::template type<_If, _Else>; + + + template + struct __type_identity + { using type = _Type; }; + + template + using __type_identity_t = typename __type_identity<_Tp>::type; + + namespace __detail + { + + template + using __first_t = _Tp; + + + template + auto __or_fn(int) -> __first_t...>; + + template + auto __or_fn(...) -> true_type; + + template + auto __and_fn(int) -> __first_t...>; + + template + auto __and_fn(...) -> false_type; + } + + + + + template + struct __or_ + : decltype(__detail::__or_fn<_Bn...>(0)) + { }; + + template + struct __and_ + : decltype(__detail::__and_fn<_Bn...>(0)) + { }; + + template + struct __not_ + : __bool_constant + { }; + + + + + + template + inline constexpr bool __or_v = __or_<_Bn...>::value; + template + inline constexpr bool __and_v = __and_<_Bn...>::value; + + namespace __detail + { + template + struct __disjunction_impl + { using type = _B1; }; + + template + struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __disjunction_impl::type; }; + + template + struct __conjunction_impl + { using type = _B1; }; + + template + struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> + { using type = typename __conjunction_impl::type; }; + } + + + + + template + struct conjunction + : __detail::__conjunction_impl::type + { }; + + template<> + struct conjunction<> + : true_type + { }; + + template + struct disjunction + : __detail::__disjunction_impl::type + { }; + + template<> + struct disjunction<> + : false_type + { }; + + template + struct negation + : __not_<_Pp>::type + { }; + + + + + template + inline constexpr bool conjunction_v = conjunction<_Bn...>::value; + + template + inline constexpr bool disjunction_v = disjunction<_Bn...>::value; + + template + inline constexpr bool negation_v = negation<_Pp>::value; + + + + + + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct remove_cv; + template + struct is_const; + + + template + struct __is_array_unknown_bounds; + + + + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + + + template + using __remove_cv_t = typename remove_cv<_Tp>::type; + + + + + + template + struct is_void + : public false_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + template<> + struct is_void + : public true_type { }; + + + template + struct __is_integral_helper + : public false_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + + + + + + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; + + template<> + struct __is_integral_helper + : public true_type { }; +# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_integral + : public __is_integral_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct __is_floating_point_helper + : public false_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; + + template<> + struct __is_floating_point_helper + : public true_type { }; +# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_floating_point + : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_array + : public false_type { }; + + template + struct is_array<_Tp[_Size]> + : public true_type { }; + + template + struct is_array<_Tp[]> + : public true_type { }; + + template + struct __is_pointer_helper + : public false_type { }; + + template + struct __is_pointer_helper<_Tp*> + : public true_type { }; + + + template + struct is_pointer + : public __is_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_lvalue_reference + : public false_type { }; + + template + struct is_lvalue_reference<_Tp&> + : public true_type { }; + + + template + struct is_rvalue_reference + : public false_type { }; + + template + struct is_rvalue_reference<_Tp&&> + : public true_type { }; + + template + struct __is_member_object_pointer_helper + : public false_type { }; + + template + struct __is_member_object_pointer_helper<_Tp _Cp::*> + : public __not_>::type { }; + + + template + struct is_member_object_pointer + : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct __is_member_function_pointer_helper + : public false_type { }; + + template + struct __is_member_function_pointer_helper<_Tp _Cp::*> + : public is_function<_Tp>::type { }; + + + template + struct is_member_function_pointer + : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + + template + struct is_enum + : public integral_constant + { }; + + + template + struct is_union + : public integral_constant + { }; + + + template + struct is_class + : public integral_constant + { }; + + + template + struct is_function + : public __bool_constant::value> { }; + + template + struct is_function<_Tp&> + : public false_type { }; + + template + struct is_function<_Tp&&> + : public false_type { }; + + + + + template + struct is_null_pointer + : public false_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + template<> + struct is_null_pointer + : public true_type { }; + + + + template + struct __is_nullptr_t + : public is_null_pointer<_Tp> + { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); + + + + + template + struct is_reference + : public false_type + { }; + + template + struct is_reference<_Tp&> + : public true_type + { }; + + template + struct is_reference<_Tp&&> + : public true_type + { }; + + + template + struct is_arithmetic + : public __or_, is_floating_point<_Tp>>::type + { }; + + + template + struct is_fundamental + : public __or_, is_void<_Tp>, + is_null_pointer<_Tp>>::type + { }; + + + template + struct is_object + : public __not_<__or_, is_reference<_Tp>, + is_void<_Tp>>>::type + { }; + + template + struct is_member_pointer; + + + template + struct is_scalar + : public __or_, is_enum<_Tp>, is_pointer<_Tp>, + is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type + { }; + + + template + struct is_compound + : public __not_>::type { }; + + + template + struct __is_member_pointer_helper + : public false_type { }; + + template + struct __is_member_pointer_helper<_Tp _Cp::*> + : public true_type { }; + + + + template + struct is_member_pointer + : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type + { }; + + template + struct is_same; + + + template + using __is_one_of = __or_...>; + + + __extension__ + template + using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, + signed char, signed short, signed int, signed long, + signed long long +# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + __extension__ + template + using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, + unsigned char, unsigned short, unsigned int, unsigned long, + unsigned long long +# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + >; + + + template + using __is_standard_integer + = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; + + + template using __void_t = void; + + + + + + template + struct is_const + : public false_type { }; + + template + struct is_const<_Tp const> + : public true_type { }; + + + template + struct is_volatile + : public false_type { }; + + template + struct is_volatile<_Tp volatile> + : public true_type { }; + + + template + struct is_trivial + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copyable + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_standard_layout + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + template + struct + + is_pod + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct + [[__deprecated__]] + is_literal_type + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_empty + : public integral_constant + { }; + + + template + struct is_polymorphic + : public integral_constant + { }; + + + + + + template + struct is_final + : public integral_constant + { }; + + + + template + struct is_abstract + : public integral_constant + { }; + + + template::value> + struct __is_signed_helper + : public false_type { }; + + template + struct __is_signed_helper<_Tp, true> + : public integral_constant + { }; + + + + template + struct is_signed + : public __is_signed_helper<_Tp>::type + { }; + + + template + struct is_unsigned + : public __and_, __not_>>::type + { }; + + + template + _Up + __declval(int); + + template + _Tp + __declval(long); + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)); + + template + struct remove_all_extents; + + + template + struct __is_array_known_bounds + : public false_type + { }; + + template + struct __is_array_known_bounds<_Tp[_Size]> + : public true_type + { }; + + template + struct __is_array_unknown_bounds + : public false_type + { }; + + template + struct __is_array_unknown_bounds<_Tp[]> + : public true_type + { }; +# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + struct __do_is_destructible_impl + { + template().~_Tp())> + static true_type __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_destructible_impl + : public __do_is_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_destructible_safe; + + template + struct __is_destructible_safe<_Tp, false, false> + : public __is_destructible_impl::type>::type + { }; + + template + struct __is_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_destructible + : public __is_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + + + struct __do_is_nt_destructible_impl + { + template + static __bool_constant().~_Tp())> + __test(int); + + template + static false_type __test(...); + }; + + template + struct __is_nt_destructible_impl + : public __do_is_nt_destructible_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template, + __is_array_unknown_bounds<_Tp>, + is_function<_Tp>>::value, + bool = __or_, is_scalar<_Tp>>::value> + struct __is_nt_destructible_safe; + + template + struct __is_nt_destructible_safe<_Tp, false, false> + : public __is_nt_destructible_impl::type>::type + { }; + + template + struct __is_nt_destructible_safe<_Tp, true, false> + : public false_type { }; + + template + struct __is_nt_destructible_safe<_Tp, false, true> + : public true_type { }; + + + + template + struct is_nothrow_destructible + : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_constructible_impl + = __bool_constant<__is_constructible(_Tp, _Args...)>; + + + + template + struct is_constructible + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_default_constructible + : public __is_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_lvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> + { using type = _Tp&; }; + + template + using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; + + + + template + struct is_copy_constructible + : public __is_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct __add_rvalue_reference_helper + { using type = _Tp; }; + + template + struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> + { using type = _Tp&&; }; + + template + using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; + + + + template + struct is_move_constructible + : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_constructible_impl + = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; + + + + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_default_constructible + : public __is_nothrow_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_constructible + : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; + + + + template + struct is_assignable + : public __is_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_copy_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_move_assignable + : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_nothrow_assignable_impl + = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; + + + + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_copy_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_move_assignable + : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_constructible_impl + = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; + + + + template + struct is_trivially_constructible + : public __is_trivially_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_default_constructible + : public __is_trivially_constructible_impl<_Tp> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + struct __do_is_implicitly_default_constructible_impl + { + template + static void __helper(const _Tp&); + + template + static true_type __test(const _Tp&, + decltype(__helper({}))* = 0); + + static false_type __test(...); + }; + + template + struct __is_implicitly_default_constructible_impl + : public __do_is_implicitly_default_constructible_impl + { + typedef decltype(__test(declval<_Tp>())) type; + }; + + template + struct __is_implicitly_default_constructible_safe + : public __is_implicitly_default_constructible_impl<_Tp>::type + { }; + + template + struct __is_implicitly_default_constructible + : public __and_<__is_constructible_impl<_Tp>, + __is_implicitly_default_constructible_safe<_Tp>>::type + { }; + + + template + struct is_trivially_copy_constructible + : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_constructible + : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + using __is_trivially_assignable_impl + = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; + + + + template + struct is_trivially_assignable + : public __is_trivially_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_copy_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_lval_ref_t> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_move_assignable + : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_trivially_destructible + : public __and_<__is_destructible_safe<_Tp>, + __bool_constant<__has_trivial_destructor(_Tp)>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + struct has_virtual_destructor + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + + + template + struct alignment_of + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct rank + : public integral_constant { }; + + template + struct rank<_Tp[_Size]> + : public integral_constant::value> { }; + + template + struct rank<_Tp[]> + : public integral_constant::value> { }; + + + template + struct extent + : public integral_constant { }; + + template + struct extent<_Tp[_Size], 0> + : public integral_constant { }; + + template + struct extent<_Tp[_Size], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + template + struct extent<_Tp[], 0> + : public integral_constant { }; + + template + struct extent<_Tp[], _Uint> + : public extent<_Tp, _Uint - 1>::type { }; + + + + + + template + struct is_same + + : public integral_constant + + + + { }; +# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct is_base_of + : public integral_constant + { }; + + + template + struct is_convertible + : public __bool_constant<__is_convertible(_From, _To)> + { }; +# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + using __is_array_convertible + = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; +# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_const + { typedef _Tp type; }; + + template + struct remove_const<_Tp const> + { typedef _Tp type; }; + + + template + struct remove_volatile + { typedef _Tp type; }; + + template + struct remove_volatile<_Tp volatile> + { typedef _Tp type; }; + + + + template + struct remove_cv + { using type = __remove_cv(_Tp); }; +# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct add_const + { using type = _Tp const; }; + + + template + struct add_volatile + { using type = _Tp volatile; }; + + + template + struct add_cv + { using type = _Tp const volatile; }; + + + + + + + template + using remove_const_t = typename remove_const<_Tp>::type; + + + template + using remove_volatile_t = typename remove_volatile<_Tp>::type; + + + template + using remove_cv_t = typename remove_cv<_Tp>::type; + + + template + using add_const_t = typename add_const<_Tp>::type; + + + template + using add_volatile_t = typename add_volatile<_Tp>::type; + + + template + using add_cv_t = typename add_cv<_Tp>::type; +# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct remove_reference + { using type = _Tp; }; + + template + struct remove_reference<_Tp&> + { using type = _Tp; }; + + template + struct remove_reference<_Tp&&> + { using type = _Tp; }; + + + + template + struct add_lvalue_reference + { using type = __add_lval_ref_t<_Tp>; }; + + + template + struct add_rvalue_reference + { using type = __add_rval_ref_t<_Tp>; }; + + + + template + using remove_reference_t = typename remove_reference<_Tp>::type; + + + template + using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; + + + template + using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; + + + + + + + + template + struct __cv_selector; + + template + struct __cv_selector<_Unqualified, false, false> + { 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; }; +# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_unsigned_selector; + + template + class __make_unsigned_selector<_Tp, true, false> + { + using __unsigned_type + = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + class __make_unsigned_selector_base + { + protected: + template struct _List { }; + + template + struct _List<_Tp, _Up...> : _List<_Up...> + { static constexpr size_t __size = sizeof(_Tp); }; + + template + struct __select; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, true> + { using __type = _Uint; }; + + template + struct __select<_Sz, _List<_Uint, _UInts...>, false> + : __select<_Sz, _List<_UInts...>> + { }; + }; + + + template + class __make_unsigned_selector<_Tp, false, true> + : __make_unsigned_selector_base + { + + using _UInts = _List; + + using __unsigned_type = typename __select::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; + }; + + + + + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; +# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + template<> + struct __make_unsigned + { + using __type + = typename __make_unsigned_selector::__type; + }; + + + + + + + template + struct make_unsigned + { typedef typename __make_unsigned_selector<_Tp>::__type type; }; + + + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + template<> struct make_unsigned; + + + + + template + struct __make_signed + { typedef _Tp __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed char __type; }; + + template<> + struct __make_signed + { typedef signed short __type; }; + + template<> + struct __make_signed + { typedef signed int __type; }; + + template<> + struct __make_signed + { typedef signed long __type; }; + + template<> + struct __make_signed + { typedef signed long long __type; }; +# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, + bool _IsEnum = is_enum<_Tp>::value> + class __make_signed_selector; + + template + class __make_signed_selector<_Tp, true, false> + { + using __signed_type + = typename __make_signed<__remove_cv_t<_Tp>>::__type; + + public: + using __type + = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; + }; + + + template + class __make_signed_selector<_Tp, false, true> + { + typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; + + public: + typedef typename __make_signed_selector<__unsigned_type>::__type __type; + }; + + + + + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; +# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + template<> + struct __make_signed + { + using __type + = typename __make_signed_selector::__type; + }; + + + + + + + template + struct make_signed + { typedef typename __make_signed_selector<_Tp>::__type type; }; + + + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + template<> struct make_signed; + + + + template + using make_signed_t = typename make_signed<_Tp>::type; + + + template + using make_unsigned_t = typename make_unsigned<_Tp>::type; + + + + + + template + struct remove_extent + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[_Size]> + { typedef _Tp type; }; + + template + struct remove_extent<_Tp[]> + { typedef _Tp type; }; + + + template + struct remove_all_extents + { typedef _Tp type; }; + + template + struct remove_all_extents<_Tp[_Size]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + template + struct remove_all_extents<_Tp[]> + { typedef typename remove_all_extents<_Tp>::type type; }; + + + + template + using remove_extent_t = typename remove_extent<_Tp>::type; + + + template + using remove_all_extents_t = typename remove_all_extents<_Tp>::type; + + + + + template + struct __remove_pointer_helper + { typedef _Tp type; }; + + template + struct __remove_pointer_helper<_Tp, _Up*> + { typedef _Up type; }; + + + template + struct remove_pointer + : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> + { }; + + template + struct __add_pointer_helper + { using type = _Tp; }; + + template + struct __add_pointer_helper<_Tp, __void_t<_Tp*>> + { using type = _Tp*; }; + + + template + struct add_pointer + : public __add_pointer_helper<_Tp> + { }; + + template + struct add_pointer<_Tp&> + { using type = _Tp*; }; + + template + struct add_pointer<_Tp&&> + { using type = _Tp*; }; + + + + template + using remove_pointer_t = typename remove_pointer<_Tp>::type; + + + template + using add_pointer_t = typename add_pointer<_Tp>::type; + + + template + struct __aligned_storage_msa + { + union __type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__)) { } __align; + }; + }; +# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::__type)> + struct + + aligned_storage + { + union type + { + unsigned char __data[_Len]; + struct __attribute__((__aligned__((_Align)))) { } __align; + }; + }; + + template + struct __strictest_alignment + { + static const size_t _S_alignment = 0; + static const size_t _S_size = 0; + }; + + template + struct __strictest_alignment<_Tp, _Types...> + { + static const size_t _S_alignment = + alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment + ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; + static const size_t _S_size = + sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size + ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; +#pragma GCC diagnostic pop + + + + + + template + struct __decay_selector + : __conditional_t::value, + remove_cv<_Up>, + add_pointer<_Up>> + { }; + + template + struct __decay_selector<_Up[_Nm]> + { using type = _Up*; }; + + template + struct __decay_selector<_Up[]> + { using type = _Up*; }; + + + + + template + struct decay + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&> + { using type = typename __decay_selector<_Tp>::type; }; + + template + struct decay<_Tp&&> + { using type = typename __decay_selector<_Tp>::type; }; + + + + + template + struct __strip_reference_wrapper + { + typedef _Tp __type; + }; + + template + struct __strip_reference_wrapper > + { + typedef _Tp& __type; + }; + + + template + using __decay_t = typename decay<_Tp>::type; + + template + using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; + + + + + + template + using _Require = __enable_if_t<__and_<_Cond...>::value>; + + + template + using __remove_cvref_t + = typename remove_cv::type>::type; + + + + + template + struct conditional + { typedef _Iftrue type; }; + + + template + struct conditional + { typedef _Iffalse type; }; + + + template + struct common_type; +# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __success_type + { typedef _Tp type; }; + + struct __failure_type + { }; + + struct __do_common_type_impl + { + template + using __cond_t + = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); + + + + template + static __success_type<__decay_t<__cond_t<_Tp, _Up>>> + _S_test(int); +# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + static __failure_type + _S_test_2(...); + + template + static decltype(_S_test_2<_Tp, _Up>(0)) + _S_test(...); + }; + + + template<> + struct common_type<> + { }; + + + template + struct common_type<_Tp0> + : public common_type<_Tp0, _Tp0> + { }; + + + template, typename _Dp2 = __decay_t<_Tp2>> + struct __common_type_impl + { + + + using type = common_type<_Dp1, _Dp2>; + }; + + template + struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> + : private __do_common_type_impl + { + + + using type = decltype(_S_test<_Tp1, _Tp2>(0)); + }; + + + template + struct common_type<_Tp1, _Tp2> + : public __common_type_impl<_Tp1, _Tp2>::type + { }; + + template + struct __common_type_pack + { }; + + template + struct __common_type_fold; + + + template + struct common_type<_Tp1, _Tp2, _Rp...> + : public __common_type_fold, + __common_type_pack<_Rp...>> + { }; + + + + + template + struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, + __void_t> + : public common_type + { }; + + + template + struct __common_type_fold<_CTp, _Rp, void> + { }; + + template::value> + struct __underlying_type_impl + { + using type = __underlying_type(_Tp); + }; + + template + struct __underlying_type_impl<_Tp, false> + { }; + + + + template + struct underlying_type + : public __underlying_type_impl<_Tp> + { }; + + + template + struct __declval_protector + { + static const bool __stop = false; + }; + + + + + + + template + auto declval() noexcept -> decltype(__declval<_Tp>(0)) + { + static_assert(__declval_protector<_Tp>::__stop, + "declval() must not be used!"); + return __declval<_Tp>(0); + } + + + template + struct result_of; + + + + + + + struct __invoke_memfun_ref { }; + struct __invoke_memfun_deref { }; + struct __invoke_memobj_ref { }; + struct __invoke_memobj_deref { }; + struct __invoke_other { }; + + + template + struct __result_of_success : __success_type<_Tp> + { using __invoke_type = _Tag; }; + + + struct __result_of_memfun_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_ref + : private __result_of_memfun_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memfun_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) + ), __invoke_memfun_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memfun_deref + : private __result_of_memfun_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; + }; + + + struct __result_of_memobj_ref_impl + { + template + static __result_of_success().*std::declval<_Fp>() + ), __invoke_memobj_ref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_ref + : private __result_of_memobj_ref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + + struct __result_of_memobj_deref_impl + { + template + static __result_of_success()).*std::declval<_Fp>() + ), __invoke_memobj_deref> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_memobj_deref + : private __result_of_memobj_deref_impl + { + typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; + }; + + template + struct __result_of_memobj; + + template + struct __result_of_memobj<_Res _Class::*, _Arg> + { + typedef __remove_cvref_t<_Arg> _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t<__or_, + is_base_of<_Class, _Argval>>::value, + __result_of_memobj_ref<_MemPtr, _Arg>, + __result_of_memobj_deref<_MemPtr, _Arg> + >::type type; + }; + + template + struct __result_of_memfun; + + template + struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> + { + typedef typename remove_reference<_Arg>::type _Argval; + typedef _Res _Class::* _MemPtr; + typedef typename __conditional_t::value, + __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, + __result_of_memfun_deref<_MemPtr, _Arg, _Args...> + >::type type; + }; + + + + + + + template> + struct __inv_unwrap + { + using type = _Tp; + }; + + template + struct __inv_unwrap<_Tp, reference_wrapper<_Up>> + { + using type = _Up&; + }; + + template + struct __result_of_impl + { + typedef __failure_type type; + }; + + template + struct __result_of_impl + : public __result_of_memobj<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type> + { }; + + template + struct __result_of_impl + : public __result_of_memfun<__decay_t<_MemPtr>, + typename __inv_unwrap<_Arg>::type, _Args...> + { }; + + + struct __result_of_other_impl + { + template + static __result_of_success()(std::declval<_Args>()...) + ), __invoke_other> _S_test(int); + + template + static __failure_type _S_test(...); + }; + + template + struct __result_of_impl + : private __result_of_other_impl + { + typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; + }; + + + template + struct __invoke_result + : public __result_of_impl< + is_member_object_pointer< + typename remove_reference<_Functor>::type + >::value, + is_member_function_pointer< + typename remove_reference<_Functor>::type + >::value, + _Functor, _ArgTypes... + >::type + { }; + + + template + struct result_of<_Functor(_ArgTypes...)> + : public __invoke_result<_Functor, _ArgTypes...> + { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); + + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" + + template::__type)> + using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; + + template + using aligned_union_t = typename aligned_union<_Len, _Types...>::type; +#pragma GCC diagnostic pop + + + template + using decay_t = typename decay<_Tp>::type; + + + template + using enable_if_t = typename enable_if<_Cond, _Tp>::type; + + + template + using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; + + + template + using common_type_t = typename common_type<_Tp...>::type; + + + template + using underlying_type_t = typename underlying_type<_Tp>::type; + + + template + using result_of_t = typename result_of<_Tp>::type; + + + + + + template using void_t = void; +# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template class _Op, typename... _Args> + struct __detector + { + using type = _Default; + using __is_detected = false_type; + }; + + + template class _Op, + typename... _Args> + struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> + { + using type = _Op<_Args...>; + using __is_detected = true_type; + }; + + template class _Op, + typename... _Args> + using __detected_or = __detector<_Default, void, _Op, _Args...>; + + + + template class _Op, + typename... _Args> + using __detected_or_t + = typename __detected_or<_Default, _Op, _Args...>::type; +# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template + struct __is_swappable; + + template + struct __is_nothrow_swappable; + + template + struct __is_tuple_like_impl : false_type + { }; + + + template + struct __is_tuple_like + : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type + { }; + + + template + + inline + _Require<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>> + swap(_Tp&, _Tp&) + noexcept(__and_, + is_nothrow_move_assignable<_Tp>>::value); + + template + + inline + __enable_if_t<__is_swappable<_Tp>::value> + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value); + + + namespace __swappable_details { + using std::swap; + + struct __do_is_swappable_impl + { + template(), std::declval<_Tp&>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_impl + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_nothrow_swappable_impl + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp>(0)) type; + }; + + template + struct __is_swappable + : public __is_swappable_impl<_Tp>::type + { }; + + template + struct __is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { }; + + + + + + + + template + struct is_swappable + : public __is_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable + : public __is_nothrow_swappable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_v = + is_swappable<_Tp>::value; + + + template + inline constexpr bool is_nothrow_swappable_v = + is_nothrow_swappable<_Tp>::value; + + + + namespace __swappable_with_details { + using std::swap; + + struct __do_is_swappable_with_impl + { + template(), std::declval<_Up>())), + typename + = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> + static true_type __test(int); + + template + static false_type __test(...); + }; + + struct __do_is_nothrow_swappable_with_impl + { + template + static __bool_constant< + noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) + && + noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) + > __test(int); + + template + static false_type __test(...); + }; + + } + + template + struct __is_swappable_with_impl + : public __swappable_with_details::__do_is_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + template + struct __is_nothrow_swappable_with_impl + : public __swappable_with_details::__do_is_nothrow_swappable_with_impl + { + typedef decltype(__test<_Tp, _Up>(0)) type; + }; + + + template + struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> + : public __swappable_details::__do_is_nothrow_swappable_impl + { + typedef decltype(__test<_Tp&>(0)) type; + }; + + + + template + struct is_swappable_with + : public __is_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_swappable_with + : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "first template argument must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), + "second template argument must be a complete class or an unbounded array"); + }; + + + + template + inline constexpr bool is_swappable_with_v = + is_swappable_with<_Tp, _Up>::value; + + + template + inline constexpr bool is_nothrow_swappable_with_v = + is_nothrow_swappable_with<_Tp, _Up>::value; +# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 + template::value, typename = void> + struct __is_invocable_impl + : false_type + { + using __nothrow_conv = false_type; + }; + + + template + struct __is_invocable_impl<_Result, _Ret, + true, + __void_t> + : true_type + { + using __nothrow_conv = true_type; + }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + + template + struct __is_invocable_impl<_Result, _Ret, + false, + __void_t> + { + private: + + using _Res_t = typename _Result::type; + + + + static _Res_t _S_get() noexcept; + + + template + static void _S_conv(__type_identity_t<_Tp>) noexcept; + + + template(_S_get())), + typename = decltype(_S_conv<_Tp>(_S_get())), + + + + bool _Dangle = false + + > + static __bool_constant<_Nothrow && !_Dangle> + _S_test(int); + + template + static false_type + _S_test(...); + + public: + + using type = decltype(_S_test<_Ret, true>(1)); + + + using __nothrow_conv = decltype(_S_test<_Ret>(1)); + }; +#pragma GCC diagnostic pop + + template + struct __is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { }; + + template + constexpr bool __call_is_nt(__invoke_memfun_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept((std::declval<_Up>().*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memfun_deref) + { + return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( + std::declval<_Args>()...)); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_ref) + { + using _Up = typename __inv_unwrap<_Tp>::type; + return noexcept(std::declval<_Up>().*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_memobj_deref) + { + return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); + } + + template + constexpr bool __call_is_nt(__invoke_other) + { + return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); + } + + template + struct __call_is_nothrow + : __bool_constant< + std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) + > + { }; + + template + using __call_is_nothrow_ + = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; + + + template + struct __is_nothrow_invocable + : __and_<__is_invocable<_Fn, _Args...>, + __call_is_nothrow_<_Fn, _Args...>>::type + { }; + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" + struct __nonesuchbase {}; + struct __nonesuch : private __nonesuchbase { + ~__nonesuch() = delete; + __nonesuch(__nonesuch const&) = delete; + void operator=(__nonesuch const&) = delete; + }; +#pragma GCC diagnostic pop + + + + + + + template + struct invoke_result + : public __invoke_result<_Functor, _ArgTypes...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), + "_Functor must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; + + + template + struct is_invocable + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + template + struct is_invocable_r + : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; + + + template + struct is_nothrow_invocable + : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + }; + + + + + + template + using __is_nt_invocable_impl + = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; + + + + template + struct is_nothrow_invocable_r + : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + static_assert((std::__is_complete_or_unbounded( + __type_identity<_ArgTypes>{}) && ...), + "each argument type must be a complete class or an unbounded array"); + static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), + "_Ret must be a complete class or an unbounded array"); + }; +# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +template + inline constexpr bool is_void_v = is_void<_Tp>::value; +template + inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; +template + inline constexpr bool is_integral_v = is_integral<_Tp>::value; +template + inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; + +template + inline constexpr bool is_array_v = false; +template + inline constexpr bool is_array_v<_Tp[]> = true; +template + inline constexpr bool is_array_v<_Tp[_Num]> = true; + +template + inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; +template + inline constexpr bool is_lvalue_reference_v = false; +template + inline constexpr bool is_lvalue_reference_v<_Tp&> = true; +template + inline constexpr bool is_rvalue_reference_v = false; +template + inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; +template + inline constexpr bool is_member_object_pointer_v = + is_member_object_pointer<_Tp>::value; +template + inline constexpr bool is_member_function_pointer_v = + is_member_function_pointer<_Tp>::value; +template + inline constexpr bool is_enum_v = __is_enum(_Tp); +template + inline constexpr bool is_union_v = __is_union(_Tp); +template + inline constexpr bool is_class_v = __is_class(_Tp); +template + inline constexpr bool is_function_v = is_function<_Tp>::value; +template + inline constexpr bool is_reference_v = false; +template + inline constexpr bool is_reference_v<_Tp&> = true; +template + inline constexpr bool is_reference_v<_Tp&&> = true; +template + inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; +template + inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; +template + inline constexpr bool is_object_v = is_object<_Tp>::value; +template + inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; +template + inline constexpr bool is_compound_v = is_compound<_Tp>::value; +template + inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; +template + inline constexpr bool is_const_v = false; +template + inline constexpr bool is_const_v = true; +template + inline constexpr bool is_volatile_v = false; +template + inline constexpr bool is_volatile_v = true; + +template + inline constexpr bool is_trivial_v = __is_trivial(_Tp); +template + inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); +template + inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); +template + + inline constexpr bool is_pod_v = __is_pod(_Tp); +template + [[__deprecated__]] + inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); +template + inline constexpr bool is_empty_v = __is_empty(_Tp); +template + inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); +template + inline constexpr bool is_abstract_v = __is_abstract(_Tp); +template + inline constexpr bool is_final_v = __is_final(_Tp); + +template + inline constexpr bool is_signed_v = is_signed<_Tp>::value; +template + inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; + +template + inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); +template + inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); +template + inline constexpr bool is_copy_constructible_v + = __is_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_move_constructible_v + = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); +template + inline constexpr bool is_copy_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); +template + inline constexpr bool is_move_assignable_v + = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; + +template + inline constexpr bool is_trivially_constructible_v + = __is_trivially_constructible(_Tp, _Args...); +template + inline constexpr bool is_trivially_default_constructible_v + = __is_trivially_constructible(_Tp); +template + inline constexpr bool is_trivially_copy_constructible_v + = __is_trivially_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_constructible_v + = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_trivially_assignable_v + = __is_trivially_assignable(_Tp, _Up); +template + inline constexpr bool is_trivially_copy_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_trivially_move_assignable_v + = __is_trivially_assignable(__add_lval_ref_t<_Tp>, + __add_rval_ref_t<_Tp>); +template + inline constexpr bool is_trivially_destructible_v = + is_trivially_destructible<_Tp>::value; +template + inline constexpr bool is_nothrow_constructible_v + = __is_nothrow_constructible(_Tp, _Args...); +template + inline constexpr bool is_nothrow_default_constructible_v + = __is_nothrow_constructible(_Tp); +template + inline constexpr bool is_nothrow_copy_constructible_v + = __is_nothrow_constructible(_Tp, __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_constructible_v + = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_assignable_v + = __is_nothrow_assignable(_Tp, _Up); +template + inline constexpr bool is_nothrow_copy_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, + __add_lval_ref_t); +template + inline constexpr bool is_nothrow_move_assignable_v + = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); + +template + inline constexpr bool is_nothrow_destructible_v = + is_nothrow_destructible<_Tp>::value; + +template + inline constexpr bool has_virtual_destructor_v + = __has_virtual_destructor(_Tp); + +template + inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; + +template + inline constexpr size_t rank_v = 0; +template + inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; +template + inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; + +template + inline constexpr size_t extent_v = 0; +template + inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; +template + inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; +template + inline constexpr size_t extent_v<_Tp[], 0> = 0; +template + inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; + + +template + inline constexpr bool is_same_v = __is_same(_Tp, _Up); + + + + + + +template + inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); +template + inline constexpr bool is_convertible_v = __is_convertible(_From, _To); +template + inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_v + = is_nothrow_invocable<_Fn, _Args...>::value; +template + inline constexpr bool is_invocable_r_v + = is_invocable_r<_Ret, _Fn, _Args...>::value; +template + inline constexpr bool is_nothrow_invocable_r_v + = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; + + + + + + + template + struct has_unique_object_representations + : bool_constant<__has_unique_object_representations( + remove_cv_t> + )> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + + template + inline constexpr bool has_unique_object_representations_v + = has_unique_object_representations<_Tp>::value; + + + + + + + template + struct is_aggregate + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { }; + + + + + + template + inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); +# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 +} +# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 +# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + template + inline constexpr _Tp* + __addressof(_Tp& __r) noexcept + { return __builtin_addressof(__r); } +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type& __t) noexcept + { return static_cast<_Tp&&>(__t); } + + + + + + + + template + [[__nodiscard__]] + constexpr _Tp&& + forward(typename std::remove_reference<_Tp>::type&& __t) noexcept + { + static_assert(!std::is_lvalue_reference<_Tp>::value, + "std::forward must not be used to convert an rvalue to an lvalue"); + return static_cast<_Tp&&>(__t); + } + + + + + + + template + [[__nodiscard__]] + constexpr typename std::remove_reference<_Tp>::type&& + move(_Tp&& __t) noexcept + { return static_cast::type&&>(__t); } + + + template + struct __move_if_noexcept_cond + : public __and_<__not_>, + is_copy_constructible<_Tp>>::type { }; +# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + constexpr + __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> + move_if_noexcept(_Tp& __x) noexcept + { return std::move(__x); } +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + [[__nodiscard__]] + inline constexpr _Tp* + addressof(_Tp& __r) noexcept + { return std::__addressof(__r); } + + + + template + const _Tp* addressof(const _Tp&&) = delete; + + + template + + inline _Tp + __exchange(_Tp& __obj, _Up&& __new_val) + { + _Tp __old_val = std::move(__obj); + __obj = std::forward<_Up>(__new_val); + return __old_val; + } +# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 + template + + inline + + typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, + is_move_constructible<_Tp>, + is_move_assignable<_Tp>>::value>::type + + + + swap(_Tp& __a, _Tp& __b) + noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) + + { + + + + + _Tp __tmp = std::move(__a); + __a = std::move(__b); + __b = std::move(__tmp); + } + + + + + template + + inline + + typename enable_if<__is_swappable<_Tp>::value>::type + + + + swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) + noexcept(__is_nothrow_swappable<_Tp>::value) + { + for (size_t __n = 0; __n < _Nm; ++__n) + swap(__a[__n], __b[__n]); + } + + + +} +# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 +# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + template + struct tuple_size; + + + + + + template::type, + typename = typename enable_if::value>::type, + size_t = tuple_size<_Tp>::value> + using __enable_if_has_tuple_size = _Tp; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + template + struct tuple_size> + : public tuple_size<_Tp> { }; + + + template + inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; + + + + template + struct tuple_element; + + + template + using __tuple_element_t = typename tuple_element<__i, _Tp>::type; + + template + struct tuple_element<__i, const _Tp> + { + using type = const __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, volatile _Tp> + { + using type = volatile __tuple_element_t<__i, _Tp>; + }; + + template + struct tuple_element<__i, const volatile _Tp> + { + using type = const volatile __tuple_element_t<__i, _Tp>; + }; + + + + + + template + constexpr size_t + __find_uniq_type_in_pack() + { + constexpr size_t __sz = sizeof...(_Types); + constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; + size_t __n = __sz; + for (size_t __i = 0; __i < __sz; ++__i) + { + if (__found[__i]) + { + if (__n < __sz) + return __sz; + __n = __i; + } + } + return __n; + } +# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 + template + using tuple_element_t = typename tuple_element<__i, _Tp>::type; + + + + + template struct _Index_tuple { }; + + + template + struct _Build_index_tuple + { + + template + using _IdxTuple = _Index_tuple<_Indices...>; + + + using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; + + + + + }; + + + + + + + template + struct integer_sequence + { + typedef _Tp value_type; + static constexpr size_t size() noexcept { return sizeof...(_Idx); } + }; + + + template + using make_integer_sequence + + = __make_integer_seq; + + + + + + template + using index_sequence = integer_sequence; + + + template + using make_index_sequence = make_integer_sequence; + + + template + using index_sequence_for = make_index_sequence; + + + + struct in_place_t { + explicit in_place_t() = default; + }; + + inline constexpr in_place_t in_place{}; + + template struct in_place_type_t + { + explicit in_place_type_t() = default; + }; + + template + inline constexpr in_place_type_t<_Tp> in_place_type{}; + + template struct in_place_index_t + { + explicit in_place_index_t() = default; + }; + + template + inline constexpr in_place_index_t<_Idx> in_place_index{}; + + template + inline constexpr bool __is_in_place_type_v = false; + + template + inline constexpr bool __is_in_place_type_v> = true; + + template + using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; + + + + + template + struct _Nth_type + { }; + + template + struct _Nth_type<0, _Tp0, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Rest...> + { using type = _Tp1; }; + + template + struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp2; }; + + template + + + + struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> + : _Nth_type<_Np - 3, _Rest...> + { }; + + + template + struct _Nth_type<0, _Tp0, _Tp1, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp0; }; + + template + struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> + { using type = _Tp1; }; + + + + + + + +} +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 + + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; + + + inline constexpr piecewise_construct_t piecewise_construct = + piecewise_construct_t(); + + + + + template + class tuple; + + template + struct _Index_tuple; + + + + + + + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return __and_, + is_constructible<_T2, const _U2&>>::value; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return __and_, + is_convertible>::value; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return __and_, + is_constructible<_T2, _U2&&>>::value; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return __and_, + is_convertible<_U2&&, _T2>>::value; + } + }; + + template + struct _PCC + { + template + static constexpr bool _ConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyConvertiblePair() + { + return false; + } + + template + static constexpr bool _MoveConstructiblePair() + { + return false; + } + + template + static constexpr bool _ImplicitlyMoveConvertiblePair() + { + return false; + } + }; + + + + template class __pair_base + { + + template friend struct pair; + __pair_base() = default; + ~__pair_base() = default; + __pair_base(const __pair_base&) = default; + __pair_base& operator=(const __pair_base&) = delete; + + }; +# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct pair + : public __pair_base<_T1, _T2> + { + typedef _T1 first_type; + typedef _T2 second_type; + + _T1 first; + _T2 second; + + + constexpr pair(const pair&) = default; + constexpr pair(pair&&) = default; + + template + + pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); + + + void + swap(pair& __p) + noexcept(__and_<__is_nothrow_swappable<_T1>, + __is_nothrow_swappable<_T2>>::value) + { + using std::swap; + swap(first, __p.first); + swap(second, __p.second); + } +# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + template + + pair(tuple<_Args1...>&, tuple<_Args2...>&, + _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); + public: +# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template , + __is_implicitly_default_constructible<_U2>> + ::value, bool>::type = true> + constexpr pair() + : first(), second() { } + + template , + is_default_constructible<_U2>, + __not_< + __and_<__is_implicitly_default_constructible<_U1>, + __is_implicitly_default_constructible<_U2>>>> + ::value, bool>::type = false> + explicit constexpr pair() + : first(), second() { } + + + + using _PCCP = _PCC; + + + + template() + && _PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + template() + && !_PCCP::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const _T1& __a, const _T2& __b) + : first(__a), second(__b) { } + + + + template + using _PCCFP = _PCC::value + || !is_same<_T2, _U2>::value, + _T1, _T2>; + + + template::template + _ConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } + + template::template + _ConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(const pair<_U1, _U2>& __p) + : first(__p.first), second(__p.second) + { ; } +# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + private: + + + + struct __zero_as_null_pointer_constant + { + __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) + { } + template::value>> + __zero_as_null_pointer_constant(_Tp) = delete; + }; + + public: + + + + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + is_convertible<_U1, _T1>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template>, + is_pointer<_T2>, + is_constructible<_T1, _U1>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(_U1&& __x, __zero_as_null_pointer_constant, ...) + : first(std::forward<_U1>(__x)), second(nullptr) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + is_convertible<_U2, _T2>>::value, + bool> = true> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + template, + __not_>, + is_constructible<_T2, _U2>, + __not_>, + __not_>>::value, + bool> = false> + __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) + explicit constexpr + pair(__zero_as_null_pointer_constant, _U2&& __y, ...) + : first(nullptr), second(std::forward<_U2>(__y)) + { ; } + + + + template() + && _PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + template() + && !_PCCP::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(_U1&& __x, _U2&& __y) + : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) + { ; } + + + template::template + _MoveConstructiblePair<_U1, _U2>() + && _PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=true> + constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + template::template + _MoveConstructiblePair<_U1, _U2>() + && !_PCCFP<_U1, _U2>::template + _ImplicitlyMoveConvertiblePair<_U1, _U2>(), + bool>::type=false> + explicit constexpr pair(pair<_U1, _U2>&& __p) + : first(std::forward<_U1>(__p.first)), + second(std::forward<_U2>(__p.second)) + { ; } + + + + pair& + operator=(__conditional_t<__and_, + is_copy_assignable<_T2>>::value, + const pair&, const __nonesuch&> __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + pair& + operator=(__conditional_t<__and_, + is_move_assignable<_T2>>::value, + pair&&, __nonesuch&&> __p) + noexcept(__and_, + is_nothrow_move_assignable<_T2>>::value) + { + first = std::forward(__p.first); + second = std::forward(__p.second); + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, const _U2&>>::value, + pair&>::type + operator=(const pair<_U1, _U2>& __p) + { + first = __p.first; + second = __p.second; + return *this; + } + + template + typename enable_if<__and_, + is_assignable<_T2&, _U2&&>>::value, + pair&>::type + operator=(pair<_U1, _U2>&& __p) + { + first = std::forward<_U1>(__p.first); + second = std::forward<_U2>(__p.second); + return *this; + } +# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + }; + + + + + template pair(_T1, _T2) -> pair<_T1, _T2>; + + + + template + inline constexpr bool + operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first == __y.first && __x.second == __y.second; } +# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline constexpr bool + operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __x.first < __y.first + || (!(__y.first < __x.first) && __x.second < __y.second); } + + + template + inline constexpr bool + operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x == __y); } + + + template + inline constexpr bool + operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return __y < __x; } + + + template + inline constexpr bool + operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__y < __x); } + + + template + inline constexpr bool + operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) + { return !(__x < __y); } +# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + inline + + + typename enable_if<__and_<__is_swappable<_T1>, + __is_swappable<_T2>>::value>::type + + + + swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) + noexcept(noexcept(__x.swap(__y))) + { __x.swap(__y); } +# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + typename enable_if, + __is_swappable<_T2>>::value>::type + swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; +# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + constexpr pair::__type, + typename __decay_and_strip<_T2>::__type> + make_pair(_T1&& __x, _T2&& __y) + { + typedef typename __decay_and_strip<_T1>::__type __ds_type1; + typedef typename __decay_and_strip<_T2>::__type __ds_type2; + typedef pair<__ds_type1, __ds_type2> __pair_type; + return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); + } +# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 + template + struct __is_tuple_like_impl> : true_type + { }; + + + + template + struct tuple_size> + : public integral_constant { }; + + + template + struct tuple_element<0, pair<_Tp1, _Tp2>> + { typedef _Tp1 type; }; + + + template + struct tuple_element<1, pair<_Tp1, _Tp2>> + { typedef _Tp2 type; }; + + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr size_t tuple_size_v> = 2; + + template + inline constexpr bool __is_pair = false; + + template + inline constexpr bool __is_pair> = true; + + + + template + struct __pair_get; + + template<> + struct __pair_get<0> + { + template + static constexpr _Tp1& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr _Tp1&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp1>(__pair.first); } + + template + static constexpr const _Tp1& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.first; } + + template + static constexpr const _Tp1&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.first); } + }; + + template<> + struct __pair_get<1> + { + template + static constexpr _Tp2& + __get(pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr _Tp2&& + __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward<_Tp2>(__pair.second); } + + template + static constexpr const _Tp2& + __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept + { return __pair.second; } + + template + static constexpr const _Tp2&& + __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept + { return std::forward(__pair.second); } + }; + + + + + + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__get(__in); } + + template + constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__move_get(std::move(__in)); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& + get(const pair<_Tp1, _Tp2>& __in) noexcept + { return __pair_get<_Int>::__const_get(__in); } + + template + constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& + get(const pair<_Tp1, _Tp2>&& __in) noexcept + { return __pair_get<_Int>::__const_move_get(std::move(__in)); } + + + + + + template + constexpr _Tp& + get(pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr const _Tp& + get(const pair<_Tp, _Up>& __p) noexcept + { return __p.first; } + + template + constexpr _Tp&& + get(pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr const _Tp&& + get(const pair<_Tp, _Up>&& __p) noexcept + { return std::move(__p.first); } + + template + constexpr _Tp& + get(pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr const _Tp& + get(const pair<_Up, _Tp>& __p) noexcept + { return __p.second; } + + template + constexpr _Tp&& + get(pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } + + template + constexpr const _Tp&& + get(const pair<_Up, _Tp>&& __p) noexcept + { return std::move(__p.second); } +# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 +} +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + struct input_iterator_tag { }; + + + struct output_iterator_tag { }; + + + struct forward_iterator_tag : public input_iterator_tag { }; + + + + struct bidirectional_iterator_tag : public forward_iterator_tag { }; + + + + struct random_access_iterator_tag : public bidirectional_iterator_tag { }; +# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct [[__deprecated__]] iterator + { + + typedef _Category iterator_category; + + typedef _Tp value_type; + + typedef _Distance difference_type; + + typedef _Pointer pointer; + + typedef _Reference reference; + }; +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits; + + + + + template> + struct __iterator_traits { }; + + + + template + struct __iterator_traits<_Iterator, + __void_t> + { + typedef typename _Iterator::iterator_category iterator_category; + typedef typename _Iterator::value_type value_type; + typedef typename _Iterator::difference_type difference_type; + typedef typename _Iterator::pointer pointer; + typedef typename _Iterator::reference reference; + }; + + + template + struct iterator_traits + : public __iterator_traits<_Iterator> { }; +# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 + template + struct iterator_traits<_Tp*> + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef _Tp* pointer; + typedef _Tp& reference; + }; + + + template + struct iterator_traits + { + typedef random_access_iterator_tag iterator_category; + typedef _Tp value_type; + typedef ptrdiff_t difference_type; + typedef const _Tp* pointer; + typedef const _Tp& reference; + }; + + + + + + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_Iter>::iterator_category + __iterator_category(const _Iter&) + { return typename iterator_traits<_Iter>::iterator_category(); } + + + + + template + using __iterator_category_t + = typename iterator_traits<_Iter>::iterator_category; + + template + using _RequireInputIter = + __enable_if_t, + input_iterator_tag>::value>; + + template> + struct __is_random_access_iter + : is_base_of + { + typedef is_base_of _Base; + enum { __value = _Base::value }; + }; +# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 +} +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 +# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 +# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 +# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 +# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + template struct _List_iterator; + template struct _List_const_iterator; + + + template + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + __distance(_InputIterator __first, _InputIterator __last, + input_iterator_tag) + { + + + + typename iterator_traits<_InputIterator>::difference_type __n = 0; + while (__first != __last) + { + ++__first; + ++__n; + } + return __n; + } + + template + __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_RandomAccessIterator>::difference_type + __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, + random_access_iterator_tag) + { + + + + return __last - __first; + } + + + + template + ptrdiff_t + __distance(std::_List_iterator<_Tp>, + std::_List_iterator<_Tp>, + input_iterator_tag); + + template + ptrdiff_t + __distance(std::_List_const_iterator<_Tp>, + std::_List_const_iterator<_Tp>, + input_iterator_tag); + + + + + template + void + __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; +# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + [[__nodiscard__]] __attribute__((__always_inline__)) + inline constexpr + typename iterator_traits<_InputIterator>::difference_type + distance(_InputIterator __first, _InputIterator __last) + { + + return std::__distance(__first, __last, + std::__iterator_category(__first)); + } + + template + inline constexpr void + __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) + { + + + do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); + while (__n--) + ++__i; + } + + template + inline constexpr void + __advance(_BidirectionalIterator& __i, _Distance __n, + bidirectional_iterator_tag) + { + + + + if (__n > 0) + while (__n--) + ++__i; + else + while (__n++) + --__i; + } + + template + inline constexpr void + __advance(_RandomAccessIterator& __i, _Distance __n, + random_access_iterator_tag) + { + + + + if (__builtin_constant_p(__n) && __n == 1) + ++__i; + else if (__builtin_constant_p(__n) && __n == -1) + --__i; + else + __i += __n; + } + + + + template + void + __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; +# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 + template + __attribute__((__always_inline__)) + inline constexpr void + advance(_InputIterator& __i, _Distance __n) + { + + typename iterator_traits<_InputIterator>::difference_type __d = __n; + std::__advance(__i, __d, std::__iterator_category(__i)); + } + + + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _InputIterator + next(_InputIterator __x, typename + iterator_traits<_InputIterator>::difference_type __n = 1) + { + + + std::advance(__x, __n); + return __x; + } + + template + [[__nodiscard__]] [[__gnu__::__always_inline__]] + inline constexpr _BidirectionalIterator + prev(_BidirectionalIterator __x, typename + iterator_traits<_BidirectionalIterator>::difference_type __n = 1) + { + + + + std::advance(__x, -__n); + return __x; + } + + + + +} +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 +# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 +# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + class __undefined; + + + + template + struct __get_first_arg + { using type = __undefined; }; + + template class _SomeTemplate, typename _Tp, + typename... _Types> + struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> + { using type = _Tp; }; + + + + template + struct __replace_first_arg + { }; + + template class _SomeTemplate, typename _Up, + typename _Tp, typename... _Types> + struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> + { using type = _SomeTemplate<_Up, _Types...>; }; + + + template + struct __ptr_traits_elem : __get_first_arg<_Ptr> + { }; + + + + + + + + template + struct __ptr_traits_elem<_Ptr, __void_t> + { using type = typename _Ptr::element_type; }; + + + template + using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; + + + + + template::value> + struct __ptr_traits_ptr_to + { + using pointer = _Ptr; + using element_type = _Elt; + + + + + + + + static pointer + pointer_to(element_type& __r) + + + + + + { return pointer::pointer_to(__r); } + }; + + + template + struct __ptr_traits_ptr_to<_Ptr, _Elt, true> + { }; + + + template + struct __ptr_traits_ptr_to<_Tp*, _Tp, false> + { + using pointer = _Tp*; + using element_type = _Tp; + + + + + + + static pointer + pointer_to(element_type& __r) noexcept + { return std::addressof(__r); } + }; + + template + struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> + { + private: + template + using __diff_t = typename _Tp::difference_type; + + template + using __rebind = __type_identity>; + + public: + + using pointer = _Ptr; + + + using element_type = _Elt; + + + using difference_type = __detected_or_t; + + + template + using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, + __rebind, _Ptr, _Up>::type; + }; + + + + template + struct __ptr_traits_impl<_Ptr, __undefined> + { }; + + + + + + + + template + struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> + { }; + + + + + + + + template + struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> + { + + typedef _Tp* pointer; + + typedef _Tp element_type; + + typedef ptrdiff_t difference_type; + + template using rebind = _Up*; + }; + + + template + using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; + + template + constexpr _Tp* + __to_address(_Tp* __ptr) noexcept + { + static_assert(!std::is_function<_Tp>::value, "not a function pointer"); + return __ptr; + } + + + template + constexpr typename std::pointer_traits<_Ptr>::element_type* + __to_address(const _Ptr& __ptr) + { return std::__to_address(__ptr.operator->()); } +# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 +# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wdeprecated-declarations" +# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class reverse_iterator + : public iterator::iterator_category, + typename iterator_traits<_Iterator>::value_type, + typename iterator_traits<_Iterator>::difference_type, + typename iterator_traits<_Iterator>::pointer, + typename iterator_traits<_Iterator>::reference> + { + template + friend class reverse_iterator; +# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + protected: + _Iterator current; + + typedef iterator_traits<_Iterator> __traits_type; + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::pointer pointer; + + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + constexpr + reverse_iterator() + noexcept(noexcept(_Iterator())) + : current() + { } + + + + + explicit constexpr + reverse_iterator(iterator_type __x) + noexcept(noexcept(_Iterator(__x))) + : current(__x) + { } + + + + + constexpr + reverse_iterator(const reverse_iterator& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + reverse_iterator& operator=(const reverse_iterator&) = default; + + + + + + + template + + + + constexpr + reverse_iterator(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(_Iterator(__x.current))) + : current(__x.current) + { } + + + template + + + + + constexpr + reverse_iterator& + operator=(const reverse_iterator<_Iter>& __x) + noexcept(noexcept(current = __x.current)) + { + current = __x.current; + return *this; + } + + + + + + [[__nodiscard__]] + constexpr iterator_type + base() const + noexcept(noexcept(_Iterator(current))) + { return current; } +# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + { + _Iterator __tmp = current; + return *--__tmp; + } + + + + + + + [[__nodiscard__]] + constexpr pointer + operator->() const + + + + + { + + + _Iterator __tmp = current; + --__tmp; + return _S_to_pointer(__tmp); + } + + + + + + + constexpr reverse_iterator& + operator++() + { + --current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator++(int) + { + reverse_iterator __tmp = *this; + --current; + return __tmp; + } + + + + + + + constexpr reverse_iterator& + operator--() + { + ++current; + return *this; + } + + + + + + + constexpr reverse_iterator + operator--(int) + { + reverse_iterator __tmp = *this; + ++current; + return __tmp; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator+(difference_type __n) const + { return reverse_iterator(current - __n); } + + + + + + + + constexpr reverse_iterator& + operator+=(difference_type __n) + { + current -= __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reverse_iterator + operator-(difference_type __n) const + { return reverse_iterator(current + __n); } + + + + + + + + constexpr reverse_iterator& + operator-=(difference_type __n) + { + current += __n; + return *this; + } + + + + + + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + { return *(*this + __n); } +# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + private: + template + static constexpr _Tp* + _S_to_pointer(_Tp* __p) + { return __p; } + + template + static constexpr pointer + _S_to_pointer(_Tp __t) + { return __t.operator->(); } + }; +# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y.base() < __x.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_Iterator>& __x, + const reverse_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() == __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() > __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() != __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() < __y.base(); } + + template + inline constexpr bool + operator<=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() >= __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + { return __x.base() <= __y.base(); } +# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr auto + operator-(const reverse_iterator<_IteratorL>& __x, + const reverse_iterator<_IteratorR>& __y) + -> decltype(__y.base() - __x.base()) + { return __y.base() - __x.base(); } + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + operator+(typename reverse_iterator<_Iterator>::difference_type __n, + const reverse_iterator<_Iterator>& __x) + { return reverse_iterator<_Iterator>(__x.base() - __n); } + + + + template + inline constexpr reverse_iterator<_Iterator> + __make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } + + + + + + + + template + [[__nodiscard__]] + inline constexpr reverse_iterator<_Iterator> + make_reverse_iterator(_Iterator __i) + { return reverse_iterator<_Iterator>(__i); } +# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) + { return __make_reverse_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + : __is_move_iterator<_Iterator> + { }; + + template + + auto + __miter_base(reverse_iterator<_Iterator> __it) + -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) + { return __make_reverse_iterator(__miter_base(__it.base())); } +# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class back_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + back_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + back_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_back(__value); + return *this; + } + + + back_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_back(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + back_insert_iterator& + operator*() + { return *this; } + + + + back_insert_iterator& + operator++() + { return *this; } + + + + back_insert_iterator + operator++(int) + { return *this; } + }; +# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline back_insert_iterator<_Container> + back_inserter(_Container& __x) + { return back_insert_iterator<_Container>(__x); } +# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class front_insert_iterator + : public iterator + { + protected: + _Container* container; + + public: + + typedef _Container container_type; + + + + + + explicit + front_insert_iterator(_Container& __x) + : container(std::__addressof(__x)) { } +# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + front_insert_iterator& + operator=(const typename _Container::value_type& __value) + { + container->push_front(__value); + return *this; + } + + + front_insert_iterator& + operator=(typename _Container::value_type&& __value) + { + container->push_front(std::move(__value)); + return *this; + } + + + + [[__nodiscard__]] + front_insert_iterator& + operator*() + { return *this; } + + + + front_insert_iterator& + operator++() + { return *this; } + + + + front_insert_iterator + operator++(int) + { return *this; } + }; +# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline front_insert_iterator<_Container> + front_inserter(_Container& __x) + { return front_insert_iterator<_Container>(__x); } +# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class insert_iterator + : public iterator + { + + + + typedef typename _Container::iterator _Iter; + + protected: + _Container* container; + _Iter iter; + + public: + + typedef _Container container_type; +# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator(_Container& __x, _Iter __i) + : container(std::__addressof(__x)), iter(__i) {} +# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + insert_iterator& + operator=(const typename _Container::value_type& __value) + { + iter = container->insert(iter, __value); + ++iter; + return *this; + } + + + insert_iterator& + operator=(typename _Container::value_type&& __value) + { + iter = container->insert(iter, std::move(__value)); + ++iter; + return *this; + } + + + + [[__nodiscard__]] + insert_iterator& + operator*() + { return *this; } + + + + insert_iterator& + operator++() + { return *this; } + + + + insert_iterator& + operator++(int) + { return *this; } + }; + +#pragma GCC diagnostic pop +# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline insert_iterator<_Container> + inserter(_Container& __x, typename _Container::iterator __i) + { return insert_iterator<_Container>(__x, __i); } + + + + + +} + +namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) +{ +# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class __normal_iterator + { + protected: + _Iterator _M_current; + + typedef std::iterator_traits<_Iterator> __traits_type; + + + template + using __convertible_from + = std::__enable_if_t::value>; + + + public: + typedef _Iterator iterator_type; + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + typedef typename __traits_type::reference reference; + typedef typename __traits_type::pointer pointer; + + + + + + constexpr __normal_iterator() noexcept + : _M_current(_Iterator()) { } + + explicit + __normal_iterator(const _Iterator& __i) noexcept + : _M_current(__i) { } + + + + template> + + __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) + noexcept +# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + : _M_current(__i.base()) { } + + + + reference + operator*() const noexcept + { return *_M_current; } + + + pointer + operator->() const noexcept + { return _M_current; } + + + __normal_iterator& + operator++() noexcept + { + ++_M_current; + return *this; + } + + + __normal_iterator + operator++(int) noexcept + { return __normal_iterator(_M_current++); } + + + + __normal_iterator& + operator--() noexcept + { + --_M_current; + return *this; + } + + + __normal_iterator + operator--(int) noexcept + { return __normal_iterator(_M_current--); } + + + + reference + operator[](difference_type __n) const noexcept + { return _M_current[__n]; } + + + __normal_iterator& + operator+=(difference_type __n) noexcept + { _M_current += __n; return *this; } + + + __normal_iterator + operator+(difference_type __n) const noexcept + { return __normal_iterator(_M_current + __n); } + + + __normal_iterator& + operator-=(difference_type __n) noexcept + { _M_current -= __n; return *this; } + + + __normal_iterator + operator-(difference_type __n) const noexcept + { return __normal_iterator(_M_current - __n); } + + + const _Iterator& + base() const noexcept + { return _M_current; } + }; +# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator==(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() == __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() != __rhs.base(); } + + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() < __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() > __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() <= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + template + [[__nodiscard__]] + inline bool + operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() >= __rhs.base(); } + + + + + + + template + + + [[__nodiscard__]] + inline auto + operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, + const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept + -> decltype(__lhs.base() - __rhs.base()) + + + + + + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline typename __normal_iterator<_Iterator, _Container>::difference_type + operator-(const __normal_iterator<_Iterator, _Container>& __lhs, + const __normal_iterator<_Iterator, _Container>& __rhs) + noexcept + { return __lhs.base() - __rhs.base(); } + + template + [[__nodiscard__]] + inline __normal_iterator<_Iterator, _Container> + operator+(typename __normal_iterator<_Iterator, _Container>::difference_type + __n, const __normal_iterator<_Iterator, _Container>& __i) + noexcept + { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } + + +} + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + template + + _Iterator + __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it.base(); } + + + + + + + template + constexpr auto + __to_address(const __gnu_cxx::__normal_iterator<_Iterator, + _Container>& __it) noexcept + -> decltype(std::__to_address(__it.base())) + { return std::__to_address(__it.base()); } +# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + namespace __detail + { +# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + } +# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + class move_iterator + + + + { + _Iterator _M_current; + + using __traits_type = iterator_traits<_Iterator>; + + using __base_ref = typename __traits_type::reference; + + + template + friend class move_iterator; +# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + public: + using iterator_type = _Iterator; +# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + typedef typename __traits_type::iterator_category iterator_category; + typedef typename __traits_type::value_type value_type; + typedef typename __traits_type::difference_type difference_type; + + typedef _Iterator pointer; + + + using reference + = __conditional_t::value, + typename remove_reference<__base_ref>::type&&, + __base_ref>; + + + constexpr + move_iterator() + : _M_current() { } + + explicit constexpr + move_iterator(iterator_type __i) + : _M_current(std::move(__i)) { } + + template + + + + constexpr + move_iterator(const move_iterator<_Iter>& __i) + : _M_current(__i._M_current) { } + + template + + + + + constexpr + move_iterator& operator=(const move_iterator<_Iter>& __i) + { + _M_current = __i._M_current; + return *this; + } + + + [[__nodiscard__]] + constexpr iterator_type + base() const + { return _M_current; } +# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + [[__nodiscard__]] + constexpr reference + operator*() const + + + + { return static_cast(*_M_current); } + + + [[__nodiscard__]] + constexpr pointer + operator->() const + { return _M_current; } + + constexpr move_iterator& + operator++() + { + ++_M_current; + return *this; + } + + constexpr move_iterator + operator++(int) + { + move_iterator __tmp = *this; + ++_M_current; + return __tmp; + } + + + + + + + + constexpr move_iterator& + operator--() + { + --_M_current; + return *this; + } + + constexpr move_iterator + operator--(int) + { + move_iterator __tmp = *this; + --_M_current; + return __tmp; + } + + [[__nodiscard__]] + constexpr move_iterator + operator+(difference_type __n) const + { return move_iterator(_M_current + __n); } + + constexpr move_iterator& + operator+=(difference_type __n) + { + _M_current += __n; + return *this; + } + + [[__nodiscard__]] + constexpr move_iterator + operator-(difference_type __n) const + { return move_iterator(_M_current - __n); } + + constexpr move_iterator& + operator-=(difference_type __n) + { + _M_current -= __n; + return *this; + } + + [[__nodiscard__]] + constexpr reference + operator[](difference_type __n) const + + + + { return std::move(_M_current[__n]); } +# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + }; + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() == __y.base(); } +# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + { return !(__x == __y); } + + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + + + + { return !(__x < __y); } + + + + + template + [[__nodiscard__]] + inline constexpr bool + operator==(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() == __y.base(); } +# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + [[__nodiscard__]] + inline constexpr bool + operator!=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x == __y); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __x.base() < __y.base(); } + + template + [[__nodiscard__]] + inline constexpr bool + operator<=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__y < __x); } + + template + [[__nodiscard__]] + inline constexpr bool + operator>(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return __y < __x; } + + template + [[__nodiscard__]] + inline constexpr bool + operator>=(const move_iterator<_Iterator>& __x, + const move_iterator<_Iterator>& __y) + { return !(__x < __y); } + + + + template + [[__nodiscard__]] + inline constexpr auto + operator-(const move_iterator<_IteratorL>& __x, + const move_iterator<_IteratorR>& __y) + -> decltype(__x.base() - __y.base()) + { return __x.base() - __y.base(); } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + operator+(typename move_iterator<_Iterator>::difference_type __n, + const move_iterator<_Iterator>& __x) + { return __x + __n; } + + template + [[__nodiscard__]] + inline constexpr move_iterator<_Iterator> + make_move_iterator(_Iterator __i) + { return move_iterator<_Iterator>(std::move(__i)); } + + template::value_type>::value, + _Iterator, move_iterator<_Iterator>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Iterator __i) + { return _ReturnType(__i); } + + + + template::value, + const _Tp*, move_iterator<_Tp*>>> + inline constexpr _ReturnType + __make_move_if_noexcept_iterator(_Tp* __i) + { return _ReturnType(__i); } +# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + + auto + __niter_base(move_iterator<_Iterator> __it) + -> decltype(make_move_iterator(__niter_base(__it.base()))) + { return make_move_iterator(__niter_base(__it.base())); } + + template + struct __is_move_iterator > + { + enum { __value = 1 }; + typedef __true_type __type; + }; + + template + + auto + __miter_base(move_iterator<_Iterator> __it) + -> decltype(__miter_base(__it.base())) + { return __miter_base(__it.base()); } +# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 + template + using __iter_key_t = remove_const_t< + typename iterator_traits<_InputIterator>::value_type::first_type>; + + template + using __iter_val_t + = typename iterator_traits<_InputIterator>::value_type::second_type; + + template + struct pair; + + template + using __iter_to_alloc_t + = pair, __iter_val_t<_InputIterator>>; + + + +} +# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 +# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 +namespace std +{ + namespace __debug { } +} + + + + +namespace __gnu_debug +{ + using namespace std::__debug; + + template + struct _Safe_iterator; +} +# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 +# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 +namespace __gnu_cxx +{ +namespace __ops +{ + struct _Iter_less_iter + { + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 < *__it2; } + }; + + constexpr + inline _Iter_less_iter + __iter_less_iter() + { return _Iter_less_iter(); } + + struct _Iter_less_val + { + + constexpr _Iter_less_val() = default; + + + + + + explicit + _Iter_less_val(_Iter_less_iter) { } + + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it < __val; } + }; + + + inline _Iter_less_val + __iter_less_val() + { return _Iter_less_val(); } + + + inline _Iter_less_val + __iter_comp_val(_Iter_less_iter) + { return _Iter_less_val(); } + + struct _Val_less_iter + { + + constexpr _Val_less_iter() = default; + + + + + + explicit + _Val_less_iter(_Iter_less_iter) { } + + template + + bool + operator()(_Value& __val, _Iterator __it) const + { return __val < *__it; } + }; + + + inline _Val_less_iter + __val_less_iter() + { return _Val_less_iter(); } + + + inline _Val_less_iter + __val_comp_iter(_Iter_less_iter) + { return _Val_less_iter(); } + + struct _Iter_equal_to_iter + { + template + + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) const + { return *__it1 == *__it2; } + }; + + + inline _Iter_equal_to_iter + __iter_equal_to_iter() + { return _Iter_equal_to_iter(); } + + struct _Iter_equal_to_val + { + template + + bool + operator()(_Iterator __it, _Value& __val) const + { return *__it == __val; } + }; + + + inline _Iter_equal_to_val + __iter_equal_to_val() + { return _Iter_equal_to_val(); } + + + inline _Iter_equal_to_val + __iter_comp_val(_Iter_equal_to_iter) + { return _Iter_equal_to_val(); } + + template + struct _Iter_comp_iter + { + _Compare _M_comp; + + explicit constexpr + _Iter_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + template + constexpr + bool + operator()(_Iterator1 __it1, _Iterator2 __it2) + { return bool(_M_comp(*__it1, *__it2)); } + }; + + template + constexpr + inline _Iter_comp_iter<_Compare> + __iter_comp_iter(_Compare __comp) + { return _Iter_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_comp_val + { + _Compare _M_comp; + + + explicit + _Iter_comp_val(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Iterator __it, _Value& __val) + { return bool(_M_comp(*__it, __val)); } + }; + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Compare __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + + inline _Iter_comp_val<_Compare> + __iter_comp_val(_Iter_comp_iter<_Compare> __comp) + { return _Iter_comp_val<_Compare>(std::move(__comp)); } + + template + struct _Val_comp_iter + { + _Compare _M_comp; + + + explicit + _Val_comp_iter(_Compare __comp) + : _M_comp(std::move(__comp)) + { } + + + explicit + _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) + : _M_comp(__comp._M_comp) + { } + + + + explicit + _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) + : _M_comp(std::move(__comp._M_comp)) + { } + + + template + + bool + operator()(_Value& __val, _Iterator __it) + { return bool(_M_comp(__val, *__it)); } + }; + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Compare __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + + inline _Val_comp_iter<_Compare> + __val_comp_iter(_Iter_comp_iter<_Compare> __comp) + { return _Val_comp_iter<_Compare>(std::move(__comp)); } + + template + struct _Iter_equals_val + { + _Value& _M_value; + + + explicit + _Iter_equals_val(_Value& __value) + : _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return *__it == _M_value; } + }; + + template + + inline _Iter_equals_val<_Value> + __iter_equals_val(_Value& __val) + { return _Iter_equals_val<_Value>(__val); } + + template + struct _Iter_equals_iter + { + _Iterator1 _M_it1; + + + explicit + _Iter_equals_iter(_Iterator1 __it1) + : _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return *__it2 == *_M_it1; } + }; + + template + + inline _Iter_equals_iter<_Iterator> + __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) + { return _Iter_equals_iter<_Iterator>(__it); } + + template + struct _Iter_pred + { + _Predicate _M_pred; + + + explicit + _Iter_pred(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_pred<_Predicate> + __pred_iter(_Predicate __pred) + { return _Iter_pred<_Predicate>(std::move(__pred)); } + + template + struct _Iter_comp_to_val + { + _Compare _M_comp; + _Value& _M_value; + + + _Iter_comp_to_val(_Compare __comp, _Value& __value) + : _M_comp(std::move(__comp)), _M_value(__value) + { } + + template + + bool + operator()(_Iterator __it) + { return bool(_M_comp(*__it, _M_value)); } + }; + + template + _Iter_comp_to_val<_Compare, _Value> + + __iter_comp_val(_Compare __comp, _Value &__val) + { + return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); + } + + template + struct _Iter_comp_to_iter + { + _Compare _M_comp; + _Iterator1 _M_it1; + + + _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) + : _M_comp(std::move(__comp)), _M_it1(__it1) + { } + + template + + bool + operator()(_Iterator2 __it2) + { return bool(_M_comp(*__it2, *_M_it1)); } + }; + + template + + inline _Iter_comp_to_iter<_Compare, _Iterator> + __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) + { + return _Iter_comp_to_iter<_Compare, _Iterator>( + std::move(__comp._M_comp), __it); + } + + template + struct _Iter_negate + { + _Predicate _M_pred; + + + explicit + _Iter_negate(_Predicate __pred) + : _M_pred(std::move(__pred)) + { } + + template + + bool + operator()(_Iterator __it) + { return !bool(_M_pred(*__it)); } + }; + + template + + inline _Iter_negate<_Predicate> + __negate(_Iter_pred<_Predicate> __pred) + { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } + +} +} +# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 +# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ +# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 + template + constexpr _Tp + __rotl(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); + else + return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); + } + + template + constexpr _Tp + __rotr(_Tp __x, int __s) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if constexpr ((_Nd & (_Nd - 1)) == 0) + { + + + constexpr unsigned __uNd = _Nd; + const unsigned __r = __s; + return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); + } + const int __r = __s % _Nd; + if (__r == 0) + return __x; + else if (__r > 0) + return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); + else + return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); + } + + template + constexpr int + __countl_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + { + constexpr int __diff = _Nd_u - _Nd; + return __builtin_clz(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ul) + { + constexpr int __diff = _Nd_ul - _Nd; + return __builtin_clzl(__x) - __diff; + } + else if constexpr (_Nd <= _Nd_ull) + { + constexpr int __diff = _Nd_ull - _Nd; + return __builtin_clzll(__x) - __diff; + } + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + unsigned long long __high = __x >> _Nd_ull; + if (__high != 0) + { + constexpr int __diff = (2 * _Nd_ull) - _Nd; + return __builtin_clzll(__high) - __diff; + } + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + return (_Nd - _Nd_ull) + __builtin_clzll(__low); + } + } + + template + constexpr int + __countl_one(_Tp __x) noexcept + { + return std::__countl_zero<_Tp>((_Tp)~__x); + } + + template + constexpr int + __countr_zero(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + if (__x == 0) + return _Nd; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_ctz(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_ctzl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_ctzll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + if (__low != 0) + return __builtin_ctzll(__low); + unsigned long long __high = __x >> _Nd_ull; + return __builtin_ctzll(__high) + _Nd_ull; + } + } + + template + constexpr int + __countr_one(_Tp __x) noexcept + { + return std::__countr_zero((_Tp)~__x); + } + + template + constexpr int + __popcount(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + + constexpr auto _Nd_ull = __int_traits::__digits; + constexpr auto _Nd_ul = __int_traits::__digits; + constexpr auto _Nd_u = __int_traits::__digits; + + if constexpr (_Nd <= _Nd_u) + return __builtin_popcount(__x); + else if constexpr (_Nd <= _Nd_ul) + return __builtin_popcountl(__x); + else if constexpr (_Nd <= _Nd_ull) + return __builtin_popcountll(__x); + else + { + static_assert(_Nd <= (2 * _Nd_ull), + "Maximum supported integer size is 128-bit"); + + constexpr auto __max_ull = __int_traits::__max; + unsigned long long __low = __x & __max_ull; + unsigned long long __high = __x >> _Nd_ull; + return __builtin_popcountll(__low) + __builtin_popcountll(__high); + } + } + + template + constexpr bool + __has_single_bit(_Tp __x) noexcept + { return std::__popcount(__x) == 1; } + + template + constexpr _Tp + __bit_ceil(_Tp __x) noexcept + { + using __gnu_cxx::__int_traits; + constexpr auto _Nd = __int_traits<_Tp>::__digits; + if (__x == 0 || __x == 1) + return 1; + auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); + + + + + if (!std::__is_constant_evaluated()) + { + do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); + } + + using __promoted_type = decltype(__x << 1); + if constexpr (!is_same<__promoted_type, _Tp>::value) + { + + + + + + const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; + __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; + } + return (_Tp)1u << __shift_exponent; + } + + template + constexpr _Tp + __bit_floor(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + if (__x == 0) + return 0; + return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); + } + + template + constexpr int + __bit_width(_Tp __x) noexcept + { + constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; + return _Nd - std::__countl_zero(__x); + } +# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 +} +# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 + + + + + +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + template + constexpr + inline int + __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) + { + + static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); +# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); + } +# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) + { +# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + swap(*__a, *__b); + + } +# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + _ForwardIterator2 + swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + std::iter_swap(__first1, __first2); + return __first2; + } +# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b) + { + + + + if (__b < __a) + return __b; + return __a; + } +# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b) + { + + + + if (__a < __b) + return __b; + return __a; + } +# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + min(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__b, __a)) + return __b; + return __a; + } +# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + constexpr + inline const _Tp& + max(const _Tp& __a, const _Tp& __b, _Compare __comp) + { + + if (__comp(__a, __b)) + return __b; + return __a; + } + + + + template + + inline _Iterator + __niter_base(_Iterator __it) + noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) + { return __it; } + + template + _Ite + __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, + std::random_access_iterator_tag>&); + + + + + template + + inline _From + __niter_wrap(_From __from, _To __res) + { return __from + (__res - std::__niter_base(__from)); } + + + template + + inline _Iterator + __niter_wrap(const _Iterator&, _Iterator __res) + { return __res; } + + + + + + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = *__first; + return __result; + } + }; + + + template + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + for (; __first != __last; ++__result, (void)++__first) + *__result = std::move(*__first); + return __result; + } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = *__first; + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = *__from; } + }; + + + template<> + struct __copy_move + { + template + + static _OI + __copy_m(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::difference_type _Distance; + for(_Distance __n = __last - __first; __n > 0; --__n) + { + *__result = std::move(*__first); + ++__first; + ++__result; + } + return __result; + } + + template + static void + __assign_one(_Tp* __to, _Up* __from) + { *__to = std::move(*__from); } + }; + + + template + struct __copy_move<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_m(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result, __first); + return __result + _Num; + } + }; + + + + template + struct _Deque_iterator; + + struct _Bit_iterator; + + + + + + + template + struct char_traits; + + template + class istreambuf_iterator; + + template + class ostreambuf_iterator; + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(_CharT*, _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type + __copy_move_a2(const _CharT*, const _CharT*, + ostreambuf_iterator<_CharT, char_traits<_CharT> >); + + template + typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, + _CharT*>::__type + __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_move_a2( + istreambuf_iterator<_CharT, char_traits<_CharT> >, + istreambuf_iterator<_CharT, char_traits<_CharT> >, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>); + + + template + + inline _OI + __copy_move_a2(_II __first, _II __last, _OI __result) + { + typedef typename iterator_traits<_II>::iterator_category _Category; + + + + + + return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, + _Category>::__copy_m(__first, __last, __result); + } + + template + _OI + __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_a1(_II __first, _II __last, _OI __result) + { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } + + template + + inline _OI + __copy_move_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_a1<_IsMove>(std::__niter_base(__first), + std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); + + template + + _OutputIterator + __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, + bool) + { + if (__n > 0) + { + while (true) + { + *__result = *__first; + ++__result; + if (--__n > 0) + ++__first; + else + break; + } + } + return __result; + } + + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, _CharT*>::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, + _Size, _CharT*, bool); + + template + typename __gnu_cxx::__enable_if< + __is_char<_CharT>::__value, + std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type + __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, + std::_Deque_iterator<_CharT, _CharT&, _CharT*>, + bool); +# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + copy(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a<__is_move_iterator<_II>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + move(_II __first, _II __last, _OI __result) + { + + + + + ; + + return std::__copy_move_a(std::__miter_base(__first), + std::__miter_base(__last), __result); + } + + + + + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = *--__last; + return __result; + } + }; + + + template + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + while (__first != __last) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = *--__last; + return __result; + } + }; + + + template<> + struct __copy_move_backward + { + template + + static _BI2 + __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) + { + typename iterator_traits<_BI1>::difference_type + __n = __last - __first; + for (; __n > 0; --__n) + *--__result = std::move(*--__last); + return __result; + } + }; + + + template + struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> + { + template + + static _Up* + __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) + { + const ptrdiff_t _Num = __last - __first; + if (__builtin_expect(_Num > 1, true)) + __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); + else if (_Num == 1) + std::__copy_move<_IsMove, false, random_access_iterator_tag>:: + __assign_one(__result - 1, __first); + return __result - _Num; + } + }; + + template + + inline _BI2 + __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) + { + typedef typename iterator_traits<_BI1>::iterator_category _Category; + + + + + + return std::__copy_move_backward<_IsMove, + __memcpyable<_BI2, _BI1>::__value, + _Category>::__copy_move_b(__first, + __last, + __result); + } + + template + + inline _BI2 + __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) + { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } + + template + _OI + __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _OI); + + template + std::_Deque_iterator<_OTp, _OTp&, _OTp*> + __copy_move_backward_a1( + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_ITp, _IRef, _IPtr>, + std::_Deque_iterator<_OTp, _OTp&, _OTp*>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, + std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type + __copy_move_backward_a1(_II, _II, + std::_Deque_iterator<_Tp, _Tp&, _Tp*>); + + template + + inline _OI + __copy_move_backward_a(_II __first, _II __last, _OI __result) + { + return std::__niter_wrap(__result, + std::__copy_move_backward_a1<_IsMove> + (std::__niter_base(__first), std::__niter_base(__last), + std::__niter_base(__result))); + } + + template + _OI + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + _OI); + + template + __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __copy_move_backward_a(_II, _II, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); + + template + ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> + __copy_move_backward_a( + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, + const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); +# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> + (std::__miter_base(__first), std::__miter_base(__last), __result); + } +# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _BI2 + move_backward(_BI1 __first, _BI1 __last, _BI2 __result) + { + + + + + + ; + + return std::__copy_move_backward_a(std::__miter_base(__first), + std::__miter_base(__last), + __result); + } + + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + for (; __first != __last; ++__first) + *__first = __value; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type + __fill_a1(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __first != __last; ++__first) + *__first = __tmp; + } + + + template + + inline typename + __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type + __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) + { + const _Tp __tmp = __c; +# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + if (const size_t __len = __last - __first) + __builtin_memset(__first, static_cast(__tmp), __len); + } + + template + + inline void + __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, + ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, + const _Tp& __value) + { std::__fill_a1(__first.base(), __last.base(), __value); } + + template + void + __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, + const _VTp&); + + + void + __fill_a1(std::_Bit_iterator, std::_Bit_iterator, + const bool&); + + template + + inline void + __fill_a(_FIte __first, _FIte __last, const _Tp& __value) + { std::__fill_a1(__first, __last, __value); } + + template + void + __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, + const _Tp&); +# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline void + fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) + { + + + + ; + + std::__fill_a(__first, __last, __value); + } + + + inline constexpr int + __size_to_integer(int __n) { return __n; } + inline constexpr unsigned + __size_to_integer(unsigned __n) { return __n; } + inline constexpr long + __size_to_integer(long __n) { return __n; } + inline constexpr unsigned long + __size_to_integer(unsigned long __n) { return __n; } + inline constexpr long long + __size_to_integer(long long __n) { return __n; } + inline constexpr unsigned long long + __size_to_integer(unsigned long long __n) { return __n; } +# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + inline constexpr long long + __size_to_integer(float __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(double __n) { return (long long)__n; } + inline constexpr long long + __size_to_integer(long double __n) { return (long long)__n; } + + + + + + template + + inline typename + __gnu_cxx::__enable_if::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + for (; __n > 0; --__n, (void) ++__first) + *__first = __value; + return __first; + } + + template + + inline typename + __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type + __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) + { + const _Tp __tmp = __value; + for (; __n > 0; --__n, (void) ++__first) + *__first = __tmp; + return __first; + } + + template + ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> + __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, + _Size __n, const _Tp& __value, + std::input_iterator_tag); + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::output_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::input_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + return __fill_n_a1(__first, __n, __value); + } + + template + + inline _OutputIterator + __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, + std::random_access_iterator_tag) + { + + static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); + + if (__n <= 0) + return __first; + + ; + + std::__fill_a(__first, __first + __n, __value); + return __first + __n; + } +# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _OI + fill_n(_OI __first, _Size __n, const _Tp& __value) + { + + + + return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, + std::__iterator_category(__first)); + } + + template + struct __equal + { + template + + static bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + for (; __first1 != __last1; ++__first1, (void) ++__first2) + if (!(*__first1 == *__first2)) + return false; + return true; + } + }; + + template<> + struct __equal + { + template + + static bool + equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) + { + if (const size_t __len = (__last1 - __first1)) + return !std::__memcmp(__first1, __first2, __len); + return true; + } + }; + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, + std::_Deque_iterator<_Tp, _Ref, _Ptr>, + _II); + + template + bool + __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + typename __gnu_cxx::__enable_if< + __is_random_access_iter<_II>::__value, bool>::__type + __equal_aux1(_II, _II, + std::_Deque_iterator<_Tp, _Ref, _Ptr>); + + template + + inline bool + __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + const bool __simple = ((__is_integer<_ValueType1>::__value + || __is_pointer<_ValueType1>::__value) + && __memcmpable<_II1, _II2>::__value); + return std::__equal<__simple>::equal(__first1, __last1, __first2); + } + + template + + inline bool + __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) + { + return std::__equal_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2)); + } + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + _II2); + + template + bool + __equal_aux(_II1, _II1, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + bool + __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); + + template + struct __lc_rai + { + template + + static _II1 + __newlast1(_II1, _II1 __last1, _II2, _II2) + { return __last1; } + + template + + static bool + __cnd2(_II __first, _II __last) + { return __first != __last; } + }; + + template<> + struct __lc_rai + { + template + + static _RAI1 + __newlast1(_RAI1 __first1, _RAI1 __last1, + _RAI2 __first2, _RAI2 __last2) + { + const typename iterator_traits<_RAI1>::difference_type + __diff1 = __last1 - __first1; + const typename iterator_traits<_RAI2>::difference_type + __diff2 = __last2 - __first2; + return __diff2 < __diff1 ? __first1 + __diff2 : __last1; + } + + template + static bool + __cnd2(_RAI, _RAI) + { return true; } + }; + + template + + bool + __lexicographical_compare_impl(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, + _Compare __comp) + { + typedef typename iterator_traits<_II1>::iterator_category _Category1; + typedef typename iterator_traits<_II2>::iterator_category _Category2; + typedef std::__lc_rai<_Category1, _Category2> __rai_type; + + __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); + for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); + ++__first1, (void)++__first2) + { + if (__comp(__first1, __first2)) + return true; + if (__comp(__first2, __first1)) + return false; + } + return __first1 == __last1 && __first2 != __last2; + } + + template + struct __lexicographical_compare + { + template + + static bool + __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using __gnu_cxx::__ops::__iter_less_iter; + return std::__lexicographical_compare_impl(__first1, __last1, + __first2, __last2, + __iter_less_iter()); + } + + template + + static int + __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + while (__first1 != __last1) + { + if (__first2 == __last2) + return +1; + if (*__first1 < *__first2) + return -1; + if (*__first2 < *__first1) + return +1; + ++__first1; + ++__first2; + } + return int(__first2 == __last2) - 1; + } + }; + + template<> + struct __lexicographical_compare + { + template + + static bool + __lc(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { return __3way(__first1, __last1, __first2, __last2) < 0; } + + template + + static ptrdiff_t + __3way(const _Tp* __first1, const _Tp* __last1, + const _Up* __first2, const _Up* __last2) + { + const size_t __len1 = __last1 - __first1; + const size_t __len2 = __last2 - __first2; + if (const size_t __len = std::min(__len1, __len2)) + if (int __result = std::__memcmp(__first1, __first2, __len)) + return __result; + return ptrdiff_t(__len1 - __len2); + } + }; + + template + + inline bool + __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + typedef typename iterator_traits<_II1>::value_type _ValueType1; + typedef typename iterator_traits<_II2>::value_type _ValueType2; + const bool __simple = + (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value + && __is_pointer<_II1>::__value + && __is_pointer<_II2>::__value + + + + + + + + ); + + return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, + __first2, __last2); + } + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + _Tp2*, _Tp2*); + + template + bool + __lexicographical_compare_aux1(_Tp1*, _Tp1*, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + bool + __lexicographical_compare_aux1( + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, + std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); + + template + + inline bool + __lexicographical_compare_aux(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { + return std::__lexicographical_compare_aux1(std::__niter_base(__first1), + std::__niter_base(__last1), + std::__niter_base(__first2), + std::__niter_base(__last2)); + } + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + _II2, _II2); + + template + bool + __lexicographical_compare_aux( + _II1, _II1, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + bool + __lexicographical_compare_aux( + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, + const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); + + template + + _ForwardIterator + __lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val, _Compare __comp) + { + typedef typename iterator_traits<_ForwardIterator>::difference_type + _DistanceType; + + _DistanceType __len = std::distance(__first, __last); + + while (__len > 0) + { + _DistanceType __half = __len >> 1; + _ForwardIterator __middle = __first; + std::advance(__middle, __half); + if (__comp(__middle, __val)) + { + __first = __middle; + ++__first; + __len = __len - __half - 1; + } + else + __len = __half; + } + return __first; + } +# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline _ForwardIterator + lower_bound(_ForwardIterator __first, _ForwardIterator __last, + const _Tp& __val) + { + + + + + ; + + return std::__lower_bound(__first, __last, __val, + __gnu_cxx::__ops::__iter_less_val()); + } + + + + template + inline constexpr _Tp + __lg(_Tp __n) + { + + return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; +# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + } +# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2) + { + + + + + + + ; + + return std::__equal_aux(__first1, __last1, __first2); + } +# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return true; + } + + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!(*__first1 == *__first2)) + return false; + return __first1 == __last1 && __first2 == __last2; + } + + + template + + inline bool + __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, + _BinaryPredicate __binary_pred) + { + using _RATag = random_access_iterator_tag; + using _Cat1 = typename iterator_traits<_II1>::iterator_category; + using _Cat2 = typename iterator_traits<_II2>::iterator_category; + using _RAIters = __and_, is_same<_Cat2, _RATag>>; + if (_RAIters()) + { + auto __d1 = std::distance(__first1, __last1); + auto __d2 = std::distance(__first2, __last2); + if (__d1 != __d2) + return false; + return std::equal(__first1, __last1, __first2, + __binary_pred); + } + + for (; __first1 != __last1 && __first2 != __last2; + ++__first1, (void)++__first2) + if (!bool(__binary_pred(*__first1, *__first2))) + return false; + return __first1 == __last1 && __first2 == __last2; + } +# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) + { + + + + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2); + } +# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + equal(_IIter1 __first1, _IIter1 __last1, + _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__equal4(__first1, __last1, __first2, __last2, + __binary_pred); + } +# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2) + { +# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + ; + ; + + return std::__lexicographical_compare_aux(__first1, __last1, + __first2, __last2); + } +# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + lexicographical_compare(_II1 __first1, _II1 __last1, + _II2 __first2, _II2 __last2, _Compare __comp) + { + + + + ; + ; + + return std::__lexicographical_compare_impl + (__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__comp)); + } +# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2) + { + + + + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _BinaryPredicate __binary_pred) + { + + + + ; + + return std::__mismatch(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + template + + pair<_InputIterator1, _InputIterator2> + __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + while (__first1 != __last1 && __first2 != __last2 + && __binary_pred(__first1, __first2)) + { + ++__first1; + ++__first2; + } + return pair<_InputIterator1, _InputIterator2>(__first1, __first2); + } +# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2) + { + + + + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } +# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline pair<_InputIterator1, _InputIterator2> + mismatch(_InputIterator1 __first1, _InputIterator1 __last1, + _InputIterator2 __first2, _InputIterator2 __last2, + _BinaryPredicate __binary_pred) + { + + + + ; + ; + + return std::__mismatch(__first1, __last1, __first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); + } + + + + + + template + + inline _InputIterator + __find_if(_InputIterator __first, _InputIterator __last, + _Predicate __pred, input_iterator_tag) + { + while (__first != __last && !__pred(__first)) + ++__first; + return __first; + } + + + template + + _RandomAccessIterator + __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, + _Predicate __pred, random_access_iterator_tag) + { + typename iterator_traits<_RandomAccessIterator>::difference_type + __trip_count = (__last - __first) >> 2; + + for (; __trip_count > 0; --__trip_count) + { + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + + if (__pred(__first)) + return __first; + ++__first; + } + + switch (__last - __first) + { + case 3: + if (__pred(__first)) + return __first; + ++__first; + + case 2: + if (__pred(__first)) + return __first; + ++__first; + + case 1: + if (__pred(__first)) + return __first; + ++__first; + + case 0: + default: + return __last; + } + } + + template + + inline _Iterator + __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) + { + return __find_if(__first, __last, __pred, + std::__iterator_category(__first)); + } + + template + + typename iterator_traits<_InputIterator>::difference_type + __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) + { + typename iterator_traits<_InputIterator>::difference_type __n = 0; + for (; __first != __last; ++__first) + if (__pred(__first)) + ++__n; + return __n; + } + + template + + _ForwardIterator + __remove_if(_ForwardIterator __first, _ForwardIterator __last, + _Predicate __pred) + { + __first = std::__find_if(__first, __last, __pred); + if (__first == __last) + return __first; + _ForwardIterator __result = __first; + ++__first; + for (; __first != __last; ++__first) + if (!__pred(__first)) + { + *__result = std::move(*__first); + ++__result; + } + return __result; + } + + + template + + bool + __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2, _BinaryPredicate __pred) + { + + + for (; __first1 != __last1; ++__first1, (void)++__first2) + if (!__pred(__first1, __first2)) + break; + + if (__first1 == __last1) + return true; + + + + _ForwardIterator2 __last2 = __first2; + std::advance(__last2, std::distance(__first1, __last1)); + for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) + { + if (__scan != std::__find_if(__first1, __scan, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) + continue; + + auto __matches + = std::__count_if(__first2, __last2, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); + if (0 == __matches || + std::__count_if(__scan, __last1, + __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) + != __matches) + return false; + } + return true; + } +# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 + template + + inline bool + is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, + _ForwardIterator2 __first2) + { + + + + + + + ; + + return std::__is_permutation(__first1, __last1, __first2, + __gnu_cxx::__ops::__iter_equal_to_iter()); + } + + + +} +# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/specfun.h" 2 3 +# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 1 3 +# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 +# 158 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 +namespace std __attribute__ ((__visibility__ ("default"))) +{ + + + + + + + + enum float_round_style + { + round_indeterminate = -1, + round_toward_zero = 0, + round_to_nearest = 1, + round_toward_infinity = 2, + round_toward_neg_infinity = 3 + }; + + + + + + + + enum float_denorm_style + { + + denorm_indeterminate = -1, + + denorm_absent = 0, + + denorm_present = 1 + }; +# 202 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 + struct __numeric_limits_base + { + + + static constexpr bool is_specialized = false; + + + + + static constexpr int digits = 0; + + + static constexpr int digits10 = 0; + + + + + static constexpr int max_digits10 = 0; + + + + static constexpr bool is_signed = false; + + + static constexpr bool is_integer = false; + + + + + static constexpr bool is_exact = false; + + + + static constexpr int radix = 0; + + + + static constexpr int min_exponent = 0; + + + + static constexpr int min_exponent10 = 0; + + + + + static constexpr int max_exponent = 0; + + + + static constexpr int max_exponent10 = 0; + + + static constexpr bool has_infinity = false; + + + + static constexpr bool has_quiet_NaN = false; + + + + static constexpr bool has_signaling_NaN = false; + + + static constexpr float_denorm_style has_denorm = denorm_absent; + + + + static constexpr bool has_denorm_loss = false; + + + + static constexpr bool is_iec559 = false; + + + + + static constexpr bool is_bounded = false; +# 288 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 + static constexpr bool is_modulo = false; + + + static constexpr bool traps = false; + + + static constexpr bool tinyness_before = false; + + + + + static constexpr float_round_style round_style = + round_toward_zero; + }; +# 311 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 + template + struct numeric_limits : public __numeric_limits_base + { + + + static constexpr _Tp + min() noexcept { return _Tp(); } + + + static constexpr _Tp + max() noexcept { return _Tp(); } + + + + + static constexpr _Tp + lowest() noexcept { return _Tp(); } + + + + + static constexpr _Tp + epsilon() noexcept { return _Tp(); } + + + static constexpr _Tp + round_error() noexcept { return _Tp(); } + + + static constexpr _Tp + infinity() noexcept { return _Tp(); } + + + + static constexpr _Tp + quiet_NaN() noexcept { return _Tp(); } + + + + static constexpr _Tp + signaling_NaN() noexcept { return _Tp(); } + + + + + static constexpr _Tp + denorm_min() noexcept { return _Tp(); } + }; + + + + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; + + template + struct numeric_limits + : public numeric_limits<_Tp> { }; +# 383 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr bool + min() noexcept { return false; } + + static constexpr bool + max() noexcept { return true; } + + + static constexpr bool + lowest() noexcept { return min(); } + + static constexpr int digits = 1; + static constexpr int digits10 = 0; + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr bool + epsilon() noexcept { return false; } + + static constexpr bool + round_error() noexcept { return false; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr bool + infinity() noexcept { return false; } + + static constexpr bool + quiet_NaN() noexcept { return false; } + + static constexpr bool + signaling_NaN() noexcept { return false; } + + static constexpr bool + denorm_min() noexcept { return false; } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + + + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char + min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } + + static constexpr char + max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } + + + static constexpr char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((char)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char + epsilon() noexcept { return 0; } + + static constexpr char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr + char infinity() noexcept { return char(); } + + static constexpr char + quiet_NaN() noexcept { return char(); } + + static constexpr char + signaling_NaN() noexcept { return char(); } + + static constexpr char + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr signed char + min() noexcept { return -127 - 1; } + + static constexpr signed char + max() noexcept { return 127; } + + + static constexpr signed char + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr signed char + epsilon() noexcept { return 0; } + + static constexpr signed char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr signed char + infinity() noexcept { return static_cast(0); } + + static constexpr signed char + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr signed char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr signed char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned char + min() noexcept { return 0; } + + static constexpr unsigned char + max() noexcept { return 127 * 2U + 1; } + + + static constexpr unsigned char + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned char + epsilon() noexcept { return 0; } + + static constexpr unsigned char + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned char + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned char + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned char + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr wchar_t + min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } + + static constexpr wchar_t + max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } + + + static constexpr wchar_t + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = ((wchar_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr wchar_t + epsilon() noexcept { return 0; } + + static constexpr wchar_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr wchar_t + infinity() noexcept { return wchar_t(); } + + static constexpr wchar_t + quiet_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + signaling_NaN() noexcept { return wchar_t(); } + + static constexpr wchar_t + denorm_min() noexcept { return wchar_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 796 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char16_t + min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } + + static constexpr char16_t + max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } + + static constexpr char16_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char16_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char16_t + epsilon() noexcept { return 0; } + + static constexpr char16_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char16_t + infinity() noexcept { return char16_t(); } + + static constexpr char16_t + quiet_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + signaling_NaN() noexcept { return char16_t(); } + + static constexpr char16_t + denorm_min() noexcept { return char16_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr char32_t + min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } + + static constexpr char32_t + max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } + + static constexpr char32_t + lowest() noexcept { return min(); } + + static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); + static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); + static constexpr int max_digits10 = 0; + static constexpr bool is_signed = ((char32_t)(-1) < 0); + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr char32_t + epsilon() noexcept { return 0; } + + static constexpr char32_t + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr char32_t + infinity() noexcept { return char32_t(); } + + static constexpr char32_t + quiet_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + signaling_NaN() noexcept { return char32_t(); } + + static constexpr char32_t + denorm_min() noexcept { return char32_t(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = !is_signed; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style = round_toward_zero; + }; + + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr short + min() noexcept { return -32767 - 1; } + + static constexpr short + max() noexcept { return 32767; } + + + static constexpr short + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); + static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr short + epsilon() noexcept { return 0; } + + static constexpr short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr short + infinity() noexcept { return short(); } + + static constexpr short + quiet_NaN() noexcept { return short(); } + + static constexpr short + signaling_NaN() noexcept { return short(); } + + static constexpr short + denorm_min() noexcept { return short(); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned short + min() noexcept { return 0; } + + static constexpr unsigned short + max() noexcept { return 32767 * 2U + 1; } + + + static constexpr unsigned short + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned short + epsilon() noexcept { return 0; } + + static constexpr unsigned short + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned short + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned short + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned short + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr int + min() noexcept { return -2147483647 - 1; } + + static constexpr int + max() noexcept { return 2147483647; } + + + static constexpr int + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); + static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr int + epsilon() noexcept { return 0; } + + static constexpr int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr int + infinity() noexcept { return static_cast(0); } + + static constexpr int + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr int + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr int + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned int + min() noexcept { return 0; } + + static constexpr unsigned int + max() noexcept { return 2147483647 * 2U + 1; } + + + static constexpr unsigned int + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned int + epsilon() noexcept { return 0; } + + static constexpr unsigned int + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned int + infinity() noexcept { return static_cast(0); } + + static constexpr unsigned int + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned int + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long + min() noexcept { return -9223372036854775807L - 1; } + + static constexpr long + max() noexcept { return 9223372036854775807L; } + + + static constexpr long + lowest() noexcept { return min(); } + + + static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); + static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long + epsilon() noexcept { return 0; } + + static constexpr long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long + infinity() noexcept { return static_cast(0); } + + static constexpr long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long + signaling_NaN() noexcept { return static_cast(0); } + + static constexpr long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long + min() noexcept { return 0; } + + static constexpr unsigned long + max() noexcept { return 9223372036854775807L * 2UL + 1; } + + + static constexpr unsigned long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long + epsilon() noexcept { return 0; } + + static constexpr unsigned long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr long long + min() noexcept { return -9223372036854775807LL - 1; } + + static constexpr long long + max() noexcept { return 9223372036854775807LL; } + + + static constexpr long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(long long) * 8 - ((long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = true; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr long long + epsilon() noexcept { return 0; } + + static constexpr long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr long long + infinity() noexcept { return static_cast(0); } + + static constexpr long long + quiet_NaN() noexcept { return static_cast(0); } + + static constexpr long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr long long + denorm_min() noexcept { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = false; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; + + + template<> + struct numeric_limits + { + static constexpr bool is_specialized = true; + + static constexpr unsigned long long + min() noexcept { return 0; } + + static constexpr unsigned long long + max() noexcept { return 9223372036854775807LL * 2ULL + 1; } + + + static constexpr unsigned long long + lowest() noexcept { return min(); } + + + static constexpr int digits + = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); + static constexpr int digits10 + = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); + + static constexpr int max_digits10 = 0; + + static constexpr bool is_signed = false; + static constexpr bool is_integer = true; + static constexpr bool is_exact = true; + static constexpr int radix = 2; + + static constexpr unsigned long long + epsilon() noexcept { return 0; } + + static constexpr unsigned long long + round_error() noexcept { return 0; } + + static constexpr int min_exponent = 0; + static constexpr int min_exponent10 = 0; + static constexpr int max_exponent = 0; + static constexpr int max_exponent10 = 0; + + static constexpr bool has_infinity = false; + static constexpr bool has_quiet_NaN = false; + static constexpr bool has_signaling_NaN = false; + static constexpr float_denorm_style has_denorm + = denorm_absent; + static constexpr bool has_denorm_loss = false; + + static constexpr unsigned long long + infinity() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + quiet_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + signaling_NaN() noexcept + { return static_cast(0); } + + static constexpr unsigned long long + denorm_min() noexcept + { return static_cast(0); } + + static constexpr bool is_iec559 = false; + static constexpr bool is_bounded = true; + static constexpr bool is_modulo = true; + + static constexpr bool traps = true; + static constexpr bool tinyness_before = false; + static constexpr float_round_style round_style + = round_toward_zero; + }; +# 1658 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 + __extension__ template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = t \ No newline at end of file diff --git a/src/core/application.cpp b/src/core/application.cpp index ba33ccf..f8ce592 100644 --- a/src/core/application.cpp +++ b/src/core/application.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 22:10:52 by maldavid #+# #+# */ -/* Updated: 2023/11/20 07:29:12 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 13:32:18 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/xmake.lua b/xmake.lua new file mode 100644 index 0000000..f75c1bc --- /dev/null +++ b/xmake.lua @@ -0,0 +1,74 @@ +-------------------------------------------------------------------------------- +-- -- +-- ::: :::::::: -- +-- xmake.lua :+: :+: :+: -- +-- +:+ +:+ +:+ -- +-- By: maldavid +#+ +:+ +#+ -- +-- +#+#+#+#+#+ +#+ -- +-- Created: 2023/12/07 15:21:38 by kbz_8 #+# #+# -- +-- Updated: 2023/12/07 15:21:38 by kbz_8 ### ########.fr -- +-- -- +-------------------------------------------------------------------------------- + +-- Global settings + +add_requires("libsdl", "vulkan-headers") + +add_rules("mode.debug", "mode.release") +set_languages("cxx17") + +set_objectdir("objs/xmake/$(os)_$(arch)") +set_targetdir("./") + +set_optimize("fastest") + +-- Options + +option("images_optimized") + set_default(true) + add_defines("IMAGE_OPTIMIZED") +option_end() + +option("force_integrated_gpu") + set_default(false) + add_defines("FORCE_INTEGRATED_GPU") +option_end() + +option("graphics_memory_dump") + set_default(false) + add_defines("GRAPHICS_MEMORY_DUMP") +option_end() + +-- Targets + +target("mlx") + set_default(true) + set_license("MIT") + set_kind("shared") + add_options("images_optimized") + add_options("force_integrated_gpu") + add_options("graphics_memory_dump") + add_includedirs("includes", "src", "third_party") + + add_defines("MLX_BUILD") + + add_files("src/**.cpp") + + add_packages("libsdl", "vulkan-headers") + + if is_mode("debug") then + add_defines("DEBUG") + end +target_end() -- optional but I think the code is cleaner with this -- optional but I think the code is cleaner with this + +target("Test") + set_default(false) + set_kind("binary") + set_targetdir("test") + + add_deps("mlx") + + add_files("test/main.c") + + add_packages("libsdl") +target_end() From df860a5a64e9981d34ffff7ce88e66e9dff8c507 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 8 Dec 2023 14:12:41 +0100 Subject: [PATCH 02/14] removing garbage files --- .gitignore | 1 + .../__cpp_application.cpp-33125923.cpp.tmp | 27194 ----------- .../core/__cpp_bridge.cpp-eb644723.cpp.tmp | 6401 --- .../__cpp_inputs.cpp-7e53d83f.cpp.tmp | 38940 ---------------- .../__cpp_text_pipeline.cpp-cd270745.cpp.tmp | 37918 --------------- ...cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp | 34132 -------------- .../__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp | 18406 -------- 7 files changed, 1 insertion(+), 162991 deletions(-) delete mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_application.cpp-33125923.cpp.tmp delete mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_bridge.cpp-eb644723.cpp.tmp delete mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/platform/__cpp_inputs.cpp-7e53d83f.cpp.tmp delete mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/__cpp_text_pipeline.cpp-cd270745.cpp.tmp delete mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/descriptors/__cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp delete mode 100644 objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/swapchain/__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp diff --git a/.gitignore b/.gitignore index c620972..6bc8987 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,7 @@ *.out *.dll *.json +*.tmp .xmake/ .cache/ build/ diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_application.cpp-33125923.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_application.cpp-33125923.cpp.tmp deleted file mode 100644 index 99c2c57..0000000 --- a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_application.cpp-33125923.cpp.tmp +++ /dev/null @@ -1,27194 +0,0 @@ -# 1 "src/core/application.cpp" -# 1 "" 1 -# 1 "" 3 -# 433 "" 3 -# 1 "" 1 -# 1 "" 2 -# 1 "src/core/application.cpp" 2 -# 13 "src/core/application.cpp" -# 1 "src/core/application.h" 1 -# 16 "src/core/application.h" -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 1 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 -# 31 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 -# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - typedef long unsigned int size_t; - typedef long int ptrdiff_t; - - - typedef decltype(nullptr) nullptr_t; - - -#pragma GCC visibility push(default) - - - extern "C++" __attribute__ ((__noreturn__, __always_inline__)) - inline void __terminate() noexcept - { - void terminate() noexcept __attribute__ ((__noreturn__)); - terminate(); - } -#pragma GCC visibility pop -} -# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -namespace __gnu_cxx -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ -#pragma GCC visibility push(default) - - - - - constexpr inline bool - __is_constant_evaluated() noexcept - { - - - - - - return __builtin_is_constant_evaluated(); - - - - } -#pragma GCC visibility pop -} -# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 3 -# 1 "/usr/include/features.h" 1 3 4 -# 394 "/usr/include/features.h" 3 4 -# 1 "/usr/include/features-time64.h" 1 3 4 -# 20 "/usr/include/features-time64.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 21 "/usr/include/features-time64.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 22 "/usr/include/features-time64.h" 2 3 4 -# 395 "/usr/include/features.h" 2 3 4 -# 481 "/usr/include/features.h" 3 4 -# 1 "/usr/include/stdc-predef.h" 1 3 4 -# 482 "/usr/include/features.h" 2 3 4 -# 503 "/usr/include/features.h" 3 4 -# 1 "/usr/include/sys/cdefs.h" 1 3 4 -# 576 "/usr/include/sys/cdefs.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 577 "/usr/include/sys/cdefs.h" 2 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 578 "/usr/include/sys/cdefs.h" 2 3 4 -# 504 "/usr/include/features.h" 2 3 4 -# 527 "/usr/include/features.h" 3 4 -# 1 "/usr/include/gnu/stubs.h" 1 3 4 -# 10 "/usr/include/gnu/stubs.h" 3 4 -# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 -# 11 "/usr/include/gnu/stubs.h" 2 3 4 -# 528 "/usr/include/features.h" 2 3 4 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3 -# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 -# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 2 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - void - __throw_bad_exception(void) __attribute__((__noreturn__)); - - - void - __throw_bad_alloc(void) __attribute__((__noreturn__)); - - void - __throw_bad_array_new_length(void) __attribute__((__noreturn__)); - - - void - __throw_bad_cast(void) __attribute__((__noreturn__)); - - void - __throw_bad_typeid(void) __attribute__((__noreturn__)); - - - void - __throw_logic_error(const char*) __attribute__((__noreturn__)); - - void - __throw_domain_error(const char*) __attribute__((__noreturn__)); - - void - __throw_invalid_argument(const char*) __attribute__((__noreturn__)); - - void - __throw_length_error(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) - __attribute__((__format__(__gnu_printf__, 1, 2))); - - void - __throw_runtime_error(const char*) __attribute__((__noreturn__)); - - void - __throw_range_error(const char*) __attribute__((__noreturn__)); - - void - __throw_overflow_error(const char*) __attribute__((__noreturn__)); - - void - __throw_underflow_error(const char*) __attribute__((__noreturn__)); - - - void - __throw_ios_failure(const char*) __attribute__((__noreturn__)); - - void - __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); - - - void - __throw_system_error(int) __attribute__((__noreturn__)); - - - void - __throw_future_error(int) __attribute__((__noreturn__)); - - - void - __throw_bad_function_call() __attribute__((__noreturn__)); -# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -} -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - struct __true_type { }; - struct __false_type { }; - - template - struct __truth_type - { typedef __false_type __type; }; - - template<> - struct __truth_type - { typedef __true_type __type; }; - - - - template - struct __traitor - { - enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; - typedef typename __truth_type<__value>::__type __type; - }; - - - template - struct __are_same - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __are_same<_Tp, _Tp> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_void - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_void - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_integer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; - }; -# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template - struct __is_pointer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __is_pointer<_Tp*> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_arithmetic - : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > - { }; - - - - - template - struct __is_scalar - : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > - { }; - - - - - template - struct __is_char - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_byte - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - enum class byte : unsigned char; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template struct iterator_traits; - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = __is_trivially_copyable(_Tp) }; - }; - - - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = 0 }; - }; - - - template - struct __memcpyable - { - enum { __value = 0 }; - }; - - template - struct __memcpyable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcpyable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - template - struct __memcmpable - { - enum { __value = 0 }; - }; - - - template - struct __memcmpable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - - template::__value - - > - struct __is_memcmp_ordered - { - static const bool __value = _Tp(-1) > _Tp(1); - }; - - template - struct __is_memcmp_ordered<_Tp, false> - { - static const bool __value = false; - }; - - - template - struct __is_memcmp_ordered_with - { - static const bool __value = __is_memcmp_ordered<_Tp>::__value - && __is_memcmp_ordered<_Up>::__value; - }; - - template - struct __is_memcmp_ordered_with<_Tp, _Up, false> - { - static const bool __value = false; - }; -# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_memcmp_ordered_with - { static constexpr bool __value = true; }; - - template - struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> - { static constexpr bool __value = false; }; - - template - struct __is_memcmp_ordered_with - { static constexpr bool __value = false; }; - - - - - - template - struct __is_move_iterator - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - template - - inline _Iterator - __miter_base(_Iterator __it) - { return __it; } - - -} -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - - - - -extern "C++" { - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct __enable_if - { }; - - template - struct __enable_if - { typedef _Tp __type; }; - - - - template - struct __conditional_type - { typedef _Iftrue __type; }; - - template - struct __conditional_type - { typedef _Iffalse __type; }; - - - - template - struct __add_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned short __type; }; - - template<> - struct __add_unsigned - { typedef unsigned int __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long long __type; }; - - - template<> - struct __add_unsigned; - - template<> - struct __add_unsigned; - - - - template - struct __remove_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef short __type; }; - - template<> - struct __remove_unsigned - { typedef int __type; }; - - template<> - struct __remove_unsigned - { typedef long __type; }; - - template<> - struct __remove_unsigned - { typedef long long __type; }; - - - template<> - struct __remove_unsigned; - - template<> - struct __remove_unsigned; - - - - template - constexpr - inline bool - __is_null_pointer(_Type* __ptr) - { return __ptr == 0; } - - template - constexpr - inline bool - __is_null_pointer(_Type) - { return false; } - - - constexpr bool - __is_null_pointer(std::nullptr_t) - { return true; } - - - - - template::__value> - struct __promote - { typedef double __type; }; - - - - - template - struct __promote<_Tp, false> - { }; - - template<> - struct __promote - { typedef long double __type; }; - - template<> - struct __promote - { typedef double __type; }; - - template<> - struct __promote - { typedef float __type; }; -# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - template - using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); - - - - template - using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; - - template - using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; - - template - using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 -} -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - - - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __is_integer_nonstrict - : public std::__is_integer<_Tp> - { - using std::__is_integer<_Tp>::__value; - - - enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; - }; - - template - struct __numeric_traits_integer - { - - static_assert(__is_integer_nonstrict<_Value>::__value, - "invalid specialization"); - - - - - static const bool __is_signed = (_Value)(-1) < 0; - static const int __digits - = __is_integer_nonstrict<_Value>::__width - __is_signed; - - - static const _Value __max = __is_signed - ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) - : ~(_Value)0; - static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; - }; - - template - const _Value __numeric_traits_integer<_Value>::__min; - - template - const _Value __numeric_traits_integer<_Value>::__max; - - template - const bool __numeric_traits_integer<_Value>::__is_signed; - - template - const int __numeric_traits_integer<_Value>::__digits; -# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; - - - - - - - template - using __int_traits = __numeric_traits_integer<_Tp>; -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __numeric_traits_floating - { - - static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); - - - static const bool __is_signed = true; - static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); - static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); - }; - - template - const int __numeric_traits_floating<_Value>::__max_digits10; - - template - const bool __numeric_traits_floating<_Value>::__is_signed; - - template - const int __numeric_traits_floating<_Value>::__digits10; - - template - const int __numeric_traits_floating<_Value>::__max_exponent10; - - - - - - - template - struct __numeric_traits - : public __numeric_traits_integer<_Value> - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; -# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 -} -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - class reference_wrapper; -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } - - }; - - - - - - - - using true_type = integral_constant; - - - using false_type = integral_constant; - - - - template - using __bool_constant = integral_constant; - - - - - - - template - using bool_constant = integral_constant; - - - - - - - template - struct enable_if - { }; - - - template - struct enable_if - { typedef _Tp type; }; - - - template - using __enable_if_t = typename enable_if<_Cond, _Tp>::type; - - template - struct __conditional - { - template - using type = _Tp; - }; - - template<> - struct __conditional - { - template - using type = _Up; - }; - - - template - using __conditional_t - = typename __conditional<_Cond>::template type<_If, _Else>; - - - template - struct __type_identity - { using type = _Type; }; - - template - using __type_identity_t = typename __type_identity<_Tp>::type; - - namespace __detail - { - - template - using __first_t = _Tp; - - - template - auto __or_fn(int) -> __first_t...>; - - template - auto __or_fn(...) -> true_type; - - template - auto __and_fn(int) -> __first_t...>; - - template - auto __and_fn(...) -> false_type; - } - - - - - template - struct __or_ - : decltype(__detail::__or_fn<_Bn...>(0)) - { }; - - template - struct __and_ - : decltype(__detail::__and_fn<_Bn...>(0)) - { }; - - template - struct __not_ - : __bool_constant - { }; - - - - - - template - inline constexpr bool __or_v = __or_<_Bn...>::value; - template - inline constexpr bool __and_v = __and_<_Bn...>::value; - - namespace __detail - { - template - struct __disjunction_impl - { using type = _B1; }; - - template - struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __disjunction_impl::type; }; - - template - struct __conjunction_impl - { using type = _B1; }; - - template - struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __conjunction_impl::type; }; - } - - - - - template - struct conjunction - : __detail::__conjunction_impl::type - { }; - - template<> - struct conjunction<> - : true_type - { }; - - template - struct disjunction - : __detail::__disjunction_impl::type - { }; - - template<> - struct disjunction<> - : false_type - { }; - - template - struct negation - : __not_<_Pp>::type - { }; - - - - - template - inline constexpr bool conjunction_v = conjunction<_Bn...>::value; - - template - inline constexpr bool disjunction_v = disjunction<_Bn...>::value; - - template - inline constexpr bool negation_v = negation<_Pp>::value; - - - - - - template - struct is_reference; - template - struct is_function; - template - struct is_void; - template - struct remove_cv; - template - struct is_const; - - - template - struct __is_array_unknown_bounds; - - - - - template - constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) - { return {}; } - - template - constexpr typename __or_< - is_reference<_NestedType>, - is_function<_NestedType>, - is_void<_NestedType>, - __is_array_unknown_bounds<_NestedType> - >::type __is_complete_or_unbounded(_TypeIdentity) - { return {}; } - - - template - using __remove_cv_t = typename remove_cv<_Tp>::type; - - - - - - template - struct is_void - : public false_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - - template - struct __is_integral_helper - : public false_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; -# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_integral - : public __is_integral_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct __is_floating_point_helper - : public false_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; -# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_floating_point - : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_array - : public false_type { }; - - template - struct is_array<_Tp[_Size]> - : public true_type { }; - - template - struct is_array<_Tp[]> - : public true_type { }; - - template - struct __is_pointer_helper - : public false_type { }; - - template - struct __is_pointer_helper<_Tp*> - : public true_type { }; - - - template - struct is_pointer - : public __is_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_lvalue_reference - : public false_type { }; - - template - struct is_lvalue_reference<_Tp&> - : public true_type { }; - - - template - struct is_rvalue_reference - : public false_type { }; - - template - struct is_rvalue_reference<_Tp&&> - : public true_type { }; - - template - struct __is_member_object_pointer_helper - : public false_type { }; - - template - struct __is_member_object_pointer_helper<_Tp _Cp::*> - : public __not_>::type { }; - - - template - struct is_member_object_pointer - : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct __is_member_function_pointer_helper - : public false_type { }; - - template - struct __is_member_function_pointer_helper<_Tp _Cp::*> - : public is_function<_Tp>::type { }; - - - template - struct is_member_function_pointer - : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_enum - : public integral_constant - { }; - - - template - struct is_union - : public integral_constant - { }; - - - template - struct is_class - : public integral_constant - { }; - - - template - struct is_function - : public __bool_constant::value> { }; - - template - struct is_function<_Tp&> - : public false_type { }; - - template - struct is_function<_Tp&&> - : public false_type { }; - - - - - template - struct is_null_pointer - : public false_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - - - template - struct __is_nullptr_t - : public is_null_pointer<_Tp> - { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); - - - - - template - struct is_reference - : public false_type - { }; - - template - struct is_reference<_Tp&> - : public true_type - { }; - - template - struct is_reference<_Tp&&> - : public true_type - { }; - - - template - struct is_arithmetic - : public __or_, is_floating_point<_Tp>>::type - { }; - - - template - struct is_fundamental - : public __or_, is_void<_Tp>, - is_null_pointer<_Tp>>::type - { }; - - - template - struct is_object - : public __not_<__or_, is_reference<_Tp>, - is_void<_Tp>>>::type - { }; - - template - struct is_member_pointer; - - - template - struct is_scalar - : public __or_, is_enum<_Tp>, is_pointer<_Tp>, - is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type - { }; - - - template - struct is_compound - : public __not_>::type { }; - - - template - struct __is_member_pointer_helper - : public false_type { }; - - template - struct __is_member_pointer_helper<_Tp _Cp::*> - : public true_type { }; - - - - template - struct is_member_pointer - : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct is_same; - - - template - using __is_one_of = __or_...>; - - - __extension__ - template - using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, - signed char, signed short, signed int, signed long, - signed long long -# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - __extension__ - template - using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, - unsigned char, unsigned short, unsigned int, unsigned long, - unsigned long long -# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - template - using __is_standard_integer - = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; - - - template using __void_t = void; - - - - - - template - struct is_const - : public false_type { }; - - template - struct is_const<_Tp const> - : public true_type { }; - - - template - struct is_volatile - : public false_type { }; - - template - struct is_volatile<_Tp volatile> - : public true_type { }; - - - template - struct is_trivial - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copyable - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_standard_layout - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - template - struct - - is_pod - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct - [[__deprecated__]] - is_literal_type - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_empty - : public integral_constant - { }; - - - template - struct is_polymorphic - : public integral_constant - { }; - - - - - - template - struct is_final - : public integral_constant - { }; - - - - template - struct is_abstract - : public integral_constant - { }; - - - template::value> - struct __is_signed_helper - : public false_type { }; - - template - struct __is_signed_helper<_Tp, true> - : public integral_constant - { }; - - - - template - struct is_signed - : public __is_signed_helper<_Tp>::type - { }; - - - template - struct is_unsigned - : public __and_, __not_>>::type - { }; - - - template - _Up - __declval(int); - - template - _Tp - __declval(long); - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)); - - template - struct remove_all_extents; - - - template - struct __is_array_known_bounds - : public false_type - { }; - - template - struct __is_array_known_bounds<_Tp[_Size]> - : public true_type - { }; - - template - struct __is_array_unknown_bounds - : public false_type - { }; - - template - struct __is_array_unknown_bounds<_Tp[]> - : public true_type - { }; -# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - struct __do_is_destructible_impl - { - template().~_Tp())> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_destructible_impl - : public __do_is_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_destructible_safe; - - template - struct __is_destructible_safe<_Tp, false, false> - : public __is_destructible_impl::type>::type - { }; - - template - struct __is_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_destructible - : public __is_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - - struct __do_is_nt_destructible_impl - { - template - static __bool_constant().~_Tp())> - __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_nt_destructible_impl - : public __do_is_nt_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_nt_destructible_safe; - - template - struct __is_nt_destructible_safe<_Tp, false, false> - : public __is_nt_destructible_impl::type>::type - { }; - - template - struct __is_nt_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_nt_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_nothrow_destructible - : public __is_nt_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_constructible_impl - = __bool_constant<__is_constructible(_Tp, _Args...)>; - - - - template - struct is_constructible - : public __is_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_default_constructible - : public __is_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_lvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> - { using type = _Tp&; }; - - template - using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; - - - - template - struct is_copy_constructible - : public __is_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_rvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> - { using type = _Tp&&; }; - - template - using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; - - - - template - struct is_move_constructible - : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_constructible_impl - = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; - - - - template - struct is_nothrow_constructible - : public __is_nothrow_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_default_constructible - : public __is_nothrow_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; - - - - template - struct is_assignable - : public __is_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_copy_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_move_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_assignable_impl - = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; - - - - template - struct is_nothrow_assignable - : public __is_nothrow_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_constructible_impl - = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; - - - - template - struct is_trivially_constructible - : public __is_trivially_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_default_constructible - : public __is_trivially_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - struct __do_is_implicitly_default_constructible_impl - { - template - static void __helper(const _Tp&); - - template - static true_type __test(const _Tp&, - decltype(__helper({}))* = 0); - - static false_type __test(...); - }; - - template - struct __is_implicitly_default_constructible_impl - : public __do_is_implicitly_default_constructible_impl - { - typedef decltype(__test(declval<_Tp>())) type; - }; - - template - struct __is_implicitly_default_constructible_safe - : public __is_implicitly_default_constructible_impl<_Tp>::type - { }; - - template - struct __is_implicitly_default_constructible - : public __and_<__is_constructible_impl<_Tp>, - __is_implicitly_default_constructible_safe<_Tp>>::type - { }; - - - template - struct is_trivially_copy_constructible - : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_constructible - : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_assignable_impl - = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; - - - - template - struct is_trivially_assignable - : public __is_trivially_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copy_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_destructible - : public __and_<__is_destructible_safe<_Tp>, - __bool_constant<__has_trivial_destructor(_Tp)>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - struct has_virtual_destructor - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct alignment_of - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct rank - : public integral_constant { }; - - template - struct rank<_Tp[_Size]> - : public integral_constant::value> { }; - - template - struct rank<_Tp[]> - : public integral_constant::value> { }; - - - template - struct extent - : public integral_constant { }; - - template - struct extent<_Tp[_Size], 0> - : public integral_constant { }; - - template - struct extent<_Tp[_Size], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - template - struct extent<_Tp[], 0> - : public integral_constant { }; - - template - struct extent<_Tp[], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - - - - - template - struct is_same - - : public integral_constant - - - - { }; -# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_base_of - : public integral_constant - { }; - - - template - struct is_convertible - : public __bool_constant<__is_convertible(_From, _To)> - { }; -# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - using __is_array_convertible - = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; -# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_const - { typedef _Tp type; }; - - template - struct remove_const<_Tp const> - { typedef _Tp type; }; - - - template - struct remove_volatile - { typedef _Tp type; }; - - template - struct remove_volatile<_Tp volatile> - { typedef _Tp type; }; - - - - template - struct remove_cv - { using type = __remove_cv(_Tp); }; -# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct add_const - { using type = _Tp const; }; - - - template - struct add_volatile - { using type = _Tp volatile; }; - - - template - struct add_cv - { using type = _Tp const volatile; }; - - - - - - - template - using remove_const_t = typename remove_const<_Tp>::type; - - - template - using remove_volatile_t = typename remove_volatile<_Tp>::type; - - - template - using remove_cv_t = typename remove_cv<_Tp>::type; - - - template - using add_const_t = typename add_const<_Tp>::type; - - - template - using add_volatile_t = typename add_volatile<_Tp>::type; - - - template - using add_cv_t = typename add_cv<_Tp>::type; -# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_reference - { using type = _Tp; }; - - template - struct remove_reference<_Tp&> - { using type = _Tp; }; - - template - struct remove_reference<_Tp&&> - { using type = _Tp; }; - - - - template - struct add_lvalue_reference - { using type = __add_lval_ref_t<_Tp>; }; - - - template - struct add_rvalue_reference - { using type = __add_rval_ref_t<_Tp>; }; - - - - template - using remove_reference_t = typename remove_reference<_Tp>::type; - - - template - using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; - - - template - using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; - - - - - - - - template - struct __cv_selector; - - template - struct __cv_selector<_Unqualified, false, false> - { 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; }; -# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_unsigned_selector; - - template - class __make_unsigned_selector<_Tp, true, false> - { - using __unsigned_type - = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - class __make_unsigned_selector_base - { - protected: - template struct _List { }; - - template - struct _List<_Tp, _Up...> : _List<_Up...> - { static constexpr size_t __size = sizeof(_Tp); }; - - template - struct __select; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, true> - { using __type = _Uint; }; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, false> - : __select<_Sz, _List<_UInts...>> - { }; - }; - - - template - class __make_unsigned_selector<_Tp, false, true> - : __make_unsigned_selector_base - { - - using _UInts = _List; - - using __unsigned_type = typename __select::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - - - - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; -# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - - - - - - template - struct make_unsigned - { typedef typename __make_unsigned_selector<_Tp>::__type type; }; - - - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - - - - - template - struct __make_signed - { typedef _Tp __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed short __type; }; - - template<> - struct __make_signed - { typedef signed int __type; }; - - template<> - struct __make_signed - { typedef signed long __type; }; - - template<> - struct __make_signed - { typedef signed long long __type; }; -# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_signed_selector; - - template - class __make_signed_selector<_Tp, true, false> - { - using __signed_type - = typename __make_signed<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; - }; - - - template - class __make_signed_selector<_Tp, false, true> - { - typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; - - public: - typedef typename __make_signed_selector<__unsigned_type>::__type __type; - }; - - - - - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; -# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - - - - - - template - struct make_signed - { typedef typename __make_signed_selector<_Tp>::__type type; }; - - - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - - - - template - using make_signed_t = typename make_signed<_Tp>::type; - - - template - using make_unsigned_t = typename make_unsigned<_Tp>::type; - - - - - - template - struct remove_extent - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[_Size]> - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[]> - { typedef _Tp type; }; - - - template - struct remove_all_extents - { typedef _Tp type; }; - - template - struct remove_all_extents<_Tp[_Size]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - template - struct remove_all_extents<_Tp[]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - - - template - using remove_extent_t = typename remove_extent<_Tp>::type; - - - template - using remove_all_extents_t = typename remove_all_extents<_Tp>::type; - - - - - template - struct __remove_pointer_helper - { typedef _Tp type; }; - - template - struct __remove_pointer_helper<_Tp, _Up*> - { typedef _Up type; }; - - - template - struct remove_pointer - : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> - { }; - - template - struct __add_pointer_helper - { using type = _Tp; }; - - template - struct __add_pointer_helper<_Tp, __void_t<_Tp*>> - { using type = _Tp*; }; - - - template - struct add_pointer - : public __add_pointer_helper<_Tp> - { }; - - template - struct add_pointer<_Tp&> - { using type = _Tp*; }; - - template - struct add_pointer<_Tp&&> - { using type = _Tp*; }; - - - - template - using remove_pointer_t = typename remove_pointer<_Tp>::type; - - - template - using add_pointer_t = typename add_pointer<_Tp>::type; - - - template - struct __aligned_storage_msa - { - union __type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__)) { } __align; - }; - }; -# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::__type)> - struct - - aligned_storage - { - union type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__((_Align)))) { } __align; - }; - }; - - template - struct __strictest_alignment - { - static const size_t _S_alignment = 0; - static const size_t _S_size = 0; - }; - - template - struct __strictest_alignment<_Tp, _Types...> - { - static const size_t _S_alignment = - alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment - ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; - static const size_t _S_size = - sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size - ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -#pragma GCC diagnostic pop - - - - - - template - struct __decay_selector - : __conditional_t::value, - remove_cv<_Up>, - add_pointer<_Up>> - { }; - - template - struct __decay_selector<_Up[_Nm]> - { using type = _Up*; }; - - template - struct __decay_selector<_Up[]> - { using type = _Up*; }; - - - - - template - struct decay - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&> - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&&> - { using type = typename __decay_selector<_Tp>::type; }; - - - - - template - struct __strip_reference_wrapper - { - typedef _Tp __type; - }; - - template - struct __strip_reference_wrapper > - { - typedef _Tp& __type; - }; - - - template - using __decay_t = typename decay<_Tp>::type; - - template - using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; - - - - - - template - using _Require = __enable_if_t<__and_<_Cond...>::value>; - - - template - using __remove_cvref_t - = typename remove_cv::type>::type; - - - - - template - struct conditional - { typedef _Iftrue type; }; - - - template - struct conditional - { typedef _Iffalse type; }; - - - template - struct common_type; -# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __success_type - { typedef _Tp type; }; - - struct __failure_type - { }; - - struct __do_common_type_impl - { - template - using __cond_t - = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); - - - - template - static __success_type<__decay_t<__cond_t<_Tp, _Up>>> - _S_test(int); -# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - static __failure_type - _S_test_2(...); - - template - static decltype(_S_test_2<_Tp, _Up>(0)) - _S_test(...); - }; - - - template<> - struct common_type<> - { }; - - - template - struct common_type<_Tp0> - : public common_type<_Tp0, _Tp0> - { }; - - - template, typename _Dp2 = __decay_t<_Tp2>> - struct __common_type_impl - { - - - using type = common_type<_Dp1, _Dp2>; - }; - - template - struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> - : private __do_common_type_impl - { - - - using type = decltype(_S_test<_Tp1, _Tp2>(0)); - }; - - - template - struct common_type<_Tp1, _Tp2> - : public __common_type_impl<_Tp1, _Tp2>::type - { }; - - template - struct __common_type_pack - { }; - - template - struct __common_type_fold; - - - template - struct common_type<_Tp1, _Tp2, _Rp...> - : public __common_type_fold, - __common_type_pack<_Rp...>> - { }; - - - - - template - struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, - __void_t> - : public common_type - { }; - - - template - struct __common_type_fold<_CTp, _Rp, void> - { }; - - template::value> - struct __underlying_type_impl - { - using type = __underlying_type(_Tp); - }; - - template - struct __underlying_type_impl<_Tp, false> - { }; - - - - template - struct underlying_type - : public __underlying_type_impl<_Tp> - { }; - - - template - struct __declval_protector - { - static const bool __stop = false; - }; - - - - - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)) - { - static_assert(__declval_protector<_Tp>::__stop, - "declval() must not be used!"); - return __declval<_Tp>(0); - } - - - template - struct result_of; - - - - - - - struct __invoke_memfun_ref { }; - struct __invoke_memfun_deref { }; - struct __invoke_memobj_ref { }; - struct __invoke_memobj_deref { }; - struct __invoke_other { }; - - - template - struct __result_of_success : __success_type<_Tp> - { using __invoke_type = _Tag; }; - - - struct __result_of_memfun_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_ref - : private __result_of_memfun_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memfun_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_deref - : private __result_of_memfun_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memobj_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>() - ), __invoke_memobj_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_ref - : private __result_of_memobj_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - - struct __result_of_memobj_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>() - ), __invoke_memobj_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_deref - : private __result_of_memobj_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - template - struct __result_of_memobj; - - template - struct __result_of_memobj<_Res _Class::*, _Arg> - { - typedef __remove_cvref_t<_Arg> _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t<__or_, - is_base_of<_Class, _Argval>>::value, - __result_of_memobj_ref<_MemPtr, _Arg>, - __result_of_memobj_deref<_MemPtr, _Arg> - >::type type; - }; - - template - struct __result_of_memfun; - - template - struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> - { - typedef typename remove_reference<_Arg>::type _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t::value, - __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, - __result_of_memfun_deref<_MemPtr, _Arg, _Args...> - >::type type; - }; - - - - - - - template> - struct __inv_unwrap - { - using type = _Tp; - }; - - template - struct __inv_unwrap<_Tp, reference_wrapper<_Up>> - { - using type = _Up&; - }; - - template - struct __result_of_impl - { - typedef __failure_type type; - }; - - template - struct __result_of_impl - : public __result_of_memobj<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type> - { }; - - template - struct __result_of_impl - : public __result_of_memfun<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type, _Args...> - { }; - - - struct __result_of_other_impl - { - template - static __result_of_success()(std::declval<_Args>()...) - ), __invoke_other> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_impl - : private __result_of_other_impl - { - typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; - }; - - - template - struct __invoke_result - : public __result_of_impl< - is_member_object_pointer< - typename remove_reference<_Functor>::type - >::value, - is_member_function_pointer< - typename remove_reference<_Functor>::type - >::value, - _Functor, _ArgTypes... - >::type - { }; - - - template - struct result_of<_Functor(_ArgTypes...)> - : public __invoke_result<_Functor, _ArgTypes...> - { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template::__type)> - using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; - - template - using aligned_union_t = typename aligned_union<_Len, _Types...>::type; -#pragma GCC diagnostic pop - - - template - using decay_t = typename decay<_Tp>::type; - - - template - using enable_if_t = typename enable_if<_Cond, _Tp>::type; - - - template - using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; - - - template - using common_type_t = typename common_type<_Tp...>::type; - - - template - using underlying_type_t = typename underlying_type<_Tp>::type; - - - template - using result_of_t = typename result_of<_Tp>::type; - - - - - - template using void_t = void; -# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template class _Op, typename... _Args> - struct __detector - { - using type = _Default; - using __is_detected = false_type; - }; - - - template class _Op, - typename... _Args> - struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> - { - using type = _Op<_Args...>; - using __is_detected = true_type; - }; - - template class _Op, - typename... _Args> - using __detected_or = __detector<_Default, void, _Op, _Args...>; - - - - template class _Op, - typename... _Args> - using __detected_or_t - = typename __detected_or<_Default, _Op, _Args...>::type; -# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __is_swappable; - - template - struct __is_nothrow_swappable; - - template - struct __is_tuple_like_impl : false_type - { }; - - - template - struct __is_tuple_like - : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type - { }; - - - template - - inline - _Require<__not_<__is_tuple_like<_Tp>>, - is_move_constructible<_Tp>, - is_move_assignable<_Tp>> - swap(_Tp&, _Tp&) - noexcept(__and_, - is_nothrow_move_assignable<_Tp>>::value); - - template - - inline - __enable_if_t<__is_swappable<_Tp>::value> - swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(__is_nothrow_swappable<_Tp>::value); - - - namespace __swappable_details { - using std::swap; - - struct __do_is_swappable_impl - { - template(), std::declval<_Tp&>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_impl - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_nothrow_swappable_impl - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_swappable - : public __is_swappable_impl<_Tp>::type - { }; - - template - struct __is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { }; - - - - - - - - template - struct is_swappable - : public __is_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_v = - is_swappable<_Tp>::value; - - - template - inline constexpr bool is_nothrow_swappable_v = - is_nothrow_swappable<_Tp>::value; - - - - namespace __swappable_with_details { - using std::swap; - - struct __do_is_swappable_with_impl - { - template(), std::declval<_Up>())), - typename - = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_with_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) - && - noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_with_impl - : public __swappable_with_details::__do_is_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - template - struct __is_nothrow_swappable_with_impl - : public __swappable_with_details::__do_is_nothrow_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - - - template - struct is_swappable_with - : public __is_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable_with - : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_with_v = - is_swappable_with<_Tp, _Up>::value; - - - template - inline constexpr bool is_nothrow_swappable_with_v = - is_nothrow_swappable_with<_Tp, _Up>::value; -# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, typename = void> - struct __is_invocable_impl - : false_type - { - using __nothrow_conv = false_type; - }; - - - template - struct __is_invocable_impl<_Result, _Ret, - true, - __void_t> - : true_type - { - using __nothrow_conv = true_type; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - - template - struct __is_invocable_impl<_Result, _Ret, - false, - __void_t> - { - private: - - using _Res_t = typename _Result::type; - - - - static _Res_t _S_get() noexcept; - - - template - static void _S_conv(__type_identity_t<_Tp>) noexcept; - - - template(_S_get())), - typename = decltype(_S_conv<_Tp>(_S_get())), - - - - bool _Dangle = false - - > - static __bool_constant<_Nothrow && !_Dangle> - _S_test(int); - - template - static false_type - _S_test(...); - - public: - - using type = decltype(_S_test<_Ret, true>(1)); - - - using __nothrow_conv = decltype(_S_test<_Ret>(1)); - }; -#pragma GCC diagnostic pop - - template - struct __is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { }; - - template - constexpr bool __call_is_nt(__invoke_memfun_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept((std::declval<_Up>().*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memfun_deref) - { - return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept(std::declval<_Up>().*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_deref) - { - return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_other) - { - return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); - } - - template - struct __call_is_nothrow - : __bool_constant< - std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) - > - { }; - - template - using __call_is_nothrow_ - = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; - - - template - struct __is_nothrow_invocable - : __and_<__is_invocable<_Fn, _Args...>, - __call_is_nothrow_<_Fn, _Args...>>::type - { }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - struct __nonesuchbase {}; - struct __nonesuch : private __nonesuchbase { - ~__nonesuch() = delete; - __nonesuch(__nonesuch const&) = delete; - void operator=(__nonesuch const&) = delete; - }; -#pragma GCC diagnostic pop - - - - - - - template - struct invoke_result - : public __invoke_result<_Functor, _ArgTypes...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), - "_Functor must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; - - - template - struct is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - struct is_invocable_r - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_invocable - : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - - - - template - using __is_nt_invocable_impl - = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; - - - - template - struct is_nothrow_invocable_r - : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; -# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -template - inline constexpr bool is_void_v = is_void<_Tp>::value; -template - inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; -template - inline constexpr bool is_integral_v = is_integral<_Tp>::value; -template - inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; - -template - inline constexpr bool is_array_v = false; -template - inline constexpr bool is_array_v<_Tp[]> = true; -template - inline constexpr bool is_array_v<_Tp[_Num]> = true; - -template - inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; -template - inline constexpr bool is_lvalue_reference_v = false; -template - inline constexpr bool is_lvalue_reference_v<_Tp&> = true; -template - inline constexpr bool is_rvalue_reference_v = false; -template - inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; -template - inline constexpr bool is_member_object_pointer_v = - is_member_object_pointer<_Tp>::value; -template - inline constexpr bool is_member_function_pointer_v = - is_member_function_pointer<_Tp>::value; -template - inline constexpr bool is_enum_v = __is_enum(_Tp); -template - inline constexpr bool is_union_v = __is_union(_Tp); -template - inline constexpr bool is_class_v = __is_class(_Tp); -template - inline constexpr bool is_function_v = is_function<_Tp>::value; -template - inline constexpr bool is_reference_v = false; -template - inline constexpr bool is_reference_v<_Tp&> = true; -template - inline constexpr bool is_reference_v<_Tp&&> = true; -template - inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; -template - inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; -template - inline constexpr bool is_object_v = is_object<_Tp>::value; -template - inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; -template - inline constexpr bool is_compound_v = is_compound<_Tp>::value; -template - inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; -template - inline constexpr bool is_const_v = false; -template - inline constexpr bool is_const_v = true; -template - inline constexpr bool is_volatile_v = false; -template - inline constexpr bool is_volatile_v = true; - -template - inline constexpr bool is_trivial_v = __is_trivial(_Tp); -template - inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); -template - inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); -template - - inline constexpr bool is_pod_v = __is_pod(_Tp); -template - [[__deprecated__]] - inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); -template - inline constexpr bool is_empty_v = __is_empty(_Tp); -template - inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); -template - inline constexpr bool is_abstract_v = __is_abstract(_Tp); -template - inline constexpr bool is_final_v = __is_final(_Tp); - -template - inline constexpr bool is_signed_v = is_signed<_Tp>::value; -template - inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; - -template - inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); -template - inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); -template - inline constexpr bool is_copy_constructible_v - = __is_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_move_constructible_v - = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); -template - inline constexpr bool is_copy_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); -template - inline constexpr bool is_move_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; - -template - inline constexpr bool is_trivially_constructible_v - = __is_trivially_constructible(_Tp, _Args...); -template - inline constexpr bool is_trivially_default_constructible_v - = __is_trivially_constructible(_Tp); -template - inline constexpr bool is_trivially_copy_constructible_v - = __is_trivially_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_constructible_v - = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_trivially_assignable_v - = __is_trivially_assignable(_Tp, _Up); -template - inline constexpr bool is_trivially_copy_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>); -template - inline constexpr bool is_trivially_destructible_v = - is_trivially_destructible<_Tp>::value; -template - inline constexpr bool is_nothrow_constructible_v - = __is_nothrow_constructible(_Tp, _Args...); -template - inline constexpr bool is_nothrow_default_constructible_v - = __is_nothrow_constructible(_Tp); -template - inline constexpr bool is_nothrow_copy_constructible_v - = __is_nothrow_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_constructible_v - = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_assignable_v - = __is_nothrow_assignable(_Tp, _Up); -template - inline constexpr bool is_nothrow_copy_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_destructible_v = - is_nothrow_destructible<_Tp>::value; - -template - inline constexpr bool has_virtual_destructor_v - = __has_virtual_destructor(_Tp); - -template - inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; - -template - inline constexpr size_t rank_v = 0; -template - inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; -template - inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; - -template - inline constexpr size_t extent_v = 0; -template - inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; -template - inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; -template - inline constexpr size_t extent_v<_Tp[], 0> = 0; -template - inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; - - -template - inline constexpr bool is_same_v = __is_same(_Tp, _Up); - - - - - - -template - inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); -template - inline constexpr bool is_convertible_v = __is_convertible(_From, _To); -template - inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_v - = is_nothrow_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_invocable_r_v - = is_invocable_r<_Ret, _Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_r_v - = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; - - - - - - - template - struct has_unique_object_representations - : bool_constant<__has_unique_object_representations( - remove_cv_t> - )> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - inline constexpr bool has_unique_object_representations_v - = has_unique_object_representations<_Tp>::value; - - - - - - - template - struct is_aggregate - : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> - { }; - - - - - - template - inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); -# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -} -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - inline constexpr _Tp* - __addressof(_Tp& __r) noexcept - { return __builtin_addressof(__r); } -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type& __t) noexcept - { return static_cast<_Tp&&>(__t); } - - - - - - - - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type&& __t) noexcept - { - static_assert(!std::is_lvalue_reference<_Tp>::value, - "std::forward must not be used to convert an rvalue to an lvalue"); - return static_cast<_Tp&&>(__t); - } - - - - - - - template - [[__nodiscard__]] - constexpr typename std::remove_reference<_Tp>::type&& - move(_Tp&& __t) noexcept - { return static_cast::type&&>(__t); } - - - template - struct __move_if_noexcept_cond - : public __and_<__not_>, - is_copy_constructible<_Tp>>::type { }; -# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr - __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> - move_if_noexcept(_Tp& __x) noexcept - { return std::move(__x); } -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - inline constexpr _Tp* - addressof(_Tp& __r) noexcept - { return std::__addressof(__r); } - - - - template - const _Tp* addressof(const _Tp&&) = delete; - - - template - - inline _Tp - __exchange(_Tp& __obj, _Up&& __new_val) - { - _Tp __old_val = std::move(__obj); - __obj = std::forward<_Up>(__new_val); - return __old_val; - } -# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - - inline - - typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, - is_move_constructible<_Tp>, - is_move_assignable<_Tp>>::value>::type - - - - swap(_Tp& __a, _Tp& __b) - noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) - - { - - - - - _Tp __tmp = std::move(__a); - __a = std::move(__b); - __b = std::move(__tmp); - } - - - - - template - - inline - - typename enable_if<__is_swappable<_Tp>::value>::type - - - - swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(__is_nothrow_swappable<_Tp>::value) - { - for (size_t __n = 0; __n < _Nm; ++__n) - swap(__a[__n], __b[__n]); - } - - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct tuple_size; - - - - - - template::type, - typename = typename enable_if::value>::type, - size_t = tuple_size<_Tp>::value> - using __enable_if_has_tuple_size = _Tp; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - - template - inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; - - - - template - struct tuple_element; - - - template - using __tuple_element_t = typename tuple_element<__i, _Tp>::type; - - template - struct tuple_element<__i, const _Tp> - { - using type = const __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, volatile _Tp> - { - using type = volatile __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, const volatile _Tp> - { - using type = const volatile __tuple_element_t<__i, _Tp>; - }; - - - - - - template - constexpr size_t - __find_uniq_type_in_pack() - { - constexpr size_t __sz = sizeof...(_Types); - constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; - size_t __n = __sz; - for (size_t __i = 0; __i < __sz; ++__i) - { - if (__found[__i]) - { - if (__n < __sz) - return __sz; - __n = __i; - } - } - return __n; - } -# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - template - using tuple_element_t = typename tuple_element<__i, _Tp>::type; - - - - - template struct _Index_tuple { }; - - - template - struct _Build_index_tuple - { - - template - using _IdxTuple = _Index_tuple<_Indices...>; - - - using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; - - - - - }; - - - - - - - template - struct integer_sequence - { - typedef _Tp value_type; - static constexpr size_t size() noexcept { return sizeof...(_Idx); } - }; - - - template - using make_integer_sequence - - = __make_integer_seq; - - - - - - template - using index_sequence = integer_sequence; - - - template - using make_index_sequence = make_integer_sequence; - - - template - using index_sequence_for = make_index_sequence; - - - - struct in_place_t { - explicit in_place_t() = default; - }; - - inline constexpr in_place_t in_place{}; - - template struct in_place_type_t - { - explicit in_place_type_t() = default; - }; - - template - inline constexpr in_place_type_t<_Tp> in_place_type{}; - - template struct in_place_index_t - { - explicit in_place_index_t() = default; - }; - - template - inline constexpr in_place_index_t<_Idx> in_place_index{}; - - template - inline constexpr bool __is_in_place_type_v = false; - - template - inline constexpr bool __is_in_place_type_v> = true; - - template - using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; - - - - - template - struct _Nth_type - { }; - - template - struct _Nth_type<0, _Tp0, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Rest...> - { using type = _Tp1; }; - - template - struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp2; }; - - template - - - - struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> - : _Nth_type<_Np - 3, _Rest...> - { }; - - - template - struct _Nth_type<0, _Tp0, _Tp1, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp1; }; - - - - - - - -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; - - - inline constexpr piecewise_construct_t piecewise_construct = - piecewise_construct_t(); - - - - - template - class tuple; - - template - struct _Index_tuple; - - - - - - - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return __and_, - is_constructible<_T2, const _U2&>>::value; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return __and_, - is_convertible>::value; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return __and_, - is_constructible<_T2, _U2&&>>::value; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return __and_, - is_convertible<_U2&&, _T2>>::value; - } - }; - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return false; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return false; - } - }; - - - - template class __pair_base - { - - template friend struct pair; - __pair_base() = default; - ~__pair_base() = default; - __pair_base(const __pair_base&) = default; - __pair_base& operator=(const __pair_base&) = delete; - - }; -# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct pair - : public __pair_base<_T1, _T2> - { - typedef _T1 first_type; - typedef _T2 second_type; - - _T1 first; - _T2 second; - - - constexpr pair(const pair&) = default; - constexpr pair(pair&&) = default; - - template - - pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); - - - void - swap(pair& __p) - noexcept(__and_<__is_nothrow_swappable<_T1>, - __is_nothrow_swappable<_T2>>::value) - { - using std::swap; - swap(first, __p.first); - swap(second, __p.second); - } -# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - template - - pair(tuple<_Args1...>&, tuple<_Args2...>&, - _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); - public: -# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template , - __is_implicitly_default_constructible<_U2>> - ::value, bool>::type = true> - constexpr pair() - : first(), second() { } - - template , - is_default_constructible<_U2>, - __not_< - __and_<__is_implicitly_default_constructible<_U1>, - __is_implicitly_default_constructible<_U2>>>> - ::value, bool>::type = false> - explicit constexpr pair() - : first(), second() { } - - - - using _PCCP = _PCC; - - - - template() - && _PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - template() - && !_PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - - template - using _PCCFP = _PCC::value - || !is_same<_T2, _U2>::value, - _T1, _T2>; - - - template::template - _ConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } - - template::template - _ConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } -# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - - - - struct __zero_as_null_pointer_constant - { - __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) - { } - template::value>> - __zero_as_null_pointer_constant(_Tp) = delete; - }; - - public: - - - - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - is_convertible<_U1, _T1>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - is_convertible<_U2, _T2>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - - - template() - && _PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - template() - && !_PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - - template::template - _MoveConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - template::template - _MoveConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - - - pair& - operator=(__conditional_t<__and_, - is_copy_assignable<_T2>>::value, - const pair&, const __nonesuch&> __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - pair& - operator=(__conditional_t<__and_, - is_move_assignable<_T2>>::value, - pair&&, __nonesuch&&> __p) - noexcept(__and_, - is_nothrow_move_assignable<_T2>>::value) - { - first = std::forward(__p.first); - second = std::forward(__p.second); - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, const _U2&>>::value, - pair&>::type - operator=(const pair<_U1, _U2>& __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, _U2&&>>::value, - pair&>::type - operator=(pair<_U1, _U2>&& __p) - { - first = std::forward<_U1>(__p.first); - second = std::forward<_U2>(__p.second); - return *this; - } -# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - }; - - - - - template pair(_T1, _T2) -> pair<_T1, _T2>; - - - - template - inline constexpr bool - operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first == __y.first && __x.second == __y.second; } -# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline constexpr bool - operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first < __y.first - || (!(__y.first < __x.first) && __x.second < __y.second); } - - - template - inline constexpr bool - operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x == __y); } - - - template - inline constexpr bool - operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __y < __x; } - - - template - inline constexpr bool - operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__y < __x); } - - - template - inline constexpr bool - operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x < __y); } -# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline - - - typename enable_if<__and_<__is_swappable<_T1>, - __is_swappable<_T2>>::value>::type - - - - swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } -# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - typename enable_if, - __is_swappable<_T2>>::value>::type - swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; -# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - constexpr pair::__type, - typename __decay_and_strip<_T2>::__type> - make_pair(_T1&& __x, _T2&& __y) - { - typedef typename __decay_and_strip<_T1>::__type __ds_type1; - typedef typename __decay_and_strip<_T2>::__type __ds_type2; - typedef pair<__ds_type1, __ds_type2> __pair_type; - return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); - } -# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct __is_tuple_like_impl> : true_type - { }; - - - - template - struct tuple_size> - : public integral_constant { }; - - - template - struct tuple_element<0, pair<_Tp1, _Tp2>> - { typedef _Tp1 type; }; - - - template - struct tuple_element<1, pair<_Tp1, _Tp2>> - { typedef _Tp2 type; }; - - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr bool __is_pair = false; - - template - inline constexpr bool __is_pair> = true; - - - - template - struct __pair_get; - - template<> - struct __pair_get<0> - { - template - static constexpr _Tp1& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr _Tp1&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp1>(__pair.first); } - - template - static constexpr const _Tp1& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr const _Tp1&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.first); } - }; - - template<> - struct __pair_get<1> - { - template - static constexpr _Tp2& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr _Tp2&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp2>(__pair.second); } - - template - static constexpr const _Tp2& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr const _Tp2&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.second); } - }; - - - - - - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__get(__in); } - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__move_get(std::move(__in)); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(const pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__const_get(__in); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(const pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__const_move_get(std::move(__in)); } - - - - - - template - constexpr _Tp& - get(pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr const _Tp& - get(const pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr _Tp&& - get(pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr const _Tp&& - get(const pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr _Tp& - get(pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr const _Tp& - get(const pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr _Tp&& - get(pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } - - template - constexpr const _Tp&& - get(const pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } -# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - struct input_iterator_tag { }; - - - struct output_iterator_tag { }; - - - struct forward_iterator_tag : public input_iterator_tag { }; - - - - struct bidirectional_iterator_tag : public forward_iterator_tag { }; - - - - struct random_access_iterator_tag : public bidirectional_iterator_tag { }; -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct [[__deprecated__]] iterator - { - - typedef _Category iterator_category; - - typedef _Tp value_type; - - typedef _Distance difference_type; - - typedef _Pointer pointer; - - typedef _Reference reference; - }; -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits; - - - - - template> - struct __iterator_traits { }; - - - - template - struct __iterator_traits<_Iterator, - __void_t> - { - typedef typename _Iterator::iterator_category iterator_category; - typedef typename _Iterator::value_type value_type; - typedef typename _Iterator::difference_type difference_type; - typedef typename _Iterator::pointer pointer; - typedef typename _Iterator::reference reference; - }; - - - template - struct iterator_traits - : public __iterator_traits<_Iterator> { }; -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits<_Tp*> - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; - }; - - - template - struct iterator_traits - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; - }; - - - - - - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_Iter>::iterator_category - __iterator_category(const _Iter&) - { return typename iterator_traits<_Iter>::iterator_category(); } - - - - - template - using __iterator_category_t - = typename iterator_traits<_Iter>::iterator_category; - - template - using _RequireInputIter = - __enable_if_t, - input_iterator_tag>::value>; - - template> - struct __is_random_access_iter - : is_base_of - { - typedef is_base_of _Base; - enum { __value = _Base::value }; - }; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template struct _List_iterator; - template struct _List_const_iterator; - - - template - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - __distance(_InputIterator __first, _InputIterator __last, - input_iterator_tag) - { - - - - typename iterator_traits<_InputIterator>::difference_type __n = 0; - while (__first != __last) - { - ++__first; - ++__n; - } - return __n; - } - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_RandomAccessIterator>::difference_type - __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, - random_access_iterator_tag) - { - - - - return __last - __first; - } - - - - template - ptrdiff_t - __distance(std::_List_iterator<_Tp>, - std::_List_iterator<_Tp>, - input_iterator_tag); - - template - ptrdiff_t - __distance(std::_List_const_iterator<_Tp>, - std::_List_const_iterator<_Tp>, - input_iterator_tag); - - - - - template - void - __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; -# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - [[__nodiscard__]] __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - distance(_InputIterator __first, _InputIterator __last) - { - - return std::__distance(__first, __last, - std::__iterator_category(__first)); - } - - template - inline constexpr void - __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) - { - - - do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); - while (__n--) - ++__i; - } - - template - inline constexpr void - __advance(_BidirectionalIterator& __i, _Distance __n, - bidirectional_iterator_tag) - { - - - - if (__n > 0) - while (__n--) - ++__i; - else - while (__n++) - --__i; - } - - template - inline constexpr void - __advance(_RandomAccessIterator& __i, _Distance __n, - random_access_iterator_tag) - { - - - - if (__builtin_constant_p(__n) && __n == 1) - ++__i; - else if (__builtin_constant_p(__n) && __n == -1) - --__i; - else - __i += __n; - } - - - - template - void - __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; -# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - __attribute__((__always_inline__)) - inline constexpr void - advance(_InputIterator& __i, _Distance __n) - { - - typename iterator_traits<_InputIterator>::difference_type __d = __n; - std::__advance(__i, __d, std::__iterator_category(__i)); - } - - - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _InputIterator - next(_InputIterator __x, typename - iterator_traits<_InputIterator>::difference_type __n = 1) - { - - - std::advance(__x, __n); - return __x; - } - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _BidirectionalIterator - prev(_BidirectionalIterator __x, typename - iterator_traits<_BidirectionalIterator>::difference_type __n = 1) - { - - - - std::advance(__x, -__n); - return __x; - } - - - - -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 -# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - class __undefined; - - - - template - struct __get_first_arg - { using type = __undefined; }; - - template class _SomeTemplate, typename _Tp, - typename... _Types> - struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> - { using type = _Tp; }; - - - - template - struct __replace_first_arg - { }; - - template class _SomeTemplate, typename _Up, - typename _Tp, typename... _Types> - struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> - { using type = _SomeTemplate<_Up, _Types...>; }; - - - template - struct __ptr_traits_elem : __get_first_arg<_Ptr> - { }; - - - - - - - - template - struct __ptr_traits_elem<_Ptr, __void_t> - { using type = typename _Ptr::element_type; }; - - - template - using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; - - - - - template::value> - struct __ptr_traits_ptr_to - { - using pointer = _Ptr; - using element_type = _Elt; - - - - - - - - static pointer - pointer_to(element_type& __r) - - - - - - { return pointer::pointer_to(__r); } - }; - - - template - struct __ptr_traits_ptr_to<_Ptr, _Elt, true> - { }; - - - template - struct __ptr_traits_ptr_to<_Tp*, _Tp, false> - { - using pointer = _Tp*; - using element_type = _Tp; - - - - - - - static pointer - pointer_to(element_type& __r) noexcept - { return std::addressof(__r); } - }; - - template - struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> - { - private: - template - using __diff_t = typename _Tp::difference_type; - - template - using __rebind = __type_identity>; - - public: - - using pointer = _Ptr; - - - using element_type = _Elt; - - - using difference_type = __detected_or_t; - - - template - using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, - __rebind, _Ptr, _Up>::type; - }; - - - - template - struct __ptr_traits_impl<_Ptr, __undefined> - { }; - - - - - - - - template - struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> - { }; - - - - - - - - template - struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> - { - - typedef _Tp* pointer; - - typedef _Tp element_type; - - typedef ptrdiff_t difference_type; - - template using rebind = _Up*; - }; - - - template - using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; - - template - constexpr _Tp* - __to_address(_Tp* __ptr) noexcept - { - static_assert(!std::is_function<_Tp>::value, "not a function pointer"); - return __ptr; - } - - - template - constexpr typename std::pointer_traits<_Ptr>::element_type* - __to_address(const _Ptr& __ptr) - { return std::__to_address(__ptr.operator->()); } -# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 -# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class reverse_iterator - : public iterator::iterator_category, - typename iterator_traits<_Iterator>::value_type, - typename iterator_traits<_Iterator>::difference_type, - typename iterator_traits<_Iterator>::pointer, - typename iterator_traits<_Iterator>::reference> - { - template - friend class reverse_iterator; -# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - protected: - _Iterator current; - - typedef iterator_traits<_Iterator> __traits_type; - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::pointer pointer; - - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - constexpr - reverse_iterator() - noexcept(noexcept(_Iterator())) - : current() - { } - - - - - explicit constexpr - reverse_iterator(iterator_type __x) - noexcept(noexcept(_Iterator(__x))) - : current(__x) - { } - - - - - constexpr - reverse_iterator(const reverse_iterator& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - reverse_iterator& operator=(const reverse_iterator&) = default; - - - - - - - template - - - - constexpr - reverse_iterator(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - template - - - - - constexpr - reverse_iterator& - operator=(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(current = __x.current)) - { - current = __x.current; - return *this; - } - - - - - - [[__nodiscard__]] - constexpr iterator_type - base() const - noexcept(noexcept(_Iterator(current))) - { return current; } -# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - { - _Iterator __tmp = current; - return *--__tmp; - } - - - - - - - [[__nodiscard__]] - constexpr pointer - operator->() const - - - - - { - - - _Iterator __tmp = current; - --__tmp; - return _S_to_pointer(__tmp); - } - - - - - - - constexpr reverse_iterator& - operator++() - { - --current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator++(int) - { - reverse_iterator __tmp = *this; - --current; - return __tmp; - } - - - - - - - constexpr reverse_iterator& - operator--() - { - ++current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator--(int) - { - reverse_iterator __tmp = *this; - ++current; - return __tmp; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator+(difference_type __n) const - { return reverse_iterator(current - __n); } - - - - - - - - constexpr reverse_iterator& - operator+=(difference_type __n) - { - current -= __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator-(difference_type __n) const - { return reverse_iterator(current + __n); } - - - - - - - - constexpr reverse_iterator& - operator-=(difference_type __n) - { - current += __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - { return *(*this + __n); } -# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - private: - template - static constexpr _Tp* - _S_to_pointer(_Tp* __p) - { return __p; } - - template - static constexpr pointer - _S_to_pointer(_Tp __t) - { return __t.operator->(); } - }; -# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y.base() < __x.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() > __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() != __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() < __y.base(); } - - template - inline constexpr bool - operator<=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() >= __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() <= __y.base(); } -# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr auto - operator-(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - -> decltype(__y.base() - __x.base()) - { return __y.base() - __x.base(); } - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - operator+(typename reverse_iterator<_Iterator>::difference_type __n, - const reverse_iterator<_Iterator>& __x) - { return reverse_iterator<_Iterator>(__x.base() - __n); } - - - - template - inline constexpr reverse_iterator<_Iterator> - __make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } - - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } -# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) - { return __make_reverse_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - : __is_move_iterator<_Iterator> - { }; - - template - - auto - __miter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) - { return __make_reverse_iterator(__miter_base(__it.base())); } -# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class back_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - back_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - back_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_back(__value); - return *this; - } - - - back_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_back(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - back_insert_iterator& - operator*() - { return *this; } - - - - back_insert_iterator& - operator++() - { return *this; } - - - - back_insert_iterator - operator++(int) - { return *this; } - }; -# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline back_insert_iterator<_Container> - back_inserter(_Container& __x) - { return back_insert_iterator<_Container>(__x); } -# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class front_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - front_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - front_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_front(__value); - return *this; - } - - - front_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_front(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - front_insert_iterator& - operator*() - { return *this; } - - - - front_insert_iterator& - operator++() - { return *this; } - - - - front_insert_iterator - operator++(int) - { return *this; } - }; -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline front_insert_iterator<_Container> - front_inserter(_Container& __x) - { return front_insert_iterator<_Container>(__x); } -# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class insert_iterator - : public iterator - { - - - - typedef typename _Container::iterator _Iter; - - protected: - _Container* container; - _Iter iter; - - public: - - typedef _Container container_type; -# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator(_Container& __x, _Iter __i) - : container(std::__addressof(__x)), iter(__i) {} -# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator& - operator=(const typename _Container::value_type& __value) - { - iter = container->insert(iter, __value); - ++iter; - return *this; - } - - - insert_iterator& - operator=(typename _Container::value_type&& __value) - { - iter = container->insert(iter, std::move(__value)); - ++iter; - return *this; - } - - - - [[__nodiscard__]] - insert_iterator& - operator*() - { return *this; } - - - - insert_iterator& - operator++() - { return *this; } - - - - insert_iterator& - operator++(int) - { return *this; } - }; - -#pragma GCC diagnostic pop -# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline insert_iterator<_Container> - inserter(_Container& __x, typename _Container::iterator __i) - { return insert_iterator<_Container>(__x, __i); } - - - - - -} - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class __normal_iterator - { - protected: - _Iterator _M_current; - - typedef std::iterator_traits<_Iterator> __traits_type; - - - template - using __convertible_from - = std::__enable_if_t::value>; - - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; - typedef typename __traits_type::pointer pointer; - - - - - - constexpr __normal_iterator() noexcept - : _M_current(_Iterator()) { } - - explicit - __normal_iterator(const _Iterator& __i) noexcept - : _M_current(__i) { } - - - - template> - - __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) - noexcept -# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - : _M_current(__i.base()) { } - - - - reference - operator*() const noexcept - { return *_M_current; } - - - pointer - operator->() const noexcept - { return _M_current; } - - - __normal_iterator& - operator++() noexcept - { - ++_M_current; - return *this; - } - - - __normal_iterator - operator++(int) noexcept - { return __normal_iterator(_M_current++); } - - - - __normal_iterator& - operator--() noexcept - { - --_M_current; - return *this; - } - - - __normal_iterator - operator--(int) noexcept - { return __normal_iterator(_M_current--); } - - - - reference - operator[](difference_type __n) const noexcept - { return _M_current[__n]; } - - - __normal_iterator& - operator+=(difference_type __n) noexcept - { _M_current += __n; return *this; } - - - __normal_iterator - operator+(difference_type __n) const noexcept - { return __normal_iterator(_M_current + __n); } - - - __normal_iterator& - operator-=(difference_type __n) noexcept - { _M_current -= __n; return *this; } - - - __normal_iterator - operator-(difference_type __n) const noexcept - { return __normal_iterator(_M_current - __n); } - - - const _Iterator& - base() const noexcept - { return _M_current; } - }; -# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - - - - - - template - - - [[__nodiscard__]] - inline auto - operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept - -> decltype(__lhs.base() - __rhs.base()) - - - - - - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline typename __normal_iterator<_Iterator, _Container>::difference_type - operator-(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline __normal_iterator<_Iterator, _Container> - operator+(typename __normal_iterator<_Iterator, _Container>::difference_type - __n, const __normal_iterator<_Iterator, _Container>& __i) - noexcept - { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } - - -} - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - - _Iterator - __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it.base(); } - - - - - - - template - constexpr auto - __to_address(const __gnu_cxx::__normal_iterator<_Iterator, - _Container>& __it) noexcept - -> decltype(std::__to_address(__it.base())) - { return std::__to_address(__it.base()); } -# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - namespace __detail - { -# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - } -# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class move_iterator - - - - { - _Iterator _M_current; - - using __traits_type = iterator_traits<_Iterator>; - - using __base_ref = typename __traits_type::reference; - - - template - friend class move_iterator; -# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - public: - using iterator_type = _Iterator; -# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - - typedef _Iterator pointer; - - - using reference - = __conditional_t::value, - typename remove_reference<__base_ref>::type&&, - __base_ref>; - - - constexpr - move_iterator() - : _M_current() { } - - explicit constexpr - move_iterator(iterator_type __i) - : _M_current(std::move(__i)) { } - - template - - - - constexpr - move_iterator(const move_iterator<_Iter>& __i) - : _M_current(__i._M_current) { } - - template - - - - - constexpr - move_iterator& operator=(const move_iterator<_Iter>& __i) - { - _M_current = __i._M_current; - return *this; - } - - - [[__nodiscard__]] - constexpr iterator_type - base() const - { return _M_current; } -# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - - - - { return static_cast(*_M_current); } - - - [[__nodiscard__]] - constexpr pointer - operator->() const - { return _M_current; } - - constexpr move_iterator& - operator++() - { - ++_M_current; - return *this; - } - - constexpr move_iterator - operator++(int) - { - move_iterator __tmp = *this; - ++_M_current; - return __tmp; - } - - - - - - - - constexpr move_iterator& - operator--() - { - --_M_current; - return *this; - } - - constexpr move_iterator - operator--(int) - { - move_iterator __tmp = *this; - --_M_current; - return __tmp; - } - - [[__nodiscard__]] - constexpr move_iterator - operator+(difference_type __n) const - { return move_iterator(_M_current + __n); } - - constexpr move_iterator& - operator+=(difference_type __n) - { - _M_current += __n; - return *this; - } - - [[__nodiscard__]] - constexpr move_iterator - operator-(difference_type __n) const - { return move_iterator(_M_current - __n); } - - constexpr move_iterator& - operator-=(difference_type __n) - { - _M_current -= __n; - return *this; - } - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - - - - { return std::move(_M_current[__n]); } -# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - }; - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() == __y.base(); } -# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - { return !(__x == __y); } - - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } -# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - template - [[__nodiscard__]] - inline constexpr auto - operator-(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - -> decltype(__x.base() - __y.base()) - { return __x.base() - __y.base(); } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - operator+(typename move_iterator<_Iterator>::difference_type __n, - const move_iterator<_Iterator>& __x) - { return __x + __n; } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - make_move_iterator(_Iterator __i) - { return move_iterator<_Iterator>(std::move(__i)); } - - template::value_type>::value, - _Iterator, move_iterator<_Iterator>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Iterator __i) - { return _ReturnType(__i); } - - - - template::value, - const _Tp*, move_iterator<_Tp*>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Tp* __i) - { return _ReturnType(__i); } -# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(move_iterator<_Iterator> __it) - -> decltype(make_move_iterator(__niter_base(__it.base()))) - { return make_move_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template - - auto - __miter_base(move_iterator<_Iterator> __it) - -> decltype(__miter_base(__it.base())) - { return __miter_base(__it.base()); } -# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - using __iter_key_t = remove_const_t< - typename iterator_traits<_InputIterator>::value_type::first_type>; - - template - using __iter_val_t - = typename iterator_traits<_InputIterator>::value_type::second_type; - - template - struct pair; - - template - using __iter_to_alloc_t - = pair, __iter_val_t<_InputIterator>>; - - - -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 -namespace std -{ - namespace __debug { } -} - - - - -namespace __gnu_debug -{ - using namespace std::__debug; - - template - struct _Safe_iterator; -} -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 -namespace __gnu_cxx -{ -namespace __ops -{ - struct _Iter_less_iter - { - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 < *__it2; } - }; - - constexpr - inline _Iter_less_iter - __iter_less_iter() - { return _Iter_less_iter(); } - - struct _Iter_less_val - { - - constexpr _Iter_less_val() = default; - - - - - - explicit - _Iter_less_val(_Iter_less_iter) { } - - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it < __val; } - }; - - - inline _Iter_less_val - __iter_less_val() - { return _Iter_less_val(); } - - - inline _Iter_less_val - __iter_comp_val(_Iter_less_iter) - { return _Iter_less_val(); } - - struct _Val_less_iter - { - - constexpr _Val_less_iter() = default; - - - - - - explicit - _Val_less_iter(_Iter_less_iter) { } - - template - - bool - operator()(_Value& __val, _Iterator __it) const - { return __val < *__it; } - }; - - - inline _Val_less_iter - __val_less_iter() - { return _Val_less_iter(); } - - - inline _Val_less_iter - __val_comp_iter(_Iter_less_iter) - { return _Val_less_iter(); } - - struct _Iter_equal_to_iter - { - template - - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 == *__it2; } - }; - - - inline _Iter_equal_to_iter - __iter_equal_to_iter() - { return _Iter_equal_to_iter(); } - - struct _Iter_equal_to_val - { - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it == __val; } - }; - - - inline _Iter_equal_to_val - __iter_equal_to_val() - { return _Iter_equal_to_val(); } - - - inline _Iter_equal_to_val - __iter_comp_val(_Iter_equal_to_iter) - { return _Iter_equal_to_val(); } - - template - struct _Iter_comp_iter - { - _Compare _M_comp; - - explicit constexpr - _Iter_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) - { return bool(_M_comp(*__it1, *__it2)); } - }; - - template - constexpr - inline _Iter_comp_iter<_Compare> - __iter_comp_iter(_Compare __comp) - { return _Iter_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_comp_val - { - _Compare _M_comp; - - - explicit - _Iter_comp_val(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Iterator __it, _Value& __val) - { return bool(_M_comp(*__it, __val)); } - }; - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Compare __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Iter_comp_iter<_Compare> __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - struct _Val_comp_iter - { - _Compare _M_comp; - - - explicit - _Val_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Value& __val, _Iterator __it) - { return bool(_M_comp(__val, *__it)); } - }; - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Compare __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Iter_comp_iter<_Compare> __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_equals_val - { - _Value& _M_value; - - - explicit - _Iter_equals_val(_Value& __value) - : _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return *__it == _M_value; } - }; - - template - - inline _Iter_equals_val<_Value> - __iter_equals_val(_Value& __val) - { return _Iter_equals_val<_Value>(__val); } - - template - struct _Iter_equals_iter - { - _Iterator1 _M_it1; - - - explicit - _Iter_equals_iter(_Iterator1 __it1) - : _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return *__it2 == *_M_it1; } - }; - - template - - inline _Iter_equals_iter<_Iterator> - __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) - { return _Iter_equals_iter<_Iterator>(__it); } - - template - struct _Iter_pred - { - _Predicate _M_pred; - - - explicit - _Iter_pred(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_pred<_Predicate> - __pred_iter(_Predicate __pred) - { return _Iter_pred<_Predicate>(std::move(__pred)); } - - template - struct _Iter_comp_to_val - { - _Compare _M_comp; - _Value& _M_value; - - - _Iter_comp_to_val(_Compare __comp, _Value& __value) - : _M_comp(std::move(__comp)), _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_comp(*__it, _M_value)); } - }; - - template - _Iter_comp_to_val<_Compare, _Value> - - __iter_comp_val(_Compare __comp, _Value &__val) - { - return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); - } - - template - struct _Iter_comp_to_iter - { - _Compare _M_comp; - _Iterator1 _M_it1; - - - _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) - : _M_comp(std::move(__comp)), _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return bool(_M_comp(*__it2, *_M_it1)); } - }; - - template - - inline _Iter_comp_to_iter<_Compare, _Iterator> - __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) - { - return _Iter_comp_to_iter<_Compare, _Iterator>( - std::move(__comp._M_comp), __it); - } - - template - struct _Iter_negate - { - _Predicate _M_pred; - - - explicit - _Iter_negate(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return !bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_negate<_Predicate> - __negate(_Iter_pred<_Predicate> __pred) - { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } - -} -} -# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 - template - constexpr _Tp - __rotl(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); - else - return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); - } - - template - constexpr _Tp - __rotr(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); - else - return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); - } - - template - constexpr int - __countl_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - { - constexpr int __diff = _Nd_u - _Nd; - return __builtin_clz(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ul) - { - constexpr int __diff = _Nd_ul - _Nd; - return __builtin_clzl(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ull) - { - constexpr int __diff = _Nd_ull - _Nd; - return __builtin_clzll(__x) - __diff; - } - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - unsigned long long __high = __x >> _Nd_ull; - if (__high != 0) - { - constexpr int __diff = (2 * _Nd_ull) - _Nd; - return __builtin_clzll(__high) - __diff; - } - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - return (_Nd - _Nd_ull) + __builtin_clzll(__low); - } - } - - template - constexpr int - __countl_one(_Tp __x) noexcept - { - return std::__countl_zero<_Tp>((_Tp)~__x); - } - - template - constexpr int - __countr_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_ctz(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_ctzl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_ctzll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - if (__low != 0) - return __builtin_ctzll(__low); - unsigned long long __high = __x >> _Nd_ull; - return __builtin_ctzll(__high) + _Nd_ull; - } - } - - template - constexpr int - __countr_one(_Tp __x) noexcept - { - return std::__countr_zero((_Tp)~__x); - } - - template - constexpr int - __popcount(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_popcount(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_popcountl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_popcountll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - unsigned long long __high = __x >> _Nd_ull; - return __builtin_popcountll(__low) + __builtin_popcountll(__high); - } - } - - template - constexpr bool - __has_single_bit(_Tp __x) noexcept - { return std::__popcount(__x) == 1; } - - template - constexpr _Tp - __bit_ceil(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - if (__x == 0 || __x == 1) - return 1; - auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); - - - - - if (!std::__is_constant_evaluated()) - { - do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); - } - - using __promoted_type = decltype(__x << 1); - if constexpr (!is_same<__promoted_type, _Tp>::value) - { - - - - - - const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; - __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; - } - return (_Tp)1u << __shift_exponent; - } - - template - constexpr _Tp - __bit_floor(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if (__x == 0) - return 0; - return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); - } - - template - constexpr int - __bit_width(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - return _Nd - std::__countl_zero(__x); - } -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -} -# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - template - constexpr - inline int - __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) - { - - static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); -# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); - } -# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) - { -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - swap(*__a, *__b); - - } -# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - _ForwardIterator2 - swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - std::iter_swap(__first1, __first2); - return __first2; - } -# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b) - { - - - - if (__b < __a) - return __b; - return __a; - } -# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b) - { - - - - if (__a < __b) - return __b; - return __a; - } -# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__b, __a)) - return __b; - return __a; - } -# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__a, __b)) - return __b; - return __a; - } - - - - template - - inline _Iterator - __niter_base(_Iterator __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it; } - - template - _Ite - __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, - std::random_access_iterator_tag>&); - - - - - template - - inline _From - __niter_wrap(_From __from, _To __res) - { return __from + (__res - std::__niter_base(__from)); } - - - template - - inline _Iterator - __niter_wrap(const _Iterator&, _Iterator __res) - { return __res; } - - - - - - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = *__first; - return __result; - } - }; - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = std::move(*__first); - return __result; - } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = *__first; - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = *__from; } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = std::move(*__first); - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = std::move(*__from); } - }; - - - template - struct __copy_move<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_m(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result, __first); - return __result + _Num; - } - }; - - - - template - struct _Deque_iterator; - - struct _Bit_iterator; - - - - - - - template - struct char_traits; - - template - class istreambuf_iterator; - - template - class ostreambuf_iterator; - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(_CharT*, _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(const _CharT*, const _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - _CharT*>::__type - __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_move_a2( - istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>); - - - template - - inline _OI - __copy_move_a2(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::iterator_category _Category; - - - - - - return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, - _Category>::__copy_m(__first, __last, __result); - } - - template - _OI - __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_a1(_II __first, _II __last, _OI __result) - { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } - - template - - inline _OI - __copy_move_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_a1<_IsMove>(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); - - template - - _OutputIterator - __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, - bool) - { - if (__n > 0) - { - while (true) - { - *__result = *__first; - ++__result; - if (--__n > 0) - ++__first; - else - break; - } - } - return __result; - } - - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, _CharT*>::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, - _Size, _CharT*, bool); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>, - bool); -# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - copy(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a<__is_move_iterator<_II>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - move(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a(std::__miter_base(__first), - std::__miter_base(__last), __result); - } - - - - - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = *--__last; - return __result; - } - }; - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = *--__last; - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template - struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result - 1, __first); - return __result - _Num; - } - }; - - template - - inline _BI2 - __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) - { - typedef typename iterator_traits<_BI1>::iterator_category _Category; - - - - - - return std::__copy_move_backward<_IsMove, - __memcpyable<_BI2, _BI1>::__value, - _Category>::__copy_move_b(__first, - __last, - __result); - } - - template - - inline _BI2 - __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) - { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } - - template - _OI - __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_backward_a1( - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_backward_a1(_II, _II, - std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_backward_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_backward_a1<_IsMove> - (std::__niter_base(__first), std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_backward_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); -# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - move_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a(std::__miter_base(__first), - std::__miter_base(__last), - __result); - } - - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - for (; __first != __last; ++__first) - *__first = __value; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __first != __last; ++__first) - *__first = __tmp; - } - - - template - - inline typename - __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type - __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) - { - const _Tp __tmp = __c; -# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - if (const size_t __len = __last - __first) - __builtin_memset(__first, static_cast(__tmp), __len); - } - - template - - inline void - __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, - ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, - const _Tp& __value) - { std::__fill_a1(__first.base(), __last.base(), __value); } - - template - void - __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const _VTp&); - - - void - __fill_a1(std::_Bit_iterator, std::_Bit_iterator, - const bool&); - - template - - inline void - __fill_a(_FIte __first, _FIte __last, const _Tp& __value) - { std::__fill_a1(__first, __last, __value); } - - template - void - __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const _Tp&); -# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) - { - - - - ; - - std::__fill_a(__first, __last, __value); - } - - - inline constexpr int - __size_to_integer(int __n) { return __n; } - inline constexpr unsigned - __size_to_integer(unsigned __n) { return __n; } - inline constexpr long - __size_to_integer(long __n) { return __n; } - inline constexpr unsigned long - __size_to_integer(unsigned long __n) { return __n; } - inline constexpr long long - __size_to_integer(long long __n) { return __n; } - inline constexpr unsigned long long - __size_to_integer(unsigned long long __n) { return __n; } -# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - inline constexpr long long - __size_to_integer(float __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(double __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(long double __n) { return (long long)__n; } - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - for (; __n > 0; --__n, (void) ++__first) - *__first = __value; - return __first; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __n > 0; --__n, (void) ++__first) - *__first = __tmp; - return __first; - } - - template - ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, - _Size __n, const _Tp& __value, - std::input_iterator_tag); - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::output_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::input_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::random_access_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - if (__n <= 0) - return __first; - - ; - - std::__fill_a(__first, __first + __n, __value); - return __first + __n; - } -# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - fill_n(_OI __first, _Size __n, const _Tp& __value) - { - - - - return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, - std::__iterator_category(__first)); - } - - template - struct __equal - { - template - - static bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - for (; __first1 != __last1; ++__first1, (void) ++__first2) - if (!(*__first1 == *__first2)) - return false; - return true; - } - }; - - template<> - struct __equal - { - template - - static bool - equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) - { - if (const size_t __len = (__last1 - __first1)) - return !std::__memcmp(__first1, __first2, __len); - return true; - } - }; - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _II); - - template - bool - __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(_II, _II, - std::_Deque_iterator<_Tp, _Ref, _Ptr>); - - template - - inline bool - __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - const bool __simple = ((__is_integer<_ValueType1>::__value - || __is_pointer<_ValueType1>::__value) - && __memcmpable<_II1, _II2>::__value); - return std::__equal<__simple>::equal(__first1, __last1, __first2); - } - - template - - inline bool - __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) - { - return std::__equal_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2)); - } - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - _II2); - - template - bool - __equal_aux(_II1, _II1, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - struct __lc_rai - { - template - - static _II1 - __newlast1(_II1, _II1 __last1, _II2, _II2) - { return __last1; } - - template - - static bool - __cnd2(_II __first, _II __last) - { return __first != __last; } - }; - - template<> - struct __lc_rai - { - template - - static _RAI1 - __newlast1(_RAI1 __first1, _RAI1 __last1, - _RAI2 __first2, _RAI2 __last2) - { - const typename iterator_traits<_RAI1>::difference_type - __diff1 = __last1 - __first1; - const typename iterator_traits<_RAI2>::difference_type - __diff2 = __last2 - __first2; - return __diff2 < __diff1 ? __first1 + __diff2 : __last1; - } - - template - static bool - __cnd2(_RAI, _RAI) - { return true; } - }; - - template - - bool - __lexicographical_compare_impl(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, - _Compare __comp) - { - typedef typename iterator_traits<_II1>::iterator_category _Category1; - typedef typename iterator_traits<_II2>::iterator_category _Category2; - typedef std::__lc_rai<_Category1, _Category2> __rai_type; - - __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); - for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); - ++__first1, (void)++__first2) - { - if (__comp(__first1, __first2)) - return true; - if (__comp(__first2, __first1)) - return false; - } - return __first1 == __last1 && __first2 != __last2; - } - - template - struct __lexicographical_compare - { - template - - static bool - __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using __gnu_cxx::__ops::__iter_less_iter; - return std::__lexicographical_compare_impl(__first1, __last1, - __first2, __last2, - __iter_less_iter()); - } - - template - - static int - __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - while (__first1 != __last1) - { - if (__first2 == __last2) - return +1; - if (*__first1 < *__first2) - return -1; - if (*__first2 < *__first1) - return +1; - ++__first1; - ++__first2; - } - return int(__first2 == __last2) - 1; - } - }; - - template<> - struct __lexicographical_compare - { - template - - static bool - __lc(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { return __3way(__first1, __last1, __first2, __last2) < 0; } - - template - - static ptrdiff_t - __3way(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { - const size_t __len1 = __last1 - __first1; - const size_t __len2 = __last2 - __first2; - if (const size_t __len = std::min(__len1, __len2)) - if (int __result = std::__memcmp(__first1, __first2, __len)) - return __result; - return ptrdiff_t(__len1 - __len2); - } - }; - - template - - inline bool - __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - typedef typename iterator_traits<_II2>::value_type _ValueType2; - const bool __simple = - (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value - && __is_pointer<_II1>::__value - && __is_pointer<_II2>::__value - - - - - - - - ); - - return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, - __first2, __last2); - } - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - _Tp2*, _Tp2*); - - template - bool - __lexicographical_compare_aux1(_Tp1*, _Tp1*, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - - inline bool - __lexicographical_compare_aux(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - return std::__lexicographical_compare_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2), - std::__niter_base(__last2)); - } - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - _II2, _II2); - - template - bool - __lexicographical_compare_aux( - _II1, _II1, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - - _ForwardIterator - __lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val, _Compare __comp) - { - typedef typename iterator_traits<_ForwardIterator>::difference_type - _DistanceType; - - _DistanceType __len = std::distance(__first, __last); - - while (__len > 0) - { - _DistanceType __half = __len >> 1; - _ForwardIterator __middle = __first; - std::advance(__middle, __half); - if (__comp(__middle, __val)) - { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - else - __len = __half; - } - return __first; - } -# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _ForwardIterator - lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val) - { - - - - - ; - - return std::__lower_bound(__first, __last, __val, - __gnu_cxx::__ops::__iter_less_val()); - } - - - - template - inline constexpr _Tp - __lg(_Tp __n) - { - - return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; -# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - } -# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - - - - - - - ; - - return std::__equal_aux(__first1, __last1, __first2); - } -# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return true; - } - - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!(*__first1 == *__first2)) - return false; - return __first1 == __last1 && __first2 == __last2; - } - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, - _BinaryPredicate __binary_pred) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2, - __binary_pred); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return __first1 == __last1 && __first2 == __last2; - } -# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - - - - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2); - } -# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2, - __binary_pred); - } -# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { -# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - ; - ; - - return std::__lexicographical_compare_aux(__first1, __last1, - __first2, __last2); - } -# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, _Compare __comp) - { - - - - ; - ; - - return std::__lexicographical_compare_impl - (__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); - } -# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2) - { - - - - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __first2 != __last2 - && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2) - { - - - - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - - - template - - inline _InputIterator - __find_if(_InputIterator __first, _InputIterator __last, - _Predicate __pred, input_iterator_tag) - { - while (__first != __last && !__pred(__first)) - ++__first; - return __first; - } - - - template - - _RandomAccessIterator - __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Predicate __pred, random_access_iterator_tag) - { - typename iterator_traits<_RandomAccessIterator>::difference_type - __trip_count = (__last - __first) >> 2; - - for (; __trip_count > 0; --__trip_count) - { - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - } - - switch (__last - __first) - { - case 3: - if (__pred(__first)) - return __first; - ++__first; - - case 2: - if (__pred(__first)) - return __first; - ++__first; - - case 1: - if (__pred(__first)) - return __first; - ++__first; - - case 0: - default: - return __last; - } - } - - template - - inline _Iterator - __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) - { - return __find_if(__first, __last, __pred, - std::__iterator_category(__first)); - } - - template - - typename iterator_traits<_InputIterator>::difference_type - __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) - { - typename iterator_traits<_InputIterator>::difference_type __n = 0; - for (; __first != __last; ++__first) - if (__pred(__first)) - ++__n; - return __n; - } - - template - - _ForwardIterator - __remove_if(_ForwardIterator __first, _ForwardIterator __last, - _Predicate __pred) - { - __first = std::__find_if(__first, __last, __pred); - if (__first == __last) - return __first; - _ForwardIterator __result = __first; - ++__first; - for (; __first != __last; ++__first) - if (!__pred(__first)) - { - *__result = std::move(*__first); - ++__result; - } - return __result; - } - - - template - - bool - __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _BinaryPredicate __pred) - { - - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!__pred(__first1, __first2)) - break; - - if (__first1 == __last1) - return true; - - - - _ForwardIterator2 __last2 = __first2; - std::advance(__last2, std::distance(__first1, __last1)); - for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) - { - if (__scan != std::__find_if(__first1, __scan, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) - continue; - - auto __matches - = std::__count_if(__first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); - if (0 == __matches || - std::__count_if(__scan, __last1, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) - != __matches) - return false; - } - return true; - } -# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - - ; - - return std::__is_permutation(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } - - - -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 1 3 -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 - - - -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 - class exception - { - public: - exception() noexcept { } - virtual ~exception() noexcept; - - exception(const exception&) = default; - exception& operator=(const exception&) = default; - exception(exception&&) = default; - exception& operator=(exception&&) = default; - - - - - virtual const char* - what() const noexcept; - }; - - - -} - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 2 3 - -#pragma GCC visibility push(default) - -extern "C++" { - -namespace std -{ - - - - - - - class bad_alloc : public exception - { - public: - bad_alloc() throw() { } - - - bad_alloc(const bad_alloc&) = default; - bad_alloc& operator=(const bad_alloc&) = default; - - - - - virtual ~bad_alloc() throw(); - - - virtual const char* what() const throw(); - }; - - - class bad_array_new_length : public bad_alloc - { - public: - bad_array_new_length() throw() { } - - - - virtual ~bad_array_new_length() throw(); - - - virtual const char* what() const throw(); - }; - - - - enum class align_val_t: size_t {}; - - - struct nothrow_t - { - - explicit nothrow_t() = default; - - }; - - extern const nothrow_t nothrow; - - - - typedef void (*new_handler)(); - - - - new_handler set_new_handler(new_handler) throw(); - - - - new_handler get_new_handler() noexcept; - -} -# 126 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -[[__nodiscard__]] void* operator new(std::size_t) - __attribute__((__externally_visible__)); -[[__nodiscard__]] void* operator new[](std::size_t) - __attribute__((__externally_visible__)); -void operator delete(void*) noexcept - __attribute__((__externally_visible__)); -void operator delete[](void*) noexcept - __attribute__((__externally_visible__)); - - - - - - -[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete(void*, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__)); -void operator delete[](void*, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__)); - -[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete(void*, std::align_val_t) - noexcept __attribute__((__externally_visible__)); -void operator delete(void*, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__)); -[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete[](void*, std::align_val_t) - noexcept __attribute__((__externally_visible__)); -void operator delete[](void*, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__)); -# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept -{ return __p; } -[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept -{ return __p; } - - -inline void operator delete (void*, void*) noexcept { } -inline void operator delete[](void*, void*) noexcept { } - -} - - -namespace std -{ - - - - template - [[nodiscard]] constexpr _Tp* - launder(_Tp* __p) noexcept - { return __builtin_launder(__p); } - - - - - template - void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; - template - void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; - - void launder(void*) = delete; - void launder(const void*) = delete; - void launder(volatile void*) = delete; - void launder(const volatile void*) = delete; - - - - - - - -} -# 236 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -#pragma GCC visibility pop -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - template - class __new_allocator - { - public: - typedef _Tp value_type; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - - template - struct rebind - { typedef __new_allocator<_Tp1> other; }; - - - - - - typedef std::true_type propagate_on_container_move_assignment; - - - __attribute__((__always_inline__)) - - __new_allocator() noexcept { } - - __attribute__((__always_inline__)) - - __new_allocator(const __new_allocator&) noexcept { } - - template - __attribute__((__always_inline__)) - - __new_allocator(const __new_allocator<_Tp1>&) noexcept { } - - - ~__new_allocator() noexcept { } - - pointer - address(reference __x) const noexcept - { return std::__addressof(__x); } - - const_pointer - address(const_reference __x) const noexcept - { return std::__addressof(__x); } -# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - [[__nodiscard__]] _Tp* - allocate(size_type __n, const void* = static_cast(0)) - { - - - - static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); - - - if (__builtin_expect(__n > this->_M_max_size(), false)) - { - - - if (__n > (std::size_t(-1) / sizeof(_Tp))) - std::__throw_bad_array_new_length(); - std::__throw_bad_alloc(); - } - - - if (alignof(_Tp) > 16UL) - { - std::align_val_t __al = std::align_val_t(alignof(_Tp)); - return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp), - __al)); - } - - return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp))); - } - - - void - deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) - { - - - - - - - - if (alignof(_Tp) > 16UL) - { - __builtin_operator_delete((__p), - std::align_val_t(alignof(_Tp))); - return; - } - - __builtin_operator_delete((__p)); - } - - - - - - - __attribute__((__always_inline__)) - size_type - max_size() const noexcept - { return _M_max_size(); } - - - template - __attribute__((__always_inline__)) - void - construct(_Up* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } - - template - __attribute__((__always_inline__)) - void - destroy(_Up* __p) - noexcept(std::is_nothrow_destructible<_Up>::value) - { __p->~_Up(); } -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - template - friend __attribute__((__always_inline__)) bool - operator==(const __new_allocator&, const __new_allocator<_Up>&) - noexcept - { return true; } - - - template - friend __attribute__((__always_inline__)) bool - operator!=(const __new_allocator&, const __new_allocator<_Up>&) - noexcept - { return false; } - - - private: - __attribute__((__always_inline__)) - constexpr size_type - _M_max_size() const noexcept - { - - return std::size_t(9223372036854775807L) / sizeof(_Tp); - - - - } - }; - - -} -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3 - - -namespace std -{ -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 - template - using __allocator_base = __new_allocator<_Tp>; -} -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 1 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 - template - class allocator; - - template<> - class allocator; - - - - - template - struct uses_allocator; - - template - struct allocator_traits; - - - - - -} -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - template<> - class allocator - { - public: - typedef void value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - - - typedef void* pointer; - typedef const void* const_pointer; - - template - struct rebind - { typedef allocator<_Tp1> other; }; - - - - - - using propagate_on_container_move_assignment = true_type; - - using is_always_equal - - = true_type; -# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - }; -# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - template - class allocator : public __allocator_base<_Tp> - { - public: - typedef _Tp value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - - - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - - template - struct rebind - { typedef allocator<_Tp1> other; }; - - - - - - using propagate_on_container_move_assignment = true_type; - - using is_always_equal - - = true_type; - - - - - __attribute__((__always_inline__)) - - allocator() noexcept { } - - __attribute__((__always_inline__)) - - allocator(const allocator& __a) noexcept - : __allocator_base<_Tp>(__a) { } - - - - allocator& operator=(const allocator&) = default; - - - template - __attribute__((__always_inline__)) - - allocator(const allocator<_Tp1>&) noexcept { } - - __attribute__((__always_inline__)) - - - - ~allocator() noexcept { } -# 214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - friend __attribute__((__always_inline__)) - bool - operator==(const allocator&, const allocator&) noexcept - { return true; } - - - friend __attribute__((__always_inline__)) - bool - operator!=(const allocator&, const allocator&) noexcept - { return false; } - - - - }; - - - - - - - template - __attribute__((__always_inline__)) - inline bool - operator==(const allocator<_T1>&, const allocator<_T2>&) - noexcept - { return true; } - - - template - __attribute__((__always_inline__)) - inline bool - operator!=(const allocator<_T1>&, const allocator<_T2>&) - noexcept - { return false; } - - - - - - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - - - - - - - extern template class allocator; - extern template class allocator; - - - - - - -} -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - template - class initializer_list - { - public: - typedef _E value_type; - typedef const _E& reference; - typedef const _E& const_reference; - typedef size_t size_type; - typedef const _E* iterator; - typedef const _E* const_iterator; - - private: - iterator _M_array; - size_type _M_len; - - - constexpr initializer_list(const_iterator __a, size_type __l) - : _M_array(__a), _M_len(__l) { } - - public: - constexpr initializer_list() noexcept - : _M_array(0), _M_len(0) { } - - - constexpr size_type - size() const noexcept { return _M_len; } - - - constexpr const_iterator - begin() const noexcept { return _M_array; } - - - constexpr const_iterator - end() const noexcept { return begin() + size(); } - }; - - - - - - - - template - constexpr const _Tp* - begin(initializer_list<_Tp> __ils) noexcept - { return __ils.begin(); } - - - - - - - - template - constexpr const _Tp* - end(initializer_list<_Tp> __ils) noexcept - { return __ils.end(); } -} -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 2 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - begin(_Container& __cont) -> decltype(__cont.begin()) - { return __cont.begin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - begin(const _Container& __cont) -> decltype(__cont.begin()) - { return __cont.begin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - end(_Container& __cont) -> decltype(__cont.end()) - { return __cont.end(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - end(const _Container& __cont) -> decltype(__cont.end()) - { return __cont.end(); } - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr _Tp* - begin(_Tp (&__arr)[_Nm]) noexcept - { return __arr; } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr _Tp* - end(_Tp (&__arr)[_Nm]) noexcept - { return __arr + _Nm; } - - - - template class valarray; - - template _Tp* begin(valarray<_Tp>&) noexcept; - template const _Tp* begin(const valarray<_Tp>&) noexcept; - template _Tp* end(valarray<_Tp>&) noexcept; - template const _Tp* end(const valarray<_Tp>&) noexcept; - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - constexpr auto - cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) - -> decltype(std::begin(__cont)) - { return std::begin(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - constexpr auto - cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) - -> decltype(std::end(__cont)) - { return std::end(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rbegin(_Container& __cont) -> decltype(__cont.rbegin()) - { return __cont.rbegin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) - { return __cont.rbegin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rend(_Container& __cont) -> decltype(__cont.rend()) - { return __cont.rend(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rend(const _Container& __cont) -> decltype(__cont.rend()) - { return __cont.rend(); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Tp*> - rbegin(_Tp (&__arr)[_Nm]) noexcept - { return reverse_iterator<_Tp*>(__arr + _Nm); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Tp*> - rend(_Tp (&__arr)[_Nm]) noexcept - { return reverse_iterator<_Tp*>(__arr); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator - rbegin(initializer_list<_Tp> __il) noexcept - { return reverse_iterator(__il.end()); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator - rend(initializer_list<_Tp> __il) noexcept - { return reverse_iterator(__il.begin()); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) - { return std::rbegin(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - crend(const _Container& __cont) -> decltype(std::rend(__cont)) - { return std::rend(__cont); } -# 261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - size(const _Container& __cont) noexcept(noexcept(__cont.size())) - -> decltype(__cont.size()) - { return __cont.size(); } - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr size_t - size(const _Tp (&)[_Nm]) noexcept - { return _Nm; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) - -> decltype(__cont.empty()) - { return __cont.empty(); } - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr bool - empty(const _Tp (&)[_Nm]) noexcept - { return false; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr bool - empty(initializer_list<_Tp> __il) noexcept - { return __il.size() == 0;} - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - data(_Container& __cont) noexcept(noexcept(__cont.data())) - -> decltype(__cont.data()) - { return __cont.data(); } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - data(const _Container& __cont) noexcept(noexcept(__cont.data())) - -> decltype(__cont.data()) - { return __cont.data(); } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr _Tp* - data(_Tp (&__array)[_Nm]) noexcept - { return __array; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr const _Tp* - data(initializer_list<_Tp> __il) noexcept - { return __il.begin(); } -# 371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 1 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 1 3 -# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - inline void - destroy_at(_Tp* __location) - { - if constexpr (201703L > 201703L && is_array_v<_Tp>) - { - for (auto& __x : *__location) - std::destroy_at(std::__addressof(__x)); - } - else - __location->~_Tp(); - } -# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - template - - inline void - _Construct(_Tp* __p, _Args&&... __args) - { -# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); - } -# 132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - template - inline void - _Construct_novalue(_T1* __p) - { ::new((void*)__p) _T1; } - - template - void - _Destroy(_ForwardIterator __first, _ForwardIterator __last); - - - - - template - constexpr inline void - _Destroy(_Tp* __pointer) - { - - - - __pointer->~_Tp(); - - } - - template - struct _Destroy_aux - { - template - static void - __destroy(_ForwardIterator __first, _ForwardIterator __last) - { - for (; __first != __last; ++__first) - std::_Destroy(std::__addressof(*__first)); - } - }; - - template<> - struct _Destroy_aux - { - template - static void - __destroy(_ForwardIterator, _ForwardIterator) { } - }; - - - - - - - template - inline void - _Destroy(_ForwardIterator __first, _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _Value_type; - - - static_assert(is_destructible<_Value_type>::value, - "value type is destructible"); - - - - - - std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: - __destroy(__first, __last); - } - - template - struct _Destroy_n_aux - { - template - static _ForwardIterator - __destroy_n(_ForwardIterator __first, _Size __count) - { - for (; __count > 0; (void)++__first, --__count) - std::_Destroy(std::__addressof(*__first)); - return __first; - } - }; - - template<> - struct _Destroy_n_aux - { - template - static _ForwardIterator - __destroy_n(_ForwardIterator __first, _Size __count) - { - std::advance(__first, __count); - return __first; - } - }; - - - - - - - template - inline _ForwardIterator - _Destroy_n(_ForwardIterator __first, _Size __count) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _Value_type; - - - static_assert(is_destructible<_Value_type>::value, - "value type is destructible"); - - - - - - return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: - __destroy_n(__first, __count); - } - - - template - inline void - destroy(_ForwardIterator __first, _ForwardIterator __last) - { - std::_Destroy(__first, __last); - } - - template - inline _ForwardIterator - destroy_n(_ForwardIterator __first, _Size __count) - { - return std::_Destroy_n(__first, __count); - } - - - -} -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 2 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - struct __allocator_traits_base - { - template - struct __rebind : __replace_first_arg<_Tp, _Up> - { - static_assert(is_same< - typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, - _Tp>::value, - "allocator_traits::rebind_alloc must be A"); - }; - - template - struct __rebind<_Tp, _Up, - __void_t::other>> - { - using type = typename _Tp::template rebind<_Up>::other; - - static_assert(is_same< - typename _Tp::template rebind::other, - _Tp>::value, - "allocator_traits::rebind_alloc must be A"); - }; - - protected: - template - using __pointer = typename _Tp::pointer; - template - using __c_pointer = typename _Tp::const_pointer; - template - using __v_pointer = typename _Tp::void_pointer; - template - using __cv_pointer = typename _Tp::const_void_pointer; - template - using __pocca = typename _Tp::propagate_on_container_copy_assignment; - template - using __pocma = typename _Tp::propagate_on_container_move_assignment; - template - using __pocs = typename _Tp::propagate_on_container_swap; - template - using __equal = __type_identity; - }; - - template - using __alloc_rebind - = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; -# 104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct allocator_traits : __allocator_traits_base - { - - typedef _Alloc allocator_type; - - typedef typename _Alloc::value_type value_type; - - - - - - - using pointer = __detected_or_t; - - private: - - template class _Func, typename _Tp, typename = void> - struct _Ptr - { - using type = typename pointer_traits::template rebind<_Tp>; - }; - - template class _Func, typename _Tp> - struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> - { - using type = _Func<_Alloc>; - }; - - - template - struct _Diff - { using type = typename pointer_traits<_PtrT>::difference_type; }; - - template - struct _Diff<_A2, _PtrT, __void_t> - { using type = typename _A2::difference_type; }; - - - template - struct _Size : make_unsigned<_DiffT> { }; - - template - struct _Size<_A2, _DiffT, __void_t> - { using type = typename _A2::size_type; }; - - public: - - - - - - - using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; - - - - - - - - using void_pointer = typename _Ptr<__v_pointer, void>::type; - - - - - - - - using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; - - - - - - - - using difference_type = typename _Diff<_Alloc, pointer>::type; - - - - - - - - using size_type = typename _Size<_Alloc, difference_type>::type; - - - - - - - - using propagate_on_container_copy_assignment - = __detected_or_t; - - - - - - - - using propagate_on_container_move_assignment - = __detected_or_t; - - - - - - - - using propagate_on_container_swap - = __detected_or_t; - - - - - - - - using is_always_equal - = typename __detected_or_t, __equal, _Alloc>::type; - - template - using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; - template - using rebind_traits = allocator_traits>; - - private: - template - static constexpr auto - _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) - -> decltype(__a.allocate(__n, __hint)) - { return __a.allocate(__n, __hint); } - - template - static constexpr pointer - _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) - { return __a.allocate(__n); } - - template - struct __construct_helper - { - template()->construct( - std::declval<_Tp*>(), std::declval<_Args>()...))> - static true_type __test(int); - - template - static false_type __test(...); - - using type = decltype(__test<_Alloc>(0)); - }; - - template - using __has_construct - = typename __construct_helper<_Tp, _Args...>::type; - - template - static constexpr _Require<__has_construct<_Tp, _Args...>> - _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) - noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) - { __a.construct(__p, std::forward<_Args>(__args)...); } - - template - static constexpr - _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, - is_constructible<_Tp, _Args...>>> - _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) - { - - ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); - - - - } - - template - static constexpr auto - _S_destroy(_Alloc2& __a, _Tp* __p, int) - noexcept(noexcept(__a.destroy(__p))) - -> decltype(__a.destroy(__p)) - { __a.destroy(__p); } - - template - static constexpr void - _S_destroy(_Alloc2&, _Tp* __p, ...) - noexcept(std::is_nothrow_destructible<_Tp>::value) - { std::_Destroy(__p); } - - template - static constexpr auto - _S_max_size(_Alloc2& __a, int) - -> decltype(__a.max_size()) - { return __a.max_size(); } - - template - static constexpr size_type - _S_max_size(_Alloc2&, ...) - { - - - return __gnu_cxx::__numeric_traits::__max - / sizeof(value_type); - } - - template - static constexpr auto - _S_select(_Alloc2& __a, int) - -> decltype(__a.select_on_container_copy_construction()) - { return __a.select_on_container_copy_construction(); } - - template - static constexpr _Alloc2 - _S_select(_Alloc2& __a, ...) - { return __a; } - - public: -# 331 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__]] static pointer - allocate(_Alloc& __a, size_type __n) - { return __a.allocate(__n); } -# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__]] static pointer - allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) - { return _S_allocate(__a, __n, __hint, 0); } -# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static void - deallocate(_Alloc& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 373 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - static auto - construct(_Alloc& __a, _Tp* __p, _Args&&... __args) - noexcept(noexcept(_S_construct(__a, __p, - std::forward<_Args>(__args)...))) - -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) - { _S_construct(__a, __p, std::forward<_Args>(__args)...); } -# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - static void - destroy(_Alloc& __a, _Tp* __p) - noexcept(noexcept(_S_destroy(__a, __p, 0))) - { _S_destroy(__a, __p, 0); } -# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static size_type - max_size(const _Alloc& __a) noexcept - { return _S_max_size(__a, 0); } -# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static _Alloc - select_on_container_copy_construction(const _Alloc& __rhs) - { return _S_select(__rhs, 0); } - }; -# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct allocator_traits> - { - - using allocator_type = allocator<_Tp>; - - - using value_type = _Tp; - - - using pointer = _Tp*; - - - using const_pointer = const _Tp*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - using propagate_on_container_copy_assignment = false_type; - - - using propagate_on_container_move_assignment = true_type; - - - using propagate_on_container_swap = false_type; - - - using is_always_equal = true_type; - - template - using rebind_alloc = allocator<_Up>; - - template - using rebind_traits = allocator_traits>; -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__,__gnu__::__always_inline__]] - static pointer - allocate(allocator_type& __a, size_type __n) - { return __a.allocate(__n); } -# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__,__gnu__::__always_inline__]] - static pointer - allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) - { - - return __a.allocate(__n, __hint); - - - - } -# 513 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__gnu__::__always_inline__]] - static void - deallocate(allocator_type& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, - _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { - - __a.construct(__p, std::forward<_Args>(__args)...); - - - - } -# 550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { - - __a.destroy(__p); - - - - } - - - - - - - [[__gnu__::__always_inline__]] - static size_type - max_size(const allocator_type& __a __attribute__((__unused__))) noexcept - { - - return __a.max_size(); - - - - } - - - - - - - [[__gnu__::__always_inline__]] - static allocator_type - select_on_container_copy_construction(const allocator_type& __rhs) - { return __rhs; } - }; - - - template<> - struct allocator_traits> - { - - using allocator_type = allocator; - - - using value_type = void; - - - using pointer = void*; - - - using const_pointer = const void*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - using propagate_on_container_copy_assignment = false_type; - - - using propagate_on_container_move_assignment = true_type; - - - using propagate_on_container_swap = false_type; - - - using is_always_equal = true_type; - - template - using rebind_alloc = allocator<_Up>; - - template - using rebind_traits = allocator_traits>; - - - static void* - allocate(allocator_type&, size_type, const void* = nullptr) = delete; - - - static void - deallocate(allocator_type&, void*, size_type) = delete; -# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - construct(allocator_type&, _Up* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { std::_Construct(__p, std::forward<_Args>(__args)...); } -# 669 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - destroy(allocator_type&, _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { std::_Destroy(__p); } - - - static size_type - max_size(const allocator_type&) = delete; - - - - - - - [[__gnu__::__always_inline__]] - static allocator_type - select_on_container_copy_construction(const allocator_type& __rhs) - { return __rhs; } - }; -# 707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_copy(_Alloc& __one, const _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocca = - typename __traits::propagate_on_container_copy_assignment::type; - - if constexpr (__pocca::value) - __one = __two; - - - - } - - template - [[__gnu__::__always_inline__]] - constexpr _Alloc - __alloc_on_copy(const _Alloc& __a) - { - typedef allocator_traits<_Alloc> __traits; - return __traits::select_on_container_copy_construction(__a); - } -# 744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_move(_Alloc& __one, _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocma - = typename __traits::propagate_on_container_move_assignment::type; - - if constexpr (__pocma::value) - __one = std::move(__two); - - - - } -# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_swap(_Alloc& __one, _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocs = typename __traits::propagate_on_container_swap::type; - - if constexpr (__pocs::value) - { - using std::swap; - swap(__one, __two); - } - - - - } - - template, - typename = void> - struct __is_alloc_insertable_impl - : false_type - { }; - - template - struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, - __void_t::construct( - std::declval<_Alloc&>(), std::declval<_ValueT*>(), - std::declval<_Tp>()))>> - : true_type - { }; - - - - - template - struct __is_copy_insertable - : __is_alloc_insertable_impl<_Alloc, - typename _Alloc::value_type const&>::type - { }; - - - - template - struct __is_copy_insertable> - : is_copy_constructible<_Tp> - { }; - - - - - - template - struct __is_move_insertable - : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type - { }; - - - - template - struct __is_move_insertable> - : is_move_constructible<_Tp> - { }; - - - - template - struct __is_allocator : false_type { }; - - template - struct __is_allocator<_Alloc, - __void_t().allocate(size_t{}))>> - : true_type { }; - - template - using _RequireAllocator - = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; - - template - using _RequireNotAllocator - = typename enable_if::value, _Alloc>::type; -# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct __alloc_swap - { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; - - template - struct __alloc_swap<_Alloc, false> - { - static void - _S_do_it(_Alloc& __one, _Alloc& __two) noexcept - { - - if (__one != __two) - swap(__one, __two); - } - }; - - - template, - is_nothrow_move_constructible>::value> - struct __shrink_to_fit_aux - { static bool _S_do_it(_Tp&) noexcept { return false; } }; - - template - struct __shrink_to_fit_aux<_Tp, true> - { - - static bool - _S_do_it(_Tp& __c) noexcept - { - - try - { - _Tp(__make_move_if_noexcept_iterator(__c.begin()), - __make_move_if_noexcept_iterator(__c.end()), - __c.get_allocator()).swap(__c); - return true; - } - catch(...) - { return false; } - - - - } - }; -# 925 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - - void - _Destroy(_ForwardIterator __first, _ForwardIterator __last, - _Allocator& __alloc) - { - for (; __first != __last; ++__first) - - - - allocator_traits<_Allocator>::destroy(__alloc, - std::__addressof(*__first)); - - } - - - template - __attribute__((__always_inline__)) - inline void - _Destroy(_ForwardIterator __first, _ForwardIterator __last, - allocator<_Tp>&) - { - std::_Destroy(__first, __last); - } - - - - -} -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 2 3 - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - - - -template - struct __alloc_traits - - : std::allocator_traits<_Alloc> - - { - typedef _Alloc allocator_type; - - typedef std::allocator_traits<_Alloc> _Base_type; - typedef typename _Base_type::value_type value_type; - typedef typename _Base_type::pointer pointer; - typedef typename _Base_type::const_pointer const_pointer; - typedef typename _Base_type::size_type size_type; - typedef typename _Base_type::difference_type difference_type; - - typedef value_type& reference; - typedef const value_type& const_reference; - using _Base_type::allocate; - using _Base_type::deallocate; - using _Base_type::construct; - using _Base_type::destroy; - using _Base_type::max_size; - - private: - template - using __is_custom_pointer - = std::__and_, - std::__not_>>; - - public: - - template - [[__gnu__::__always_inline__]] - static constexpr - std::__enable_if_t<__is_custom_pointer<_Ptr>::value> - construct(_Alloc& __a, _Ptr __p, _Args&&... __args) - noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), - std::forward<_Args>(__args)...))) - { - _Base_type::construct(__a, std::__to_address(__p), - std::forward<_Args>(__args)...); - } - - - template - [[__gnu__::__always_inline__]] - static constexpr - std::__enable_if_t<__is_custom_pointer<_Ptr>::value> - destroy(_Alloc& __a, _Ptr __p) - noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) - { _Base_type::destroy(__a, std::__to_address(__p)); } - - [[__gnu__::__always_inline__]] - static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) - { return _Base_type::select_on_container_copy_construction(__a); } - - [[__gnu__::__always_inline__]] - static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) - { std::__alloc_on_swap(__a, __b); } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_copy_assign() - { return _Base_type::propagate_on_container_copy_assignment::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_move_assign() - { return _Base_type::propagate_on_container_move_assignment::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_swap() - { return _Base_type::propagate_on_container_swap::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_always_equal() - { return _Base_type::is_always_equal::value; } - - __attribute__((__always_inline__)) - static constexpr bool _S_nothrow_move() - { return _S_propagate_on_move_assign() || _S_always_equal(); } - - template - struct rebind - { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; -# 180 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 - }; - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocated_ptr.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocated_ptr.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template - struct __allocated_ptr - { - using pointer = typename allocator_traits<_Alloc>::pointer; - using value_type = typename allocator_traits<_Alloc>::value_type; - - - __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept - : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr) - { } - - - template>> - __allocated_ptr(_Alloc& __a, _Ptr __ptr) - : _M_alloc(std::__addressof(__a)), - _M_ptr(pointer_traits::pointer_to(*__ptr)) - { } - - - __allocated_ptr(__allocated_ptr&& __gd) noexcept - : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr) - { __gd._M_ptr = nullptr; } - - - ~__allocated_ptr() - { - if (_M_ptr != nullptr) - std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1); - } - - - __allocated_ptr& - operator=(std::nullptr_t) noexcept - { - _M_ptr = nullptr; - return *this; - } - - - value_type* get() { return std::__to_address(_M_ptr); } - - private: - _Alloc* _M_alloc; - pointer _M_ptr; - }; - - - template - __allocated_ptr<_Alloc> - __allocate_guarded(_Alloc& __a) - { - return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) }; - } - - - -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/aligned_buffer.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/aligned_buffer.h" 3 - - - - - - - -namespace __gnu_cxx -{ - - - - - template - struct __aligned_membuf - { - - - - - - struct _Tp2 { _Tp _M_t; }; - - alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)]; - - __aligned_membuf() = default; - - - __aligned_membuf(std::nullptr_t) { } - - void* - _M_addr() noexcept - { return static_cast(&_M_storage); } - - const void* - _M_addr() const noexcept - { return static_cast(&_M_storage); } - - _Tp* - _M_ptr() noexcept - { return static_cast<_Tp*>(_M_addr()); } - - const _Tp* - _M_ptr() const noexcept - { return static_cast(_M_addr()); } - }; - - - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - - - - template - struct __aligned_buffer - : std::aligned_storage - { - typename - std::aligned_storage::type _M_storage; - - __aligned_buffer() = default; - - - __aligned_buffer(std::nullptr_t) { } - - void* - _M_addr() noexcept - { - return static_cast(&_M_storage); - } - - const void* - _M_addr() const noexcept - { - return static_cast(&_M_storage); - } - - _Tp* - _M_ptr() noexcept - { return static_cast<_Tp*>(_M_addr()); } - - const _Tp* - _M_ptr() const noexcept - { return static_cast(_M_addr()); } - }; -#pragma GCC diagnostic pop - - -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - namespace __detail - { - - - - - - - - struct _List_node_base - { - _List_node_base* _M_next; - _List_node_base* _M_prev; - - static void - swap(_List_node_base& __x, _List_node_base& __y) noexcept; - - void - _M_transfer(_List_node_base* const __first, - _List_node_base* const __last) noexcept; - - void - _M_reverse() noexcept; - - void - _M_hook(_List_node_base* const __position) noexcept; - - void - _M_unhook() noexcept; - }; - - - struct _List_node_header : public _List_node_base - { - - std::size_t _M_size; - - - _List_node_header() noexcept - { _M_init(); } - - - _List_node_header(_List_node_header&& __x) noexcept - : _List_node_base{ __x._M_next, __x._M_prev } - - , _M_size(__x._M_size) - - { - if (__x._M_base()->_M_next == __x._M_base()) - this->_M_next = this->_M_prev = this; - else - { - this->_M_next->_M_prev = this->_M_prev->_M_next = this->_M_base(); - __x._M_init(); - } - } - - void - _M_move_nodes(_List_node_header&& __x) - { - _List_node_base* const __xnode = __x._M_base(); - if (__xnode->_M_next == __xnode) - _M_init(); - else - { - _List_node_base* const __node = this->_M_base(); - __node->_M_next = __xnode->_M_next; - __node->_M_prev = __xnode->_M_prev; - __node->_M_next->_M_prev = __node->_M_prev->_M_next = __node; - - _M_size = __x._M_size; - - __x._M_init(); - } - } - - - void - _M_init() noexcept - { - this->_M_next = this->_M_prev = this; - - this->_M_size = 0; - - } - - private: - _List_node_base* _M_base() { return this; } - }; - - - struct _Scratch_list : _List_node_base - { - _Scratch_list() { _M_next = _M_prev = this; } - - bool empty() const { return _M_next == this; } - - void swap(_List_node_base& __l) { _List_node_base::swap(*this, __l); } - - template - struct _Ptr_cmp - { - _Cmp _M_cmp; - - bool - operator()(__detail::_List_node_base* __lhs, - __detail::_List_node_base* __rhs) - { return _M_cmp(*_Iter(__lhs), *_Iter(__rhs)); } - }; - - template - struct _Ptr_cmp<_Iter, void> - { - bool - operator()(__detail::_List_node_base* __lhs, - __detail::_List_node_base* __rhs) const - { return *_Iter(__lhs) < *_Iter(__rhs); } - }; - - - template - void - merge(_List_node_base& __x, _Cmp __comp) - { - _List_node_base* __first1 = _M_next; - _List_node_base* const __last1 = this; - _List_node_base* __first2 = __x._M_next; - _List_node_base* const __last2 = std::__addressof(__x); - - while (__first1 != __last1 && __first2 != __last2) - { - if (__comp(__first2, __first1)) - { - _List_node_base* __next = __first2->_M_next; - __first1->_M_transfer(__first2, __next); - __first2 = __next; - } - else - __first1 = __first1->_M_next; - } - if (__first2 != __last2) - this->_M_transfer(__first2, __last2); - } - - - void _M_take_one(_List_node_base* __i) - { this->_M_transfer(__i, __i->_M_next); } - - - void _M_put_all(_List_node_base* __i) - { - if (!empty()) - __i->_M_transfer(_M_next, this); - } - }; - - } - - - - - template - struct _List_node : public __detail::_List_node_base - { - - __gnu_cxx::__aligned_membuf<_Tp> _M_storage; - _Tp* _M_valptr() { return _M_storage._M_ptr(); } - _Tp const* _M_valptr() const { return _M_storage._M_ptr(); } - - - - - - }; - - - - - - - template - struct _List_iterator - { - typedef _List_iterator<_Tp> _Self; - typedef _List_node<_Tp> _Node; - - typedef ptrdiff_t difference_type; - typedef std::bidirectional_iterator_tag iterator_category; - typedef _Tp value_type; - typedef _Tp* pointer; - typedef _Tp& reference; - - _List_iterator() noexcept - : _M_node() { } - - explicit - _List_iterator(__detail::_List_node_base* __x) noexcept - : _M_node(__x) { } - - _Self - _M_const_cast() const noexcept - { return *this; } - - - [[__nodiscard__]] - reference - operator*() const noexcept - { return *static_cast<_Node*>(_M_node)->_M_valptr(); } - - [[__nodiscard__]] - pointer - operator->() const noexcept - { return static_cast<_Node*>(_M_node)->_M_valptr(); } - - _Self& - operator++() noexcept - { - _M_node = _M_node->_M_next; - return *this; - } - - _Self - operator++(int) noexcept - { - _Self __tmp = *this; - _M_node = _M_node->_M_next; - return __tmp; - } - - _Self& - operator--() noexcept - { - _M_node = _M_node->_M_prev; - return *this; - } - - _Self - operator--(int) noexcept - { - _Self __tmp = *this; - _M_node = _M_node->_M_prev; - return __tmp; - } - - [[__nodiscard__]] - friend bool - operator==(const _Self& __x, const _Self& __y) noexcept - { return __x._M_node == __y._M_node; } - - - [[__nodiscard__]] - friend bool - operator!=(const _Self& __x, const _Self& __y) noexcept - { return __x._M_node != __y._M_node; } - - - - __detail::_List_node_base* _M_node; - }; - - - - - - - template - struct _List_const_iterator - { - typedef _List_const_iterator<_Tp> _Self; - typedef const _List_node<_Tp> _Node; - typedef _List_iterator<_Tp> iterator; - - typedef ptrdiff_t difference_type; - typedef std::bidirectional_iterator_tag iterator_category; - typedef _Tp value_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; - - _List_const_iterator() noexcept - : _M_node() { } - - explicit - _List_const_iterator(const __detail::_List_node_base* __x) - noexcept - : _M_node(__x) { } - - _List_const_iterator(const iterator& __x) noexcept - : _M_node(__x._M_node) { } - - iterator - _M_const_cast() const noexcept - { return iterator(const_cast<__detail::_List_node_base*>(_M_node)); } - - - [[__nodiscard__]] - reference - operator*() const noexcept - { return *static_cast<_Node*>(_M_node)->_M_valptr(); } - - [[__nodiscard__]] - pointer - operator->() const noexcept - { return static_cast<_Node*>(_M_node)->_M_valptr(); } - - _Self& - operator++() noexcept - { - _M_node = _M_node->_M_next; - return *this; - } - - _Self - operator++(int) noexcept - { - _Self __tmp = *this; - _M_node = _M_node->_M_next; - return __tmp; - } - - _Self& - operator--() noexcept - { - _M_node = _M_node->_M_prev; - return *this; - } - - _Self - operator--(int) noexcept - { - _Self __tmp = *this; - _M_node = _M_node->_M_prev; - return __tmp; - } - - [[__nodiscard__]] - friend bool - operator==(const _Self& __x, const _Self& __y) noexcept - { return __x._M_node == __y._M_node; } - - - [[__nodiscard__]] - friend bool - operator!=(const _Self& __x, const _Self& __y) noexcept - { return __x._M_node != __y._M_node; } - - - - const __detail::_List_node_base* _M_node; - }; - -namespace __cxx11 { - - template - class _List_base - { - protected: - typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template - rebind<_Tp>::other _Tp_alloc_type; - typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tp_alloc_traits; - typedef typename _Tp_alloc_traits::template - rebind<_List_node<_Tp> >::other _Node_alloc_type; - typedef __gnu_cxx::__alloc_traits<_Node_alloc_type> _Node_alloc_traits; - - - static size_t - _S_distance(const __detail::_List_node_base* __first, - const __detail::_List_node_base* __last) - { - size_t __n = 0; - while (__first != __last) - { - __first = __first->_M_next; - ++__n; - } - return __n; - } - - - struct _List_impl - : public _Node_alloc_type - { - __detail::_List_node_header _M_node; - - _List_impl() noexcept(is_nothrow_default_constructible<_Node_alloc_type>::value) - - : _Node_alloc_type() - { } - - _List_impl(const _Node_alloc_type& __a) noexcept - : _Node_alloc_type(__a) - { } - - - _List_impl(_List_impl&&) = default; - - _List_impl(_Node_alloc_type&& __a, _List_impl&& __x) - : _Node_alloc_type(std::move(__a)), _M_node(std::move(__x._M_node)) - { } - - _List_impl(_Node_alloc_type&& __a) noexcept - : _Node_alloc_type(std::move(__a)) - { } - - }; - - _List_impl _M_impl; - - - size_t _M_get_size() const { return _M_impl._M_node._M_size; } - - void _M_set_size(size_t __n) { _M_impl._M_node._M_size = __n; } - - void _M_inc_size(size_t __n) { _M_impl._M_node._M_size += __n; } - - void _M_dec_size(size_t __n) { _M_impl._M_node._M_size -= __n; } - - - size_t - _M_distance(const __detail::_List_node_base* __first, - const __detail::_List_node_base* __last) const - { return _S_distance(__first, __last); } - - - size_t _M_node_count() const { return _M_get_size(); } -# 516 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - typename _Node_alloc_traits::pointer - _M_get_node() - { return _Node_alloc_traits::allocate(_M_impl, 1); } - - void - _M_put_node(typename _Node_alloc_traits::pointer __p) noexcept - { _Node_alloc_traits::deallocate(_M_impl, __p, 1); } - - public: - typedef _Alloc allocator_type; - - _Node_alloc_type& - _M_get_Node_allocator() noexcept - { return _M_impl; } - - const _Node_alloc_type& - _M_get_Node_allocator() const noexcept - { return _M_impl; } - - - _List_base() = default; - - - - - _List_base(const _Node_alloc_type& __a) noexcept - : _M_impl(__a) - { } - - - _List_base(_List_base&&) = default; - - - _List_base(_List_base&& __x, _Node_alloc_type&& __a) - : _M_impl(std::move(__a)) - { - if (__x._M_get_Node_allocator() == _M_get_Node_allocator()) - _M_move_nodes(std::move(__x)); - - } - - - - _List_base(_Node_alloc_type&& __a, _List_base&& __x) - : _M_impl(std::move(__a), std::move(__x._M_impl)) - { } - - - _List_base(_Node_alloc_type&& __a) - : _M_impl(std::move(__a)) - { } - - void - _M_move_nodes(_List_base&& __x) - { _M_impl._M_node._M_move_nodes(std::move(__x._M_impl._M_node)); } - - - - ~_List_base() noexcept - { _M_clear(); } - - void - _M_clear() noexcept; - - void - _M_init() noexcept - { this->_M_impl._M_node._M_init(); } - }; -# 631 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template > - class list : protected _List_base<_Tp, _Alloc> - { -# 644 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - static_assert(is_same::type, _Tp>::value, - "std::list must have a non-const, non-volatile value_type"); - - static_assert(is_same::value, - "std::list must have the same value_type as its allocator"); - - - - typedef _List_base<_Tp, _Alloc> _Base; - typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; - typedef typename _Base::_Tp_alloc_traits _Tp_alloc_traits; - typedef typename _Base::_Node_alloc_type _Node_alloc_type; - typedef typename _Base::_Node_alloc_traits _Node_alloc_traits; - - public: - typedef _Tp value_type; - typedef typename _Tp_alloc_traits::pointer pointer; - typedef typename _Tp_alloc_traits::const_pointer const_pointer; - typedef typename _Tp_alloc_traits::reference reference; - typedef typename _Tp_alloc_traits::const_reference const_reference; - typedef _List_iterator<_Tp> iterator; - typedef _List_const_iterator<_Tp> const_iterator; - typedef std::reverse_iterator const_reverse_iterator; - typedef std::reverse_iterator reverse_iterator; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Alloc allocator_type; - - protected: - - - typedef _List_node<_Tp> _Node; - - using _Base::_M_impl; - using _Base::_M_put_node; - using _Base::_M_get_node; - using _Base::_M_get_Node_allocator; -# 706 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template - _Node* - _M_create_node(_Args&&... __args) - { - auto __p = this->_M_get_node(); - auto& __alloc = _M_get_Node_allocator(); - __allocated_ptr<_Node_alloc_type> __guard{__alloc, __p}; - _Node_alloc_traits::construct(__alloc, __p->_M_valptr(), - std::forward<_Args>(__args)...); - __guard = nullptr; - return __p; - } - - - - static size_t - _S_distance(const_iterator __first, const_iterator __last) - { return std::distance(__first, __last); } - - - size_t - _M_node_count() const - { return this->_M_get_size(); } -# 741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - public: - - - - - - - - list() = default; -# 758 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - explicit - list(const allocator_type& __a) noexcept - : _Base(_Node_alloc_type(__a)) { } -# 771 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - explicit - list(size_type __n, const allocator_type& __a = allocator_type()) - : _Base(_Node_alloc_type(__a)) - { _M_default_initialize(__n); } -# 784 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - list(size_type __n, const value_type& __value, - const allocator_type& __a = allocator_type()) - : _Base(_Node_alloc_type(__a)) - { _M_fill_initialize(__n, __value); } -# 811 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - list(const list& __x) - : _Base(_Node_alloc_traits:: - _S_select_on_copy(__x._M_get_Node_allocator())) - { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } -# 824 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - list(list&&) = default; -# 834 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - list(initializer_list __l, - const allocator_type& __a = allocator_type()) - : _Base(_Node_alloc_type(__a)) - { _M_initialize_dispatch(__l.begin(), __l.end(), __false_type()); } - - list(const list& __x, const __type_identity_t& __a) - : _Base(_Node_alloc_type(__a)) - { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } - - private: - list(list&& __x, const allocator_type& __a, true_type) noexcept - : _Base(_Node_alloc_type(__a), std::move(__x)) - { } - - list(list&& __x, const allocator_type& __a, false_type) - : _Base(_Node_alloc_type(__a)) - { - if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator()) - this->_M_move_nodes(std::move(__x)); - else - insert(begin(), std::__make_move_if_noexcept_iterator(__x.begin()), - std::__make_move_if_noexcept_iterator(__x.end())); - } - - public: - list(list&& __x, const __type_identity_t& __a) - noexcept(_Node_alloc_traits::_S_always_equal()) - : list(std::move(__x), __a, - typename _Node_alloc_traits::is_always_equal{}) - { } -# 877 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template> - list(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) - : _Base(_Node_alloc_type(__a)) - { _M_initialize_dispatch(__first, __last, __false_type()); } -# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - ~list() = default; -# 914 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - list& - operator=(const list& __x); -# 928 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - list& - operator=(list&& __x) - noexcept(_Node_alloc_traits::_S_nothrow_move()) - { - constexpr bool __move_storage = - _Node_alloc_traits::_S_propagate_on_move_assign() - || _Node_alloc_traits::_S_always_equal(); - _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); - return *this; - } -# 946 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - list& - operator=(initializer_list __l) - { - this->assign(__l.begin(), __l.end()); - return *this; - } -# 964 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - assign(size_type __n, const value_type& __val) - { _M_fill_assign(__n, __val); } -# 981 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template> - void - assign(_InputIterator __first, _InputIterator __last) - { _M_assign_dispatch(__first, __last, __false_type()); } -# 1005 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - assign(initializer_list __l) - { this->_M_assign_dispatch(__l.begin(), __l.end(), __false_type()); } - - - - allocator_type - get_allocator() const noexcept - { return allocator_type(_Base::_M_get_Node_allocator()); } - - - - - - - [[__nodiscard__]] - iterator - begin() noexcept - { return iterator(this->_M_impl._M_node._M_next); } - - - - - - - [[__nodiscard__]] - const_iterator - begin() const noexcept - { return const_iterator(this->_M_impl._M_node._M_next); } - - - - - - - [[__nodiscard__]] - iterator - end() noexcept - { return iterator(&this->_M_impl._M_node); } - - - - - - - [[__nodiscard__]] - const_iterator - end() const noexcept - { return const_iterator(&this->_M_impl._M_node); } - - - - - - - [[__nodiscard__]] - reverse_iterator - rbegin() noexcept - { return reverse_iterator(end()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - rbegin() const noexcept - { return const_reverse_iterator(end()); } - - - - - - - [[__nodiscard__]] - reverse_iterator - rend() noexcept - { return reverse_iterator(begin()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - rend() const noexcept - { return const_reverse_iterator(begin()); } - - - - - - - - [[__nodiscard__]] - const_iterator - cbegin() const noexcept - { return const_iterator(this->_M_impl._M_node._M_next); } - - - - - - - [[__nodiscard__]] - const_iterator - cend() const noexcept - { return const_iterator(&this->_M_impl._M_node); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(end()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(begin()); } - - - - - - - - [[__nodiscard__]] bool - empty() const noexcept - { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; } - - - [[__nodiscard__]] - size_type - size() const noexcept - { return _M_node_count(); } - - - [[__nodiscard__]] - size_type - max_size() const noexcept - { return _Node_alloc_traits::max_size(_M_get_Node_allocator()); } -# 1168 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - resize(size_type __new_size); -# 1181 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - resize(size_type __new_size, const value_type& __x); -# 1203 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - [[__nodiscard__]] - reference - front() noexcept - { return *begin(); } - - - - - - [[__nodiscard__]] - const_reference - front() const noexcept - { return *begin(); } - - - - - - [[__nodiscard__]] - reference - back() noexcept - { - iterator __tmp = end(); - --__tmp; - return *__tmp; - } - - - - - - [[__nodiscard__]] - const_reference - back() const noexcept - { - const_iterator __tmp = end(); - --__tmp; - return *__tmp; - } -# 1254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - push_front(const value_type& __x) - { this->_M_insert(begin(), __x); } - - - void - push_front(value_type&& __x) - { this->_M_insert(begin(), std::move(__x)); } - - template - - reference - - - - emplace_front(_Args&&... __args) - { - this->_M_insert(begin(), std::forward<_Args>(__args)...); - - return front(); - - } -# 1290 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - pop_front() noexcept - { this->_M_erase(begin()); } -# 1304 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - push_back(const value_type& __x) - { this->_M_insert(end(), __x); } - - - void - push_back(value_type&& __x) - { this->_M_insert(end(), std::move(__x)); } - - template - - reference - - - - emplace_back(_Args&&... __args) - { - this->_M_insert(end(), std::forward<_Args>(__args)...); - - return back(); - - } -# 1339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - pop_back() noexcept - { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); } -# 1356 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template - iterator - emplace(const_iterator __position, _Args&&... __args); -# 1371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - iterator - insert(const_iterator __position, const value_type& __x); -# 1401 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - iterator - insert(const_iterator __position, value_type&& __x) - { return emplace(__position, std::move(__x)); } -# 1420 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - iterator - insert(const_iterator __p, initializer_list __l) - { return this->insert(__p, __l.begin(), __l.end()); } -# 1440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - iterator - insert(const_iterator __position, size_type __n, const value_type& __x); -# 1479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template> - iterator - insert(const_iterator __position, _InputIterator __first, - _InputIterator __last); -# 1523 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - iterator - - erase(const_iterator __position) noexcept; -# 1548 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - iterator - - erase(const_iterator __first, const_iterator __last) noexcept - - - - { - while (__first != __last) - __first = erase(__first); - return __last._M_const_cast(); - } -# 1571 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - swap(list& __x) noexcept - { - __detail::_List_node_base::swap(this->_M_impl._M_node, - __x._M_impl._M_node); - - size_t __xsize = __x._M_get_size(); - __x._M_set_size(this->_M_get_size()); - this->_M_set_size(__xsize); - - _Node_alloc_traits::_S_on_swap(this->_M_get_Node_allocator(), - __x._M_get_Node_allocator()); - } - - - - - - - - void - clear() noexcept - { - _Base::_M_clear(); - _Base::_M_init(); - } -# 1610 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - - splice(const_iterator __position, list&& __x) noexcept - - - - { - if (!__x.empty()) - { - _M_check_equal_allocators(__x); - - this->_M_transfer(__position._M_const_cast(), - __x.begin(), __x.end()); - - this->_M_inc_size(__x._M_get_size()); - __x._M_set_size(0); - } - } - - - void - splice(const_iterator __position, list& __x) noexcept - { splice(__position, std::move(__x)); } -# 1646 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - splice(const_iterator __position, list&& __x, const_iterator __i) noexcept -# 1661 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - { - iterator __j = __i._M_const_cast(); - ++__j; - if (__position == __i || __position == __j) - return; - - if (this != std::__addressof(__x)) - _M_check_equal_allocators(__x); - - this->_M_transfer(__position._M_const_cast(), - __i._M_const_cast(), __j); - - this->_M_inc_size(1); - __x._M_dec_size(1); - } -# 1688 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - splice(const_iterator __position, list& __x, const_iterator __i) noexcept - { splice(__position, std::move(__x), __i); } -# 1707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - splice(const_iterator __position, list&& __x, const_iterator __first, - const_iterator __last) noexcept -# 1727 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - { - if (__first != __last) - { - if (this != std::__addressof(__x)) - _M_check_equal_allocators(__x); - - size_t __n = _S_distance(__first, __last); - this->_M_inc_size(__n); - __x._M_dec_size(__n); - - this->_M_transfer(__position._M_const_cast(), - __first._M_const_cast(), - __last._M_const_cast()); - } - } -# 1757 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - splice(const_iterator __position, list& __x, const_iterator __first, - const_iterator __last) noexcept - { splice(__position, std::move(__x), __first, __last); } - - - private: - - - - - - - typedef void __remove_return_type; - - - public: -# 1787 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - __remove_return_type - remove(const _Tp& __value); -# 1801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template - __remove_return_type - remove_if(_Predicate); -# 1816 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - __remove_return_type - unique(); -# 1831 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template - __remove_return_type - unique(_BinaryPredicate); -# 1847 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - merge(list&& __x); - - void - merge(list& __x) - { merge(std::move(__x)); } -# 1872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template - void - merge(list&& __x, _StrictWeakOrdering __comp); - - template - void - merge(list& __x, _StrictWeakOrdering __comp) - { merge(std::move(__x), __comp); } -# 1891 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - void - reverse() noexcept - { this->_M_impl._M_node._M_reverse(); } - - - - - - - - void - sort(); - - - - - - - - template - void - sort(_StrictWeakOrdering); - - protected: - - - - - - - template - void - _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) - { _M_fill_initialize(static_cast(__n), __x); } - - - template - void - _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, - __false_type) - { - for (; __first != __last; ++__first) - - emplace_back(*__first); - - - - } - - - - void - _M_fill_initialize(size_type __n, const value_type& __x) - { - for (; __n; --__n) - push_back(__x); - } - - - - void - _M_default_initialize(size_type __n) - { - for (; __n; --__n) - emplace_back(); - } - - - void - _M_default_append(size_type __n); -# 1969 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template - void - _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) - { _M_fill_assign(__n, __val); } - - - template - void - _M_assign_dispatch(_InputIterator __first, _InputIterator __last, - __false_type); - - - - void - _M_fill_assign(size_type __n, const value_type& __val); - - - - void - _M_transfer(iterator __position, iterator __first, iterator __last) - { __position._M_node->_M_transfer(__first._M_node, __last._M_node); } -# 2001 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template - void - _M_insert(iterator __position, _Args&&... __args) - { - _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); - __tmp->_M_hook(__position._M_node); - this->_M_inc_size(1); - } - - - - void - _M_erase(iterator __position) noexcept - { - this->_M_dec_size(1); - __position._M_node->_M_unhook(); - _Node* __n = static_cast<_Node*>(__position._M_node); - - _Node_alloc_traits::destroy(_M_get_Node_allocator(), __n->_M_valptr()); - - - - - _M_put_node(__n); - } - - - void - _M_check_equal_allocators(const list& __x) noexcept - { - if (_M_get_Node_allocator() != __x._M_get_Node_allocator()) - __builtin_abort(); - } - - - const_iterator - _M_resize_pos(size_type& __new_size) const; - - - void - _M_move_assign(list&& __x, true_type) noexcept - { - this->clear(); - this->_M_move_nodes(std::move(__x)); - std::__alloc_on_move(this->_M_get_Node_allocator(), - __x._M_get_Node_allocator()); - } - - void - _M_move_assign(list&& __x, false_type) - { - if (__x._M_get_Node_allocator() == this->_M_get_Node_allocator()) - _M_move_assign(std::move(__x), true_type{}); - else - - - _M_assign_dispatch(std::make_move_iterator(__x.begin()), - std::make_move_iterator(__x.end()), - __false_type{}); - } - - - - - struct _Finalize_merge - { - explicit - _Finalize_merge(list& __dest, list& __src, const iterator& __src_next) - : _M_dest(__dest), _M_src(__src), _M_next(__src_next) - { } - - ~_Finalize_merge() - { - - - - const size_t __num_unmerged = std::distance(_M_next, _M_src.end()); - const size_t __orig_size = _M_src._M_get_size(); - _M_dest._M_inc_size(__orig_size - __num_unmerged); - _M_src._M_set_size(__num_unmerged); - } - - list& _M_dest; - list& _M_src; - const iterator& _M_next; - - - _Finalize_merge(const _Finalize_merge&) = delete; - - }; - - - - - - }; - - - template::value_type, - typename _Allocator = allocator<_ValT>, - typename = _RequireInputIter<_InputIterator>, - typename = _RequireAllocator<_Allocator>> - list(_InputIterator, _InputIterator, _Allocator = _Allocator()) - -> list<_ValT, _Allocator>; - - -} -# 2120 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template - [[__nodiscard__]] - inline bool - operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) - { - - if (__x.size() != __y.size()) - return false; - - - typedef typename list<_Tp, _Alloc>::const_iterator const_iterator; - const_iterator __end1 = __x.end(); - const_iterator __end2 = __y.end(); - - const_iterator __i1 = __x.begin(); - const_iterator __i2 = __y.begin(); - while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) - { - ++__i1; - ++__i2; - } - return __i1 == __end1 && __i2 == __end2; - } -# 2177 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_list.h" 3 - template - [[__nodiscard__]] - inline bool - operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) - { return std::lexicographical_compare(__x.begin(), __x.end(), - __y.begin(), __y.end()); } - - - template - [[__nodiscard__]] - inline bool - operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) - { return !(__x == __y); } - - - template - [[__nodiscard__]] - inline bool - operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) - { return __y < __x; } - - - template - [[__nodiscard__]] - inline bool - operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) - { return !(__y < __x); } - - - template - [[__nodiscard__]] - inline bool - operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) - { return !(__x < __y); } - - - - template - inline void - swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } - - - - - - - template - inline ptrdiff_t - __distance(std::_List_iterator<_Tp> __first, - std::_List_iterator<_Tp> __last, - input_iterator_tag __tag) - { - typedef std::_List_const_iterator<_Tp> _CIter; - return std::__distance(_CIter(__first), _CIter(__last), __tag); - } - - template - inline ptrdiff_t - __distance(std::_List_const_iterator<_Tp> __first, - std::_List_const_iterator<_Tp> __last, - input_iterator_tag) - { - typedef __detail::_List_node_header _Sentinel; - std::_List_const_iterator<_Tp> __beyond = __last; - ++__beyond; - const bool __whole = __first == __beyond; - if (__builtin_constant_p (__whole) && __whole) - return static_cast(__last._M_node)->_M_size; - - ptrdiff_t __n = 0; - while (__first != __last) - { - ++__first; - ++__n; - } - return __n; - } - - - -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 1 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - void - _List_base<_Tp, _Alloc>:: - _M_clear() noexcept - { - typedef _List_node<_Tp> _Node; - __detail::_List_node_base* __cur = _M_impl._M_node._M_next; - while (__cur != &_M_impl._M_node) - { - _Node* __tmp = static_cast<_Node*>(__cur); - __cur = __tmp->_M_next; - _Tp* __val = __tmp->_M_valptr(); - - _Node_alloc_traits::destroy(_M_get_Node_allocator(), __val); - - - - _M_put_node(__tmp); - } - } - - - template - template - typename list<_Tp, _Alloc>::iterator - list<_Tp, _Alloc>:: - emplace(const_iterator __position, _Args&&... __args) - { - _Node* __tmp = _M_create_node(std::forward<_Args>(__args)...); - __tmp->_M_hook(__position._M_const_cast()._M_node); - this->_M_inc_size(1); - return iterator(__tmp); - } - - - template - typename list<_Tp, _Alloc>::iterator - list<_Tp, _Alloc>:: - - insert(const_iterator __position, const value_type& __x) - - - - { - _Node* __tmp = _M_create_node(__x); - __tmp->_M_hook(__position._M_const_cast()._M_node); - this->_M_inc_size(1); - return iterator(__tmp); - } - - - template - typename list<_Tp, _Alloc>::iterator - list<_Tp, _Alloc>:: - insert(const_iterator __position, size_type __n, const value_type& __x) - { - if (__n) - { - list __tmp(__n, __x, get_allocator()); - iterator __it = __tmp.begin(); - splice(__position, __tmp); - return __it; - } - return __position._M_const_cast(); - } - - template - template - typename list<_Tp, _Alloc>::iterator - list<_Tp, _Alloc>:: - insert(const_iterator __position, _InputIterator __first, - _InputIterator __last) - { - list __tmp(__first, __last, get_allocator()); - if (!__tmp.empty()) - { - iterator __it = __tmp.begin(); - splice(__position, __tmp); - return __it; - } - return __position._M_const_cast(); - } - - - template - typename list<_Tp, _Alloc>::iterator - list<_Tp, _Alloc>:: - - erase(const_iterator __position) noexcept - - - - { - iterator __ret = iterator(__position._M_node->_M_next); - _M_erase(__position._M_const_cast()); - return __ret; - } -# 173 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 3 - template - typename list<_Tp, _Alloc>::const_iterator - list<_Tp, _Alloc>:: - _M_resize_pos(size_type& __new_size) const - { - const_iterator __i; - - const size_type __len = size(); - if (__new_size < __len) - { - if (__new_size <= __len / 2) - { - __i = begin(); - std::advance(__i, __new_size); - } - else - { - __i = end(); - ptrdiff_t __num_erase = __len - __new_size; - std::advance(__i, -__num_erase); - } - __new_size = 0; - return __i; - } - else - __i = end(); - - - - - - __new_size -= __len; - return __i; - } - - - template - void - list<_Tp, _Alloc>:: - _M_default_append(size_type __n) - { - size_type __i = 0; - try - { - for (; __i < __n; ++__i) - emplace_back(); - } - catch(...) - { - for (; __i; --__i) - pop_back(); - throw; - } - } - - template - void - list<_Tp, _Alloc>:: - resize(size_type __new_size) - { - const_iterator __i = _M_resize_pos(__new_size); - if (__new_size) - _M_default_append(__new_size); - else - erase(__i, end()); - } - - template - void - list<_Tp, _Alloc>:: - resize(size_type __new_size, const value_type& __x) - { - const_iterator __i = _M_resize_pos(__new_size); - if (__new_size) - insert(end(), __new_size, __x); - else - erase(__i, end()); - } -# 265 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 3 - template - list<_Tp, _Alloc>& - list<_Tp, _Alloc>:: - operator=(const list& __x) - { - if (this != std::__addressof(__x)) - { - - if (_Node_alloc_traits::_S_propagate_on_copy_assign()) - { - auto& __this_alloc = this->_M_get_Node_allocator(); - auto& __that_alloc = __x._M_get_Node_allocator(); - if (!_Node_alloc_traits::_S_always_equal() - && __this_alloc != __that_alloc) - { - - clear(); - } - std::__alloc_on_copy(__this_alloc, __that_alloc); - } - - _M_assign_dispatch(__x.begin(), __x.end(), __false_type()); - } - return *this; - } - - template - void - list<_Tp, _Alloc>:: - _M_fill_assign(size_type __n, const value_type& __val) - { - iterator __i = begin(); - for (; __i != end() && __n > 0; ++__i, --__n) - *__i = __val; - if (__n > 0) - insert(end(), __n, __val); - else - erase(__i, end()); - } - - template - template - void - list<_Tp, _Alloc>:: - _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2, - __false_type) - { - iterator __first1 = begin(); - iterator __last1 = end(); - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - *__first1 = *__first2; - if (__first2 == __last2) - erase(__first1, __last1); - else - insert(__last1, __first2, __last2); - } - - - - - - - - template - typename list<_Tp, _Alloc>::__remove_return_type - list<_Tp, _Alloc>:: - remove(const value_type& __value) - { - - - - list __to_destroy(get_allocator()); - iterator __first = begin(); - iterator __last = end(); - while (__first != __last) - { - iterator __next = __first; - ++__next; - if (*__first == __value) - { - - - - __to_destroy.splice(__to_destroy.begin(), *this, __first); - - - - } - - __first = __next; - } - - - - - return ; - - } - - template - typename list<_Tp, _Alloc>::__remove_return_type - list<_Tp, _Alloc>:: - unique() - { - iterator __first = begin(); - iterator __last = end(); - if (__first == __last) - return ; - - - - list __to_destroy(get_allocator()); - iterator __next = __first; - while (++__next != __last) - { - if (*__first == *__next) - { - __to_destroy.splice(__to_destroy.begin(), *this, __next); - - - - } - else - __first = __next; - __next = __first; - } - - - - - return ; - - } - - template - void - list<_Tp, _Alloc>:: - - merge(list&& __x) - - - - { - - - if (this != std::__addressof(__x)) - { - _M_check_equal_allocators(__x); - - iterator __first1 = begin(); - iterator __last1 = end(); - iterator __first2 = __x.begin(); - iterator __last2 = __x.end(); - - const _Finalize_merge __fin(*this, __x, __first2); - - while (__first1 != __last1 && __first2 != __last2) - if (*__first2 < *__first1) - { - iterator __next = __first2; - _M_transfer(__first1, __first2, ++__next); - __first2 = __next; - } - else - ++__first1; - if (__first2 != __last2) - { - _M_transfer(__last1, __first2, __last2); - __first2 = __last2; - } - } - } - - template - template - void - list<_Tp, _Alloc>:: - - merge(list&& __x, _StrictWeakOrdering __comp) - - - - { - - - if (this != std::__addressof(__x)) - { - _M_check_equal_allocators(__x); - - iterator __first1 = begin(); - iterator __last1 = end(); - iterator __first2 = __x.begin(); - iterator __last2 = __x.end(); - - const _Finalize_merge __fin(*this, __x, __first2); - - while (__first1 != __last1 && __first2 != __last2) - if (__comp(*__first2, *__first1)) - { - iterator __next = __first2; - _M_transfer(__first1, __first2, ++__next); - __first2 = __next; - } - else - ++__first1; - if (__first2 != __last2) - { - _M_transfer(__last1, __first2, __last2); - __first2 = __last2; - } - } - } - - template - void - list<_Tp, _Alloc>:: - sort() - { - - if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node - && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) - { - using __detail::_Scratch_list; -# 497 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/list.tcc" 3 - _Scratch_list __carry; - _Scratch_list __tmp[64]; - _Scratch_list* __fill = __tmp; - _Scratch_list* __counter; - - _Scratch_list::_Ptr_cmp __ptr_comp; - - try - { - do - { - __carry._M_take_one(begin()._M_node); - - for(__counter = __tmp; - __counter != __fill && !__counter->empty(); - ++__counter) - { - - __counter->merge(__carry, __ptr_comp); - __carry.swap(*__counter); - } - __carry.swap(*__counter); - if (__counter == __fill) - ++__fill; - } - while ( !empty() ); - - for (__counter = __tmp + 1; __counter != __fill; ++__counter) - __counter->merge(__counter[-1], __ptr_comp); - __fill[-1].swap(this->_M_impl._M_node); - } - catch(...) - { - - __carry._M_put_all(end()._M_node); - for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i) - __tmp[__i]._M_put_all(end()._M_node); - throw; - } - } - } - - template - template - typename list<_Tp, _Alloc>::__remove_return_type - list<_Tp, _Alloc>:: - remove_if(_Predicate __pred) - { - - - - list __to_destroy(get_allocator()); - iterator __first = begin(); - iterator __last = end(); - while (__first != __last) - { - iterator __next = __first; - ++__next; - if (__pred(*__first)) - { - __to_destroy.splice(__to_destroy.begin(), *this, __first); - - - - } - __first = __next; - } - - - - - return ; - - } - - template - template - typename list<_Tp, _Alloc>::__remove_return_type - list<_Tp, _Alloc>:: - unique(_BinaryPredicate __binary_pred) - { - iterator __first = begin(); - iterator __last = end(); - if (__first == __last) - return ; - - - - list __to_destroy(get_allocator()); - iterator __next = __first; - while (++__next != __last) - { - if (__binary_pred(*__first, *__next)) - { - __to_destroy.splice(__to_destroy.begin(), *this, __next); - - - - } - else - __first = __next; - __next = __first; - } - - - - - return ; - - } - - - - template - template - void - list<_Tp, _Alloc>:: - sort(_StrictWeakOrdering __comp) - { - - if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node - && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) - { - using __detail::_Scratch_list; - _Scratch_list __carry; - _Scratch_list __tmp[64]; - _Scratch_list* __fill = __tmp; - _Scratch_list* __counter; - - _Scratch_list::_Ptr_cmp __ptr_comp - = { __comp }; - - try - { - do - { - __carry._M_take_one(begin()._M_node); - - for(__counter = __tmp; - __counter != __fill && !__counter->empty(); - ++__counter) - { - - __counter->merge(__carry, __ptr_comp); - __carry.swap(*__counter); - } - __carry.swap(*__counter); - if (__counter == __fill) - ++__fill; - } - while ( !empty() ); - - for (__counter = __tmp + 1; __counter != __fill; ++__counter) - __counter->merge(__counter[-1], __ptr_comp); - __fill[-1].swap(this->_M_impl._M_node); - } - catch(...) - { - - __carry._M_put_all(end()._M_node); - for (int __i = 0; __i < sizeof(__tmp)/sizeof(__tmp[0]); ++__i) - __tmp[__i]._M_put_all(end()._M_node); - throw; - } - } - } - - - -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 1 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 - - - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 -# 35 "/usr/lib/clang/16/include/stddef.h" 3 -typedef long int ptrdiff_t; -# 46 "/usr/lib/clang/16/include/stddef.h" 3 -typedef long unsigned int size_t; -# 109 "/usr/lib/clang/16/include/stddef.h" 3 -# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 -# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 -typedef struct { - long long __clang_max_align_nonce1 - __attribute__((__aligned__(__alignof__(long long)))); - long double __clang_max_align_nonce2 - __attribute__((__aligned__(__alignof__(long double)))); -} max_align_t; -# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 -# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 2 3 - -extern "C++" -{ - -namespace std -{ - - using ::max_align_t; -} - - - -namespace std -{ - - - - - enum class byte : unsigned char {}; - - template struct __byte_operand { }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - - - - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; -# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - - template - using __byte_op_t = typename __byte_operand<_IntegerType>::__type; - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType> - operator<<(byte __b, _IntegerType __shift) noexcept - { return (byte)(unsigned char)((unsigned)__b << __shift); } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType> - operator>>(byte __b, _IntegerType __shift) noexcept - { return (byte)(unsigned char)((unsigned)__b >> __shift); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator|(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator&(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator^(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator~(byte __b) noexcept - { return (byte)(unsigned char)~(unsigned)__b; } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType>& - operator<<=(byte& __b, _IntegerType __shift) noexcept - { return __b = __b << __shift; } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType>& - operator>>=(byte& __b, _IntegerType __shift) noexcept - { return __b = __b >> __shift; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator|=(byte& __l, byte __r) noexcept - { return __l = __l | __r; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator&=(byte& __l, byte __r) noexcept - { return __l = __l & __r; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator^=(byte& __l, byte __r) noexcept - { return __l = __l ^ __r; } - - template - [[nodiscard,__gnu__::__always_inline__]] - constexpr _IntegerType - to_integer(__byte_op_t<_IntegerType> __b) noexcept - { return _IntegerType(__b); } - - -} - -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - struct __erased_type { }; - - - - - template - using __is_erased_or_convertible - = __or_, is_same<_Tp, __erased_type>>; - - - struct allocator_arg_t { explicit allocator_arg_t() = default; }; - - inline constexpr allocator_arg_t allocator_arg = - allocator_arg_t(); - - template> - struct __uses_allocator_helper - : false_type { }; - - template - struct __uses_allocator_helper<_Tp, _Alloc, - __void_t> - : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type - { }; - - - template - struct uses_allocator - : __uses_allocator_helper<_Tp, _Alloc>::type - { }; - - struct __uses_alloc_base { }; - - struct __uses_alloc0 : __uses_alloc_base - { - struct _Sink { void operator=(const void*) { } } _M_a; - }; - - template - struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; - - template - struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; - - template - struct __uses_alloc; - - template - struct __uses_alloc - : __conditional_t< - is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, - __uses_alloc1<_Alloc>, - __uses_alloc2<_Alloc>> - { - - - static_assert(__or_< - is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, - is_constructible<_Tp, _Args..., const _Alloc&>>::value, - "construction with an allocator must be possible" - " if uses_allocator is true"); - }; - - template - struct __uses_alloc - : __uses_alloc0 { }; - - template - using __uses_alloc_t = - __uses_alloc::value, _Tp, _Alloc, _Args...>; - - template - - inline __uses_alloc_t<_Tp, _Alloc, _Args...> - __use_alloc(const _Alloc& __a) - { - __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; - __ret._M_a = std::__addressof(__a); - return __ret; - } - - template - void - __use_alloc(const _Alloc&&) = delete; - - - template - inline constexpr bool uses_allocator_v = - uses_allocator<_Tp, _Alloc>::value; - - - template class _Predicate, - typename _Tp, typename _Alloc, typename... _Args> - struct __is_uses_allocator_predicate - : __conditional_t::value, - __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, - _Predicate<_Tp, _Args..., _Alloc>>, - _Predicate<_Tp, _Args...>> { }; - - template - struct __is_uses_allocator_constructible - : __is_uses_allocator_predicate - { }; - - - template - inline constexpr bool __is_uses_allocator_constructible_v = - __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; - - - template - struct __is_nothrow_uses_allocator_constructible - : __is_uses_allocator_predicate - { }; - - - - template - inline constexpr bool - __is_nothrow_uses_allocator_constructible_v = - __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; - - - template - void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr, - _Args&&... __args) - { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } - - template - void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr, - _Args&&... __args) - { - ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a, - std::forward<_Args>(__args)...); - } - - template - void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr, - _Args&&... __args) - { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); } - - template - void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr, - _Args&&... __args) - { - std::__uses_allocator_construct_impl( - std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr, - std::forward<_Args>(__args)...); - } - - - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - - - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 - - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 - template::type> - constexpr _Up&& - __invfwd(typename remove_reference<_Tp>::type& __t) noexcept - { return static_cast<_Up&&>(__t); } - - template - constexpr _Res - __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) - { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } - - template - constexpr _Res - __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, - _Args&&... __args) - { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } - - template - constexpr _Res - __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, - _Args&&... __args) - { - return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); - } - - template - constexpr _Res - __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) - { return __invfwd<_Tp>(__t).*__f; } - - template - constexpr _Res - __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) - { return (*std::forward<_Tp>(__t)).*__f; } - - - template - constexpr typename __invoke_result<_Callable, _Args...>::type - __invoke(_Callable&& __fn, _Args&&... __args) - noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) - { - using __result = __invoke_result<_Callable, _Args...>; - using __type = typename __result::type; - using __tag = typename __result::__invoke_type; - return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - } - - - - template - constexpr enable_if_t, _Res> - __invoke_r(_Callable&& __fn, _Args&&... __args) - noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) - { - using __result = __invoke_result<_Callable, _Args...>; - using __type = typename __result::type; - using __tag = typename __result::__invoke_type; - if constexpr (is_void_v<_Res>) - std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - else - return std::__invoke_impl<__type>(__tag{}, - std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - } -# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - class tuple; - - template - struct __is_empty_non_tuple : is_empty<_Tp> { }; - - - template - struct __is_empty_non_tuple> : false_type { }; - - - template - using __empty_not_final - = __conditional_t<__is_final(_Tp), false_type, - __is_empty_non_tuple<_Tp>>; - - template::value> - struct _Head_base; - - - template - struct _Head_base<_Idx, _Head, true> - { - constexpr _Head_base() - : _M_head_impl() { } - - constexpr _Head_base(const _Head& __h) - : _M_head_impl(__h) { } - - constexpr _Head_base(const _Head_base&) = default; - constexpr _Head_base(_Head_base&&) = default; - - template - constexpr _Head_base(_UHead&& __h) - : _M_head_impl(std::forward<_UHead>(__h)) { } - - - _Head_base(allocator_arg_t, __uses_alloc0) - : _M_head_impl() { } - - template - - _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) - : _M_head_impl(allocator_arg, *__a._M_a) { } - - template - - _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) - : _M_head_impl(*__a._M_a) { } - - template - - _Head_base(__uses_alloc0, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead)) { } - - template - - _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) - { } - - template - - _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } - - static constexpr _Head& - _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } - - static constexpr const _Head& - _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } - - [[__no_unique_address__]] _Head _M_head_impl; - }; -# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - struct _Head_base<_Idx, _Head, false> - { - constexpr _Head_base() - : _M_head_impl() { } - - constexpr _Head_base(const _Head& __h) - : _M_head_impl(__h) { } - - constexpr _Head_base(const _Head_base&) = default; - constexpr _Head_base(_Head_base&&) = default; - - template - constexpr _Head_base(_UHead&& __h) - : _M_head_impl(std::forward<_UHead>(__h)) { } - - - _Head_base(allocator_arg_t, __uses_alloc0) - : _M_head_impl() { } - - template - - _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) - : _M_head_impl(allocator_arg, *__a._M_a) { } - - template - - _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) - : _M_head_impl(*__a._M_a) { } - - template - - _Head_base(__uses_alloc0, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead)) { } - - template - - _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) - { } - - template - - _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } - - static constexpr _Head& - _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } - - static constexpr const _Head& - _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } - - _Head _M_head_impl; - }; -# 250 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - struct _Tuple_impl; - - - - - - - template - struct _Tuple_impl<_Idx, _Head, _Tail...> - : public _Tuple_impl<_Idx + 1, _Tail...>, - private _Head_base<_Idx, _Head> - { - template friend struct _Tuple_impl; - - typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; - typedef _Head_base<_Idx, _Head> _Base; - - static constexpr _Head& - _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - static constexpr const _Head& - _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - static constexpr _Inherited& - _M_tail(_Tuple_impl& __t) noexcept { return __t; } - - static constexpr const _Inherited& - _M_tail(const _Tuple_impl& __t) noexcept { return __t; } - - constexpr _Tuple_impl() - : _Inherited(), _Base() { } - - explicit constexpr - _Tuple_impl(const _Head& __head, const _Tail&... __tail) - : _Inherited(__tail...), _Base(__head) - { } - - template> - explicit constexpr - _Tuple_impl(_UHead&& __head, _UTail&&... __tail) - : _Inherited(std::forward<_UTail>(__tail)...), - _Base(std::forward<_UHead>(__head)) - { } - - constexpr _Tuple_impl(const _Tuple_impl&) = default; - - - - _Tuple_impl& operator=(const _Tuple_impl&) = delete; - - _Tuple_impl(_Tuple_impl&&) = default; - - template - constexpr - _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) - : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), - _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) - { } - - template - constexpr - _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) - : _Inherited(std::move - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), - _Base(std::forward<_UHead> - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) - { } -# 338 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) - : _Inherited(__tag, __a), - _Base(__tag, __use_alloc<_Head>(__a)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Head& __head, const _Tail&... __tail) - : _Inherited(__tag, __a, __tail...), - _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) - { } - - template> - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _UHead&& __head, _UTail&&... __tail) - : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), - _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead>(__head)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl& __in) - : _Inherited(__tag, __a, _M_tail(__in)), - _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl&& __in) - : _Inherited(__tag, __a, std::move(_M_tail(__in))), - _Base(__use_alloc<_Head, _Alloc, _Head>(__a), - std::forward<_Head>(_M_head(__in))) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl<_Idx, _UHead, _UTails...>& __in) - : _Inherited(__tag, __a, - _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), - _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), - _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) - : _Inherited(__tag, __a, std::move - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), - _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead> - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) - { } -# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - void - _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) - { - _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); - _M_tail(*this)._M_assign( - _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); - } - - template - - void - _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) - { - _M_head(*this) = std::forward<_UHead> - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); - _M_tail(*this)._M_assign( - std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); - } -# 466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - protected: - - void - _M_swap(_Tuple_impl& __in) - { - using std::swap; - swap(_M_head(*this), _M_head(__in)); - _Inherited::_M_swap(_M_tail(__in)); - } -# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - template - struct _Tuple_impl<_Idx, _Head> - : private _Head_base<_Idx, _Head> - { - template friend struct _Tuple_impl; - - typedef _Head_base<_Idx, _Head> _Base; - - static constexpr _Head& - _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - static constexpr const _Head& - _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - constexpr - _Tuple_impl() - : _Base() { } - - explicit constexpr - _Tuple_impl(const _Head& __head) - : _Base(__head) - { } - - template - explicit constexpr - _Tuple_impl(_UHead&& __head) - : _Base(std::forward<_UHead>(__head)) - { } - - constexpr _Tuple_impl(const _Tuple_impl&) = default; - - - - _Tuple_impl& operator=(const _Tuple_impl&) = delete; - - - - - constexpr - _Tuple_impl(_Tuple_impl&& __in) - noexcept(is_nothrow_move_constructible<_Head>::value) - : _Base(static_cast<_Base&&>(__in)) - { } - - - template - constexpr - _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) - : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) - { } - - template - constexpr - _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) - : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) - { } -# 559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) - : _Base(__tag, __use_alloc<_Head>(__a)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Head& __head) - : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _UHead&& __head) - : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead>(__head)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl& __in) - : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl&& __in) - : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), - std::forward<_Head>(_M_head(__in))) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl<_Idx, _UHead>& __in) - : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), - _Tuple_impl<_Idx, _UHead>::_M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl<_Idx, _UHead>&& __in) - : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) - { } -# 629 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - void - _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) - { - _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); - } - - template - - void - _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) - { - _M_head(*this) - = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); - } -# 663 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - protected: - - void - _M_swap(_Tuple_impl& __in) - { - using std::swap; - swap(_M_head(*this), _M_head(__in)); - } -# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - - template - struct _TupleConstraints - { - template - using __constructible = __and_...>; - - template - using __convertible = __and_...>; - - - - - template - static constexpr bool __is_implicitly_constructible() - { - return __and_<__constructible<_UTypes...>, - __convertible<_UTypes...> - >::value; - } - - - - - template - static constexpr bool __is_explicitly_constructible() - { - return __and_<__constructible<_UTypes...>, - __not_<__convertible<_UTypes...>> - >::value; - } - - static constexpr bool __is_implicitly_default_constructible() - { - return __and_... - >::value; - } - - static constexpr bool __is_explicitly_default_constructible() - { - return __and_..., - __not_<__and_< - std::__is_implicitly_default_constructible<_Types>...> - >>::value; - } - }; - - - - template - struct _TupleConstraints - { - template - static constexpr bool __is_implicitly_constructible() - { return false; } - - template - static constexpr bool __is_explicitly_constructible() - { return false; } - }; - - - template - class tuple : public _Tuple_impl<0, _Elements...> - { - typedef _Tuple_impl<0, _Elements...> _Inherited; - - template - using _TCC = _TupleConstraints<_Cond, _Elements...>; - - - template - using _ImplicitDefaultCtor = __enable_if_t< - _TCC<_Dummy>::__is_implicitly_default_constructible(), - bool>; - - - template - using _ExplicitDefaultCtor = __enable_if_t< - _TCC<_Dummy>::__is_explicitly_default_constructible(), - bool>; - - - template - using _ImplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), - bool>; - - - template - using _ExplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), - bool>; - - template - static constexpr - __enable_if_t - __assignable() - { return __and_...>::value; } - - - template - static constexpr bool __nothrow_assignable() - { - return - __and_...>::value; - } - - - template - static constexpr bool __nothrow_constructible() - { - return - __and_...>::value; - } - - - template - static constexpr bool __valid_args() - { - return sizeof...(_Elements) == 1 - && !is_same>::value; - } - - - template - static constexpr bool __valid_args() - { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } -# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template> - struct _UseOtherCtor - : false_type - { }; - - - template - struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> - : __or_, is_constructible<_Tp, _Tuple>>::type - { }; - - - template - struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> - : true_type - { }; - - - - - template - static constexpr bool __use_other_ctor() - { return _UseOtherCtor<_Tuple>::value; } -# 856 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - public: - template::value> = true> - constexpr - tuple() - noexcept(__and_...>::value) - : _Inherited() { } - - template::value> = false> - explicit constexpr - tuple() - noexcept(__and_...>::value) - : _Inherited() { } - - template= 1), - _ImplicitCtor<_NotEmpty, const _Elements&...> = true> - constexpr - tuple(const _Elements&... __elements) - noexcept(__nothrow_constructible()) - : _Inherited(__elements...) { } - - template= 1), - _ExplicitCtor<_NotEmpty, const _Elements&...> = false> - explicit constexpr - tuple(const _Elements&... __elements) - noexcept(__nothrow_constructible()) - : _Inherited(__elements...) { } - - template(), - _ImplicitCtor<_Valid, _UElements...> = true> - constexpr - tuple(_UElements&&... __elements) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(std::forward<_UElements>(__elements)...) { } - - template(), - _ExplicitCtor<_Valid, _UElements...> = false> - explicit constexpr - tuple(_UElements&&... __elements) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(std::forward<_UElements>(__elements)...) { } - - constexpr tuple(const tuple&) = default; - - constexpr tuple(tuple&&) = default; - - template&>(), - _ImplicitCtor<_Valid, const _UElements&...> = true> - constexpr - tuple(const tuple<_UElements...>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) - { } - - template&>(), - _ExplicitCtor<_Valid, const _UElements&...> = false> - explicit constexpr - tuple(const tuple<_UElements...>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) - { } - - template&&>(), - _ImplicitCtor<_Valid, _UElements...> = true> - constexpr - tuple(tuple<_UElements...>&& __in) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } - - template&&>(), - _ExplicitCtor<_Valid, _UElements...> = false> - explicit constexpr - tuple(tuple<_UElements...>&& __in) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } -# 968 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template::value> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a) - : _Inherited(__tag, __a) { } - - template= 1), - _ImplicitCtor<_NotEmpty, const _Elements&...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _Elements&... __elements) - : _Inherited(__tag, __a, __elements...) { } - - template= 1), - _ExplicitCtor<_NotEmpty, const _Elements&...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _Elements&... __elements) - : _Inherited(__tag, __a, __elements...) { } - - template(), - _ImplicitCtor<_Valid, _UElements...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - _UElements&&... __elements) - : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) - { } - - template(), - _ExplicitCtor<_Valid, _UElements...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - _UElements&&... __elements) - : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) - { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) - : _Inherited(__tag, __a, static_cast(__in)) { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) - : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } - - template&>(), - _ImplicitCtor<_Valid, const _UElements&...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_UElements...>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template&>(), - _ExplicitCtor<_Valid, const _UElements&...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_UElements...>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template&&>(), - _ImplicitCtor<_Valid, _UElements...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - tuple<_UElements...>&& __in) - : _Inherited(__tag, __a, - static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) - { } - - template&&>(), - _ExplicitCtor<_Valid, _UElements...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - tuple<_UElements...>&& __in) - : _Inherited(__tag, __a, - static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) - { } -# 1093 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - tuple& - operator=(__conditional_t<__assignable(), - const tuple&, - const __nonesuch&> __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - - tuple& - operator=(__conditional_t<__assignable<_Elements...>(), - tuple&&, - __nonesuch&&> __in) - noexcept(__nothrow_assignable<_Elements...>()) - { - this->_M_assign(std::move(__in)); - return *this; - } - - template - - __enable_if_t<__assignable(), tuple&> - operator=(const tuple<_UElements...>& __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - template - - __enable_if_t<__assignable<_UElements...>(), tuple&> - operator=(tuple<_UElements...>&& __in) - noexcept(__nothrow_assignable<_UElements...>()) - { - this->_M_assign(std::move(__in)); - return *this; - } -# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - void - swap(tuple& __in) - noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) - { _Inherited::_M_swap(__in); } -# 1192 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - template - tuple(_UTypes...) -> tuple<_UTypes...>; - template - tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; - template - tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; - template - tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; - template - tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; - - - - template<> - class tuple<> - { - public: - - void swap(tuple&) noexcept { } - - - - - - tuple() = default; - - template - - tuple(allocator_arg_t, const _Alloc&) noexcept { } - template - - tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } - }; - - - - template - class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> - { - typedef _Tuple_impl<0, _T1, _T2> _Inherited; - - - template - using _ImplicitDefaultCtor = __enable_if_t< - _TupleConstraints<_Dummy, _U1, _U2>:: - __is_implicitly_default_constructible(), - bool>; - - - template - using _ExplicitDefaultCtor = __enable_if_t< - _TupleConstraints<_Dummy, _U1, _U2>:: - __is_explicitly_default_constructible(), - bool>; - - template - using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; - - - template - using _ImplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), - bool>; - - - template - using _ExplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), - bool>; - - template - static constexpr bool __assignable() - { - return __and_, - is_assignable<_T2&, _U2>>::value; - } - - template - static constexpr bool __nothrow_assignable() - { - return __and_, - is_nothrow_assignable<_T2&, _U2>>::value; - } - - template - static constexpr bool __nothrow_constructible() - { - return __and_, - is_nothrow_constructible<_T2, _U2>>::value; - } - - static constexpr bool __nothrow_default_constructible() - { - return __and_, - is_nothrow_default_constructible<_T2>>::value; - } - - template - static constexpr bool __is_alloc_arg() - { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } -# 1306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - public: - template = true> - constexpr - tuple() - noexcept(__nothrow_default_constructible()) - : _Inherited() { } - - template = false> - explicit constexpr - tuple() - noexcept(__nothrow_default_constructible()) - : _Inherited() { } - - template = true> - constexpr - tuple(const _T1& __a1, const _T2& __a2) - noexcept(__nothrow_constructible()) - : _Inherited(__a1, __a2) { } - - template = false> - explicit constexpr - tuple(const _T1& __a1, const _T2& __a2) - noexcept(__nothrow_constructible()) - : _Inherited(__a1, __a2) { } - - template(), _U1, _U2> = true> - constexpr - tuple(_U1&& __a1, _U2&& __a2) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } - - template(), _U1, _U2> = false> - explicit constexpr - tuple(_U1&& __a1, _U2&& __a2) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } - - constexpr tuple(const tuple&) = default; - - constexpr tuple(tuple&&) = default; - - template = true> - constexpr - tuple(const tuple<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) { } - - template = false> - explicit constexpr - tuple(const tuple<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) { } - - template = true> - constexpr - tuple(tuple<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } - - template = false> - explicit constexpr - tuple(tuple<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } -# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template = true> - constexpr - tuple(const pair<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(__in.first, __in.second) { } - - template = false> - explicit constexpr - tuple(const pair<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(__in.first, __in.second) { } - - template = true> - constexpr - tuple(pair<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } - - template = false> - explicit constexpr - tuple(pair<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } -# 1450 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template::value, _T1, _T2> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a) - : _Inherited(__tag, __a) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _T1& __a1, const _T2& __a2) - : _Inherited(__tag, __a, __a1, __a2) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _T1& __a1, const _T2& __a2) - : _Inherited(__tag, __a, __a1, __a2) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) - : _Inherited(__tag, __a, std::forward<_U1>(__a1), - std::forward<_U2>(__a2)) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - _U1&& __a1, _U2&& __a2) - : _Inherited(__tag, __a, std::forward<_U1>(__a1), - std::forward<_U2>(__a2)) { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) - : _Inherited(__tag, __a, static_cast(__in)) { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) - : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_U1, _U2>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_U1, _U2>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) - : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) - { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) - : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) - { } -# 1553 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const pair<_U1, _U2>& __in) - : _Inherited(__tag, __a, __in.first, __in.second) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const pair<_U1, _U2>& __in) - : _Inherited(__tag, __a, __in.first, __in.second) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) - : _Inherited(__tag, __a, std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) - : _Inherited(__tag, __a, std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } -# 1604 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - tuple& - operator=(__conditional_t<__assignable(), - const tuple&, - const __nonesuch&> __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - - tuple& - operator=(__conditional_t<__assignable<_T1, _T2>(), - tuple&&, - __nonesuch&&> __in) - noexcept(__nothrow_assignable<_T1, _T2>()) - { - this->_M_assign(std::move(__in)); - return *this; - } - - template - - __enable_if_t<__assignable(), tuple&> - operator=(const tuple<_U1, _U2>& __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - template - - __enable_if_t<__assignable<_U1, _U2>(), tuple&> - operator=(tuple<_U1, _U2>&& __in) - noexcept(__nothrow_assignable<_U1, _U2>()) - { - this->_M_assign(std::move(__in)); - return *this; - } -# 1683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - __enable_if_t<__assignable(), tuple&> - operator=(const pair<_U1, _U2>& __in) - noexcept(__nothrow_assignable()) - { - this->_M_head(*this) = __in.first; - this->_M_tail(*this)._M_head(*this) = __in.second; - return *this; - } - - template - - __enable_if_t<__assignable<_U1, _U2>(), tuple&> - operator=(pair<_U1, _U2>&& __in) - noexcept(__nothrow_assignable<_U1, _U2>()) - { - this->_M_head(*this) = std::forward<_U1>(__in.first); - this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); - return *this; - } -# 1730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - void - swap(tuple& __in) - noexcept(__and_<__is_nothrow_swappable<_T1>, - __is_nothrow_swappable<_T2>>::value) - { _Inherited::_M_swap(__in); } -# 1744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - - template - struct tuple_size> - : public integral_constant { }; - - - template - inline constexpr size_t tuple_size_v> - = sizeof...(_Types); - - template - inline constexpr size_t tuple_size_v> - = sizeof...(_Types); - - - - template - struct tuple_element<__i, tuple<_Types...>> - { - static_assert(__i < sizeof...(_Types), "tuple index must be in range"); - - using type = typename _Nth_type<__i, _Types...>::type; - }; - - template - constexpr _Head& - __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept - { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } - - template - constexpr const _Head& - __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept - { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } - - - template - __enable_if_t<(__i >= sizeof...(_Types))> - __get_helper(const tuple<_Types...>&) = delete; - - - template - constexpr __tuple_element_t<__i, tuple<_Elements...>>& - get(tuple<_Elements...>& __t) noexcept - { return std::__get_helper<__i>(__t); } - - - template - constexpr const __tuple_element_t<__i, tuple<_Elements...>>& - get(const tuple<_Elements...>& __t) noexcept - { return std::__get_helper<__i>(__t); } - - - template - constexpr __tuple_element_t<__i, tuple<_Elements...>>&& - get(tuple<_Elements...>&& __t) noexcept - { - typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; - return std::forward<__element_type>(std::__get_helper<__i>(__t)); - } - - - template - constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& - get(const tuple<_Elements...>&& __t) noexcept - { - typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; - return std::forward(std::__get_helper<__i>(__t)); - } - - - - template - constexpr __enable_if_t<(__i >= sizeof...(_Elements))> - get(const tuple<_Elements...>&) = delete; - - - - - - - - template - constexpr _Tp& - get(tuple<_Types...>& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::__get_helper<__idx>(__t); - } - - - template - constexpr _Tp&& - get(tuple<_Types...>&& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::forward<_Tp>(std::__get_helper<__idx>(__t)); - } - - - template - constexpr const _Tp& - get(const tuple<_Types...>& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::__get_helper<__idx>(__t); - } - - - - template - constexpr const _Tp&& - get(const tuple<_Types...>&& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::forward(std::__get_helper<__idx>(__t)); - } - - - - template - struct __tuple_compare - { - static constexpr bool - __eq(const _Tp& __t, const _Up& __u) - { - return bool(std::get<__i>(__t) == std::get<__i>(__u)) - && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); - } - - static constexpr bool - __less(const _Tp& __t, const _Up& __u) - { - return bool(std::get<__i>(__t) < std::get<__i>(__u)) - || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) - && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); - } - }; - - template - struct __tuple_compare<_Tp, _Up, __size, __size> - { - static constexpr bool - __eq(const _Tp&, const _Up&) { return true; } - - static constexpr bool - __less(const _Tp&, const _Up&) { return false; } - }; - - template - constexpr bool - operator==(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { - static_assert(sizeof...(_TElements) == sizeof...(_UElements), - "tuple objects can only be compared if they have equal sizes."); - using __compare = __tuple_compare, - tuple<_UElements...>, - 0, sizeof...(_TElements)>; - return __compare::__eq(__t, __u); - } -# 1945 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - constexpr bool - operator<(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { - static_assert(sizeof...(_TElements) == sizeof...(_UElements), - "tuple objects can only be compared if they have equal sizes."); - using __compare = __tuple_compare, - tuple<_UElements...>, - 0, sizeof...(_TElements)>; - return __compare::__less(__t, __u); - } - - template - constexpr bool - operator!=(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return !(__t == __u); } - - template - constexpr bool - operator>(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return __u < __t; } - - template - constexpr bool - operator<=(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return !(__u < __t); } - - template - constexpr bool - operator>=(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return !(__t < __u); } - - - - - template - constexpr tuple::__type...> - make_tuple(_Elements&&... __args) - { - typedef tuple::__type...> - __result_type; - return __result_type(std::forward<_Elements>(__args)...); - } - - - - - template - constexpr tuple<_Elements&&...> - forward_as_tuple(_Elements&&... __args) noexcept - { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } - - - - - template struct array; - - template - constexpr _Tp& - get(array<_Tp, _Nm>&) noexcept; - - template - constexpr _Tp&& - get(array<_Tp, _Nm>&&) noexcept; - - template - constexpr const _Tp& - get(const array<_Tp, _Nm>&) noexcept; - - template - constexpr const _Tp&& - get(const array<_Tp, _Nm>&&) noexcept; - - - template - struct __make_tuple_impl; - - template - struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> - : __make_tuple_impl<_Idx + 1, - tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, - _Tuple, _Nm> - { }; - - template - struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> - { - typedef tuple<_Tp...> __type; - }; - - template - struct __do_make_tuple - : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value> - { }; - - - template - struct __make_tuple - : public __do_make_tuple<__remove_cvref_t<_Tuple>> - { }; - - - template - struct __combine_tuples; - - template<> - struct __combine_tuples<> - { - typedef tuple<> __type; - }; - - template - struct __combine_tuples> - { - typedef tuple<_Ts...> __type; - }; - - template - struct __combine_tuples, tuple<_T2s...>, _Rem...> - { - typedef typename __combine_tuples, - _Rem...>::__type __type; - }; - - - template - struct __tuple_cat_result - { - typedef typename __combine_tuples - ::__type...>::__type __type; - }; - - - - template - struct __make_1st_indices; - - template<> - struct __make_1st_indices<> - { - typedef _Index_tuple<> __type; - }; - - template - struct __make_1st_indices<_Tp, _Tpls...> - { - typedef typename _Build_index_tuple::type>::value>::__type __type; - }; - - - - - template - struct __tuple_concater; - - template - struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...> - { - template - static constexpr _Ret - _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) - { - typedef typename __make_1st_indices<_Tpls...>::__type __idx; - typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; - return __next::_S_do(std::forward<_Tpls>(__tps)..., - std::forward<_Us>(__us)..., - std::get<_Is>(std::forward<_Tp>(__tp))...); - } - }; - - template - struct __tuple_concater<_Ret, _Index_tuple<>> - { - template - static constexpr _Ret - _S_do(_Us&&... __us) - { - return _Ret(std::forward<_Us>(__us)...); - } - }; - - template - struct __is_tuple_like_impl> : true_type - { }; - - - - template...>::value>::type> - constexpr auto - tuple_cat(_Tpls&&... __tpls) - -> typename __tuple_cat_result<_Tpls...>::__type - { - typedef typename __tuple_cat_result<_Tpls...>::__type __ret; - typedef typename __make_1st_indices<_Tpls...>::__type __idx; - typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; - return __concater::_S_do(std::forward<_Tpls>(__tpls)...); - } - - - - - template - constexpr tuple<_Elements&...> - tie(_Elements&... __args) noexcept - { return tuple<_Elements&...>(__args...); } - - - template - - inline - - - typename enable_if<__and_<__is_swappable<_Elements>...>::value - >::type - - - - swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } -# 2184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - typename enable_if...>::value>::type - swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; - - - - - - - struct _Swallow_assign - { - template - constexpr const _Swallow_assign& - operator=(const _Tp&) const - { return *this; } - }; -# 2219 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - inline constexpr _Swallow_assign ignore{}; - - - template - struct uses_allocator, _Alloc> : true_type { }; -# 2234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - template - - inline - pair<_T1, _T2>:: - pair(piecewise_construct_t, - tuple<_Args1...> __first, tuple<_Args2...> __second) - : pair(__first, __second, - typename _Build_index_tuple::__type(), - typename _Build_index_tuple::__type()) - { } - - template - template - inline - pair<_T1, _T2>:: - pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, - _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) - : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), - second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) - { } - - - - - - - - template class _Trait, typename _Tp, typename _Tuple> - inline constexpr bool __unpack_std_tuple = false; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> - = _Trait<_Tp, _Up...>::value; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> - = _Trait<_Tp, _Up&...>::value; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> - = _Trait<_Tp, const _Up...>::value; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> - = _Trait<_Tp, const _Up&...>::value; - - - - template - constexpr decltype(auto) - __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) - { - return std::__invoke(std::forward<_Fn>(__f), - std::get<_Idx>(std::forward<_Tuple>(__t))...); - } - - template - constexpr decltype(auto) - apply(_Fn&& __f, _Tuple&& __t) - noexcept(__unpack_std_tuple) - { - using _Indices - = make_index_sequence>>; - return std::__apply_impl(std::forward<_Fn>(__f), - std::forward<_Tuple>(__t), - _Indices{}); - } - - - - template - constexpr _Tp - __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) - { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } - - template - constexpr _Tp - make_from_tuple(_Tuple&& __t) - noexcept(__unpack_std_tuple) - { - constexpr size_t __n = tuple_size_v>; - - - - - - - - return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t), - make_index_sequence<__n>{}); - } -# 2345 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 -} -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - -namespace pmr -{ - - - - - - - class memory_resource - { - static constexpr size_t _S_max_align = alignof(max_align_t); - - public: - memory_resource() = default; - memory_resource(const memory_resource&) = default; - virtual ~memory_resource(); - - memory_resource& operator=(const memory_resource&) = default; - - [[nodiscard]] - void* - allocate(size_t __bytes, size_t __alignment = _S_max_align) - __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3))) - { return ::operator new(__bytes, do_allocate(__bytes, __alignment)); } - - void - deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align) - __attribute__((__nonnull__)) - { return do_deallocate(__p, __bytes, __alignment); } - - [[nodiscard]] - bool - is_equal(const memory_resource& __other) const noexcept - { return do_is_equal(__other); } - - private: - virtual void* - do_allocate(size_t __bytes, size_t __alignment) = 0; - - virtual void - do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0; - - virtual bool - do_is_equal(const memory_resource& __other) const noexcept = 0; - }; - - [[nodiscard]] - inline bool - operator==(const memory_resource& __a, const memory_resource& __b) noexcept - { return &__a == &__b || __a.is_equal(__b); } - - - [[nodiscard]] - inline bool - operator!=(const memory_resource& __a, const memory_resource& __b) noexcept - { return !(__a == __b); } -# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - class polymorphic_allocator - { - - - template - struct __not_pair { using type = void; }; - - template - struct __not_pair> { }; - - public: - using value_type = _Tp; - - polymorphic_allocator() noexcept - { - extern memory_resource* get_default_resource() noexcept - __attribute__((__returns_nonnull__)); - _M_resource = get_default_resource(); - } - - polymorphic_allocator(memory_resource* __r) noexcept - __attribute__((__nonnull__)) - : _M_resource(__r) - { ; } - - polymorphic_allocator(const polymorphic_allocator& __other) = default; - - template - polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept - : _M_resource(__x.resource()) - { } - - polymorphic_allocator& - operator=(const polymorphic_allocator&) = delete; - - [[nodiscard]] - _Tp* - allocate(size_t __n) - __attribute__((__returns_nonnull__)) - { - if ((__gnu_cxx::__int_traits::__max / sizeof(_Tp)) < __n) - std::__throw_bad_array_new_length(); - return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp), - alignof(_Tp))); - } - - void - deallocate(_Tp* __p, size_t __n) noexcept - __attribute__((__nonnull__)) - { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); } -# 224 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - __attribute__((__nonnull__)) - typename __not_pair<_Tp1>::type - construct(_Tp1* __p, _Args&&... __args) - { - - - using __use_tag - = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>; - if constexpr (is_base_of_v<__uses_alloc0, __use_tag>) - ::new(__p) _Tp1(std::forward<_Args>(__args)...); - else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>) - ::new(__p) _Tp1(allocator_arg, *this, - std::forward<_Args>(__args)...); - else - ::new(__p) _Tp1(std::forward<_Args>(__args)..., *this); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t, - tuple<_Args1...> __x, tuple<_Args2...> __y) - { - auto __x_tag = - __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this); - auto __y_tag = - __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this); - index_sequence_for<_Args1...> __x_i; - index_sequence_for<_Args2...> __y_i; - - ::new(__p) pair<_Tp1, _Tp2>(piecewise_construct, - _S_construct_p(__x_tag, __x_i, __x), - _S_construct_p(__y_tag, __y_i, __y)); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p) - { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y) - { - this->construct(__p, piecewise_construct, - std::forward_as_tuple(std::forward<_Up>(__x)), - std::forward_as_tuple(std::forward<_Vp>(__y))); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, const std::pair<_Up, _Vp>& __pr) - { - this->construct(__p, piecewise_construct, - std::forward_as_tuple(__pr.first), - std::forward_as_tuple(__pr.second)); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr) - { - this->construct(__p, piecewise_construct, - std::forward_as_tuple(std::forward<_Up>(__pr.first)), - std::forward_as_tuple(std::forward<_Vp>(__pr.second))); - } -# 307 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - - __attribute__((__nonnull__)) - void - destroy(_Up* __p) - { __p->~_Up(); } - - polymorphic_allocator - select_on_container_copy_construction() const noexcept - { return polymorphic_allocator(); } - - memory_resource* - resource() const noexcept - __attribute__((__returns_nonnull__)) - { return _M_resource; } - - - - [[nodiscard]] - friend bool - operator==(const polymorphic_allocator& __a, - const polymorphic_allocator& __b) noexcept - { return *__a.resource() == *__b.resource(); } - - - [[nodiscard]] - friend bool - operator!=(const polymorphic_allocator& __a, - const polymorphic_allocator& __b) noexcept - { return !(__a == __b); } - - - private: - - using __uses_alloc1_ = __uses_alloc1; - using __uses_alloc2_ = __uses_alloc2; - - template - static tuple<_Args&&...> - _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t) - { return std::move(__t); } - - template - static tuple - _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>, - tuple<_Args...>& __t) - { - return { - allocator_arg, *__ua._M_a, std::get<_Ind>(std::move(__t))... - }; - } - - template - static tuple<_Args&&..., polymorphic_allocator> - _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>, - tuple<_Args...>& __t) - { return { std::get<_Ind>(std::move(__t))..., *__ua._M_a }; } - - - memory_resource* _M_resource; - }; - - template - [[nodiscard]] - inline bool - operator==(const polymorphic_allocator<_Tp1>& __a, - const polymorphic_allocator<_Tp2>& __b) noexcept - { return *__a.resource() == *__b.resource(); } - - - template - [[nodiscard]] - inline bool - operator!=(const polymorphic_allocator<_Tp1>& __a, - const polymorphic_allocator<_Tp2>& __b) noexcept - { return !(__a == __b); } - - -} - - template struct allocator_traits; - - - template - struct allocator_traits> - { - - using allocator_type = pmr::polymorphic_allocator<_Tp>; - - - using value_type = _Tp; - - - using pointer = _Tp*; - - - using const_pointer = const _Tp*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - - - - using propagate_on_container_copy_assignment = false_type; - using propagate_on_container_move_assignment = false_type; - using propagate_on_container_swap = false_type; - - static allocator_type - select_on_container_copy_construction(const allocator_type&) noexcept - { return allocator_type(); } - - - - using is_always_equal = false_type; - - template - using rebind_alloc = pmr::polymorphic_allocator<_Up>; - - template - using rebind_traits = allocator_traits>; -# 446 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - [[nodiscard]] static pointer - allocate(allocator_type& __a, size_type __n) - { return __a.allocate(__n); } -# 461 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - [[nodiscard]] static pointer - allocate(allocator_type& __a, size_type __n, const_void_pointer) - { return __a.allocate(__n); } -# 473 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - static void - deallocate(allocator_type& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - static void - construct(allocator_type& __a, _Up* __p, _Args&&... __args) - { __a.construct(__p, std::forward<_Args>(__args)...); } -# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - static void - destroy(allocator_type&, _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { __p->~_Up(); } - - - - - - static size_type - max_size(const allocator_type&) noexcept - { return size_t(-1) / sizeof(value_type); } - }; - - -} -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/list" 2 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - namespace pmr - { - template - using list = std::list<_Tp, polymorphic_allocator<_Tp>>; - } - -} -# 17 "src/core/application.h" 2 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 1 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 1 3 -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - namespace __detail - { - template - inline void - __return_temporary_buffer(_Tp* __p, - size_t __len __attribute__((__unused__))) - { - - - - ::operator delete(__p); - - } - } -# 101 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 - template - [[__deprecated__]] - pair<_Tp*, ptrdiff_t> - get_temporary_buffer(ptrdiff_t __len) noexcept - { - const ptrdiff_t __max = - __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); - if (__len > __max) - __len = __max; - - while (__len > 0) - { - _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), - std::nothrow)); - if (__tmp != 0) - return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); - __len = __len == 1 ? 0 : ((__len + 1) / 2); - } - return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); - } -# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 - template - inline void - return_temporary_buffer(_Tp* __p) - { ::operator delete(__p); } - - - - - - - template - class _Temporary_buffer - { - - - - public: - typedef _Tp value_type; - typedef value_type* pointer; - typedef pointer iterator; - typedef ptrdiff_t size_type; - - protected: - size_type _M_original_len; - size_type _M_len; - pointer _M_buffer; - - public: - - size_type - size() const - { return _M_len; } - - - size_type - requested_size() const - { return _M_original_len; } - - - iterator - begin() - { return _M_buffer; } - - - iterator - end() - { return _M_buffer + _M_len; } - - - - - - _Temporary_buffer(_ForwardIterator __seed, size_type __original_len); - - ~_Temporary_buffer() - { - std::_Destroy(_M_buffer, _M_buffer + _M_len); - std::__detail::__return_temporary_buffer(_M_buffer, _M_len); - } - - private: - - _Temporary_buffer(const _Temporary_buffer&); - - void - operator=(const _Temporary_buffer&); - }; - - - template - struct __uninitialized_construct_buf_dispatch - { - template - static void - __ucr(_Pointer __first, _Pointer __last, - _ForwardIterator __seed) - { - if (__first == __last) - return; - - _Pointer __cur = __first; - try - { - std::_Construct(std::__addressof(*__first), - std::move(*__seed)); - _Pointer __prev = __cur; - ++__cur; - for(; __cur != __last; ++__cur, ++__prev) - std::_Construct(std::__addressof(*__cur), - std::move(*__prev)); - *__seed = std::move(*__prev); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_construct_buf_dispatch - { - template - static void - __ucr(_Pointer, _Pointer, _ForwardIterator) { } - }; -# 247 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 - template - inline void - __uninitialized_construct_buf(_Pointer __first, _Pointer __last, - _ForwardIterator __seed) - { - typedef typename std::iterator_traits<_Pointer>::value_type - _ValueType; - - std::__uninitialized_construct_buf_dispatch< - __has_trivial_constructor(_ValueType)>:: - __ucr(__first, __last, __seed); - } - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template - _Temporary_buffer<_ForwardIterator, _Tp>:: - _Temporary_buffer(_ForwardIterator __seed, size_type __original_len) - : _M_original_len(__original_len), _M_len(0), _M_buffer(0) - { - std::pair __p( - std::get_temporary_buffer(_M_original_len)); - - if (__p.first) - { - try - { - std::__uninitialized_construct_buf(__p.first, __p.first + __p.second, - __seed); - _M_buffer = __p.first; - _M_len = __p.second; - } - catch(...) - { - std::__detail::__return_temporary_buffer(__p.first, __p.second); - throw; - } - } - } -#pragma GCC diagnostic pop - - -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 1 3 -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - constexpr bool - __check_constructible() - { - - - - - - static_assert(is_constructible<_ValueType, _Tp>::value, - "result type must be constructible from input type"); - - return true; - } -# 110 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - - _ForwardIterator - __do_uninit_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { - _ForwardIterator __cur = __result; - try - { - for (; __first != __last; ++__first, (void)++__cur) - std::_Construct(std::__addressof(*__cur), *__first); - return __cur; - } - catch(...) - { - std::_Destroy(__result, __cur); - throw; - } - } - - template - struct __uninitialized_copy - { - template - static _ForwardIterator - __uninit_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { return std::__do_uninit_copy(__first, __last, __result); } - }; - - template<> - struct __uninitialized_copy - { - template - static _ForwardIterator - __uninit_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { return std::copy(__first, __last, __result); } - }; -# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { - typedef typename iterator_traits<_InputIterator>::value_type - _ValueType1; - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType2; - - - - - const bool __can_memmove = __is_trivial(_ValueType1); - - - - - using _From = decltype(*__first); - - const bool __assignable - = __is_trivial(_ValueType2) && __is_assignable(_ValueType2&, _From) && std::__check_constructible<_ValueType2, _From>(); - - return std::__uninitialized_copy<__can_memmove && __assignable>:: - __uninit_copy(__first, __last, __result); - } - - - - template - void - __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { - _ForwardIterator __cur = __first; - try - { - for (; __cur != __last; ++__cur) - std::_Construct(std::__addressof(*__cur), __x); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - - template - struct __uninitialized_fill - { - template - static void - __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { std::__do_uninit_fill(__first, __last, __x); } - }; - - template<> - struct __uninitialized_fill - { - template - static void - __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { std::fill(__first, __last, __x); } - }; -# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline void - uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - - - const bool __can_fill - = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>(); - - std::__uninitialized_fill<__can_fill>:: - __uninit_fill(__first, __last, __x); - } - - - - template - - _ForwardIterator - __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) - { - _ForwardIterator __cur = __first; - try - { - for (; __n > 0; --__n, (void) ++__cur) - std::_Construct(std::__addressof(*__cur), __x); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - - template - struct __uninitialized_fill_n - { - template - static _ForwardIterator - __uninit_fill_n(_ForwardIterator __first, _Size __n, - const _Tp& __x) - { return std::__do_uninit_fill_n(__first, __n, __x); } - }; - - template<> - struct __uninitialized_fill_n - { - template - static _ForwardIterator - __uninit_fill_n(_ForwardIterator __first, _Size __n, - const _Tp& __x) - { return std::fill_n(__first, __n, __x); } - }; -# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - - - const bool __can_fill - = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>() - - - - && __is_integer<_Size>::__value; - - return __uninitialized_fill_n<__can_fill>:: - __uninit_fill_n(__first, __n, __x); - } -# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - - _ForwardIterator - __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - { - _ForwardIterator __cur = __result; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __first != __last; ++__first, (void)++__cur) - __traits::construct(__alloc, std::__addressof(*__cur), *__first); - return __cur; - } - catch(...) - { - std::_Destroy(__result, __cur, __alloc); - throw; - } - } - - - template - - inline _ForwardIterator - __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, allocator<_Tp>&) - { - - - - - return std::uninitialized_copy(__first, __last, __result); - } - - - template - - inline _ForwardIterator - __uninitialized_move_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - { - return std::__uninitialized_copy_a(std::make_move_iterator(__first), - std::make_move_iterator(__last), - __result, __alloc); - } - - template - - inline _ForwardIterator - __uninitialized_move_if_noexcept_a(_InputIterator __first, - _InputIterator __last, - _ForwardIterator __result, - _Allocator& __alloc) - { - return std::__uninitialized_copy_a - (std::__make_move_if_noexcept_iterator(__first), - std::__make_move_if_noexcept_iterator(__last), __result, __alloc); - } - - template - - void - __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x, _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __cur != __last; ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur), __x); - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - template - - inline void - __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x, allocator<_Tp2>&) - { - - - - - std::uninitialized_fill(__first, __last, __x); - } - - - template - - _ForwardIterator - __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, - const _Tp& __x, _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __n > 0; --__n, (void) ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur), __x); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - template - - inline _ForwardIterator - __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, - const _Tp& __x, allocator<_Tp2>&) - { - - - - - return std::uninitialized_fill_n(__first, __n, __x); - } -# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - __uninitialized_copy_move(_InputIterator1 __first1, - _InputIterator1 __last1, - _InputIterator2 __first2, - _InputIterator2 __last2, - _ForwardIterator __result, - _Allocator& __alloc) - { - _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, - __result, - __alloc); - try - { - return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); - } - catch(...) - { - std::_Destroy(__result, __mid, __alloc); - throw; - } - } - - - - - - template - inline _ForwardIterator - __uninitialized_move_copy(_InputIterator1 __first1, - _InputIterator1 __last1, - _InputIterator2 __first2, - _InputIterator2 __last2, - _ForwardIterator __result, - _Allocator& __alloc) - { - _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, - __result, - __alloc); - try - { - return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); - } - catch(...) - { - std::_Destroy(__result, __mid, __alloc); - throw; - } - } - - - - - template - inline _ForwardIterator - __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, - const _Tp& __x, _InputIterator __first, - _InputIterator __last, _Allocator& __alloc) - { - std::__uninitialized_fill_a(__result, __mid, __x, __alloc); - try - { - return std::__uninitialized_move_a(__first, __last, __mid, __alloc); - } - catch(...) - { - std::_Destroy(__result, __mid, __alloc); - throw; - } - } - - - - - template - inline void - __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, - _ForwardIterator __first2, - _ForwardIterator __last2, const _Tp& __x, - _Allocator& __alloc) - { - _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, - __first2, - __alloc); - try - { - std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); - } - catch(...) - { - std::_Destroy(__first2, __mid2, __alloc); - throw; - } - } -# 592 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - struct __uninitialized_default_1 - { - template - static void - __uninit_default(_ForwardIterator __first, _ForwardIterator __last) - { - _ForwardIterator __cur = __first; - try - { - for (; __cur != __last; ++__cur) - std::_Construct(std::__addressof(*__cur)); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_1 - { - template - static void - __uninit_default(_ForwardIterator __first, _ForwardIterator __last) - { - if (__first == __last) - return; - - typename iterator_traits<_ForwardIterator>::value_type* __val - = std::__addressof(*__first); - std::_Construct(__val); - if (++__first != __last) - std::fill(__first, __last, *__val); - } - }; - - template - struct __uninitialized_default_n_1 - { - template - - static _ForwardIterator - __uninit_default_n(_ForwardIterator __first, _Size __n) - { - _ForwardIterator __cur = __first; - try - { - for (; __n > 0; --__n, (void) ++__cur) - std::_Construct(std::__addressof(*__cur)); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_n_1 - { - template - - static _ForwardIterator - __uninit_default_n(_ForwardIterator __first, _Size __n) - { - if (__n > 0) - { - typename iterator_traits<_ForwardIterator>::value_type* __val - = std::__addressof(*__first); - std::_Construct(__val); - ++__first; - __first = std::fill_n(__first, __n - 1, *__val); - } - return __first; - } - }; - - - - template - inline void - __uninitialized_default(_ForwardIterator __first, - _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - const bool __assignable = is_copy_assignable<_ValueType>::value; - - std::__uninitialized_default_1<__is_trivial(_ValueType) - && __assignable>:: - __uninit_default(__first, __last); - } - - - - template - - inline _ForwardIterator - __uninitialized_default_n(_ForwardIterator __first, _Size __n) - { - - - - - - - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - constexpr bool __can_fill - = __and_, is_copy_assignable<_ValueType>>::value; - - return __uninitialized_default_n_1<__is_trivial(_ValueType) - && __can_fill>:: - __uninit_default_n(__first, __n); - } - - - - - - template - void - __uninitialized_default_a(_ForwardIterator __first, - _ForwardIterator __last, - _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __cur != __last; ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur)); - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - template - inline void - __uninitialized_default_a(_ForwardIterator __first, - _ForwardIterator __last, - allocator<_Tp>&) - { std::__uninitialized_default(__first, __last); } - - - - - - template - _ForwardIterator - __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, - _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __n > 0; --__n, (void) ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur)); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - - - template - - inline _ForwardIterator - __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, - allocator<_Tp>&) - { return std::__uninitialized_default_n(__first, __n); } - - - template - struct __uninitialized_default_novalue_1 - { - template - static void - __uninit_default_novalue(_ForwardIterator __first, - _ForwardIterator __last) - { - _ForwardIterator __cur = __first; - try - { - for (; __cur != __last; ++__cur) - std::_Construct_novalue(std::__addressof(*__cur)); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_novalue_1 - { - template - static void - __uninit_default_novalue(_ForwardIterator __first, - _ForwardIterator __last) - { - } - }; - - template - struct __uninitialized_default_novalue_n_1 - { - template - static _ForwardIterator - __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) - { - _ForwardIterator __cur = __first; - try - { - for (; __n > 0; --__n, (void) ++__cur) - std::_Construct_novalue(std::__addressof(*__cur)); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_novalue_n_1 - { - template - static _ForwardIterator - __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) - { return std::next(__first, __n); } - }; - - - - template - inline void - __uninitialized_default_novalue(_ForwardIterator __first, - _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - std::__uninitialized_default_novalue_1< - is_trivially_default_constructible<_ValueType>::value>:: - __uninit_default_novalue(__first, __last); - } - - - - template - inline _ForwardIterator - __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - return __uninitialized_default_novalue_n_1< - is_trivially_default_constructible<_ValueType>::value>:: - __uninit_default_novalue_n(__first, __n); - } - - template - _ForwardIterator - __uninitialized_copy_n(_InputIterator __first, _Size __n, - _ForwardIterator __result, input_iterator_tag) - { - _ForwardIterator __cur = __result; - try - { - for (; __n > 0; --__n, (void) ++__first, ++__cur) - std::_Construct(std::__addressof(*__cur), *__first); - return __cur; - } - catch(...) - { - std::_Destroy(__result, __cur); - throw; - } - } - - template - inline _ForwardIterator - __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, - _ForwardIterator __result, - random_access_iterator_tag) - { return std::uninitialized_copy(__first, __first + __n, __result); } - - template - pair<_InputIterator, _ForwardIterator> - __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, - _ForwardIterator __result, input_iterator_tag) - { - _ForwardIterator __cur = __result; - try - { - for (; __n > 0; --__n, (void) ++__first, ++__cur) - std::_Construct(std::__addressof(*__cur), *__first); - return {__first, __cur}; - } - catch(...) - { - std::_Destroy(__result, __cur); - throw; - } - } - - template - inline pair<_RandomAccessIterator, _ForwardIterator> - __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, - _ForwardIterator __result, - random_access_iterator_tag) - { - auto __second_res = uninitialized_copy(__first, __first + __n, __result); - auto __first_res = std::next(__first, __n); - return {__first_res, __second_res}; - } -# 947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_copy_n(_InputIterator __first, _Size __n, - _ForwardIterator __result) - { return std::__uninitialized_copy_n(__first, __n, __result, - std::__iterator_category(__first)); } - - - template - inline pair<_InputIterator, _ForwardIterator> - __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, - _ForwardIterator __result) - { - return - std::__uninitialized_copy_n_pair(__first, __n, __result, - std::__iterator_category(__first)); - } -# 976 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline void - uninitialized_default_construct(_ForwardIterator __first, - _ForwardIterator __last) - { - __uninitialized_default_novalue(__first, __last); - } -# 991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) - { - return __uninitialized_default_novalue_n(__first, __count); - } - - - - - - - - template - inline void - uninitialized_value_construct(_ForwardIterator __first, - _ForwardIterator __last) - { - return __uninitialized_default(__first, __last); - } -# 1019 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) - { - return __uninitialized_default_n(__first, __count); - } -# 1034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_move(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { - return std::uninitialized_copy - (std::make_move_iterator(__first), - std::make_move_iterator(__last), __result); - } -# 1052 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline pair<_InputIterator, _ForwardIterator> - uninitialized_move_n(_InputIterator __first, _Size __count, - _ForwardIterator __result) - { - auto __res = std::__uninitialized_copy_n_pair - (std::make_move_iterator(__first), - __count, __result); - return {__res.first.base(), __res.second}; - } - - - - - - template - - inline void - __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig, - _Allocator& __alloc) - noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, - __dest, std::move(*__orig))) - && noexcept(std::allocator_traits<_Allocator>::destroy( - __alloc, std::__addressof(*__orig)))) - { - typedef std::allocator_traits<_Allocator> __traits; - __traits::construct(__alloc, __dest, std::move(*__orig)); - __traits::destroy(__alloc, std::__addressof(*__orig)); - } - - - - template - struct __is_bitwise_relocatable - : is_trivial<_Tp> { }; - - template - - inline _ForwardIterator - __relocate_a_1(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), - std::addressof(*__first), - __alloc))) - { - typedef typename iterator_traits<_InputIterator>::value_type - _ValueType; - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType2; - static_assert(std::is_same<_ValueType, _ValueType2>::value, - "relocation is only possible for values of the same type"); - _ForwardIterator __cur = __result; - for (; __first != __last; ++__first, (void)++__cur) - std::__relocate_object_a(std::__addressof(*__cur), - std::__addressof(*__first), __alloc); - return __cur; - } - - - template - - inline __enable_if_t::value, _Tp*> - __relocate_a_1(_Tp* __first, _Tp* __last, - _Tp* __result, - [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept - { - ptrdiff_t __count = __last - __first; - if (__count > 0) - { -# 1132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - __builtin_memmove(__result, __first, __count * sizeof(_Tp)); - } - return __result + __count; - } - - - template - - inline _ForwardIterator - __relocate_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result), __alloc))) - { - return std::__relocate_a_1(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result), __alloc); - } - - - - - - - -} -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_raw_storage_iter.h" 1 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_raw_storage_iter.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - - - - template - class [[__deprecated__]] raw_storage_iterator - : public iterator - { - protected: - _OutputIterator _M_iter; - - public: - explicit - raw_storage_iterator(_OutputIterator __x) - : _M_iter(__x) {} - - raw_storage_iterator& - operator*() { return *this; } - - raw_storage_iterator& - operator=(const _Tp& __element) - { - std::_Construct(std::__addressof(*_M_iter), __element); - return *this; - } - - - - - raw_storage_iterator& - operator=(_Tp&& __element) - { - std::_Construct(std::__addressof(*_M_iter), std::move(__element)); - return *this; - } - - - raw_storage_iterator& - operator++() - { - ++_M_iter; - return *this; - } - - raw_storage_iterator - operator++(int) - { - raw_storage_iterator __tmp = *this; - ++_M_iter; - return __tmp; - } - - - - _OutputIterator base() const { return _M_iter; } - }; -#pragma GCC diagnostic pop - - -} -# 71 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 -# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 -# 52 "/usr/lib/clang/16/include/stdint.h" 3 -# 1 "/usr/include/stdint.h" 1 3 4 -# 26 "/usr/include/stdint.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/stdint.h" 2 3 4 -# 1 "/usr/include/bits/types.h" 1 3 4 -# 27 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 28 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 29 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned char __u_char; -typedef unsigned short int __u_short; -typedef unsigned int __u_int; -typedef unsigned long int __u_long; - - -typedef signed char __int8_t; -typedef unsigned char __uint8_t; -typedef signed short int __int16_t; -typedef unsigned short int __uint16_t; -typedef signed int __int32_t; -typedef unsigned int __uint32_t; - -typedef signed long int __int64_t; -typedef unsigned long int __uint64_t; - - - - - - -typedef __int8_t __int_least8_t; -typedef __uint8_t __uint_least8_t; -typedef __int16_t __int_least16_t; -typedef __uint16_t __uint_least16_t; -typedef __int32_t __int_least32_t; -typedef __uint32_t __uint_least32_t; -typedef __int64_t __int_least64_t; -typedef __uint64_t __uint_least64_t; - - - -typedef long int __quad_t; -typedef unsigned long int __u_quad_t; - - - - - - - -typedef long int __intmax_t; -typedef unsigned long int __uintmax_t; -# 141 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/typesizes.h" 1 3 4 -# 142 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/time64.h" 1 3 4 -# 143 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned long int __dev_t; -typedef unsigned int __uid_t; -typedef unsigned int __gid_t; -typedef unsigned long int __ino_t; -typedef unsigned long int __ino64_t; -typedef unsigned int __mode_t; -typedef unsigned long int __nlink_t; -typedef long int __off_t; -typedef long int __off64_t; -typedef int __pid_t; -typedef struct { int __val[2]; } __fsid_t; -typedef long int __clock_t; -typedef unsigned long int __rlim_t; -typedef unsigned long int __rlim64_t; -typedef unsigned int __id_t; -typedef long int __time_t; -typedef unsigned int __useconds_t; -typedef long int __suseconds_t; -typedef long int __suseconds64_t; - -typedef int __daddr_t; -typedef int __key_t; - - -typedef int __clockid_t; - - -typedef void * __timer_t; - - -typedef long int __blksize_t; - - - - -typedef long int __blkcnt_t; -typedef long int __blkcnt64_t; - - -typedef unsigned long int __fsblkcnt_t; -typedef unsigned long int __fsblkcnt64_t; - - -typedef unsigned long int __fsfilcnt_t; -typedef unsigned long int __fsfilcnt64_t; - - -typedef long int __fsword_t; - -typedef long int __ssize_t; - - -typedef long int __syscall_slong_t; - -typedef unsigned long int __syscall_ulong_t; - - - -typedef __off64_t __loff_t; -typedef char *__caddr_t; - - -typedef long int __intptr_t; - - -typedef unsigned int __socklen_t; - - - - -typedef int __sig_atomic_t; -# 28 "/usr/include/stdint.h" 2 3 4 -# 1 "/usr/include/bits/wchar.h" 1 3 4 -# 29 "/usr/include/stdint.h" 2 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 30 "/usr/include/stdint.h" 2 3 4 - - - - -# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-intn.h" 3 4 -typedef __int8_t int8_t; -typedef __int16_t int16_t; -typedef __int32_t int32_t; -typedef __int64_t int64_t; -# 35 "/usr/include/stdint.h" 2 3 4 - - -# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-uintn.h" 3 4 -typedef __uint8_t uint8_t; -typedef __uint16_t uint16_t; -typedef __uint32_t uint32_t; -typedef __uint64_t uint64_t; -# 38 "/usr/include/stdint.h" 2 3 4 - - - - - -typedef __int_least8_t int_least8_t; -typedef __int_least16_t int_least16_t; -typedef __int_least32_t int_least32_t; -typedef __int_least64_t int_least64_t; - - -typedef __uint_least8_t uint_least8_t; -typedef __uint_least16_t uint_least16_t; -typedef __uint_least32_t uint_least32_t; -typedef __uint_least64_t uint_least64_t; - - - - - -typedef signed char int_fast8_t; - -typedef long int int_fast16_t; -typedef long int int_fast32_t; -typedef long int int_fast64_t; -# 71 "/usr/include/stdint.h" 3 4 -typedef unsigned char uint_fast8_t; - -typedef unsigned long int uint_fast16_t; -typedef unsigned long int uint_fast32_t; -typedef unsigned long int uint_fast64_t; -# 87 "/usr/include/stdint.h" 3 4 -typedef long int intptr_t; - - -typedef unsigned long int uintptr_t; -# 101 "/usr/include/stdint.h" 3 4 -typedef __intmax_t intmax_t; -typedef __uintmax_t uintmax_t; -# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 -inline void* -align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept -{ - if (__space < __size) - return nullptr; - const auto __intptr = reinterpret_cast(__ptr); - const auto __aligned = (__intptr - 1u + __align) & -__align; - const auto __diff = __aligned - __intptr; - if (__diff > (__space - __size)) - return nullptr; - else - { - __space -= __diff; - return __ptr = reinterpret_cast(__aligned); - } -} -# 109 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 -} -# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct unary_function - { - - typedef _Arg argument_type; - - - typedef _Result result_type; - } __attribute__ ((__deprecated__)); - - - - - - template - struct binary_function - { - - typedef _Arg1 first_argument_type; - - - typedef _Arg2 second_argument_type; - - - typedef _Result result_type; - } __attribute__ ((__deprecated__)); -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - struct __is_transparent; - - template - struct plus; - - template - struct minus; - - template - struct multiplies; - - template - struct divides; - - template - struct modulus; - - template - struct negate; - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct plus : public binary_function<_Tp, _Tp, _Tp> - { - - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x + __y; } - }; - - - template - struct minus : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x - __y; } - }; - - - template - struct multiplies : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x * __y; } - }; - - - template - struct divides : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x / __y; } - }; - - - template - struct modulus : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x % __y; } - }; - - - template - struct negate : public unary_function<_Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x) const - { return -__x; } - }; -#pragma GCC diagnostic pop - - - - - - template<> - struct plus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct minus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct multiplies - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct divides - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct modulus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct negate - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(-std::forward<_Tp>(__t))) - -> decltype(-std::forward<_Tp>(__t)) - { return -std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; -# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct equal_to; - - template - struct not_equal_to; - - template - struct greater; - - template - struct less; - - template - struct greater_equal; - - template - struct less_equal; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct equal_to : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x == __y; } - }; - - - template - struct not_equal_to : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x != __y; } - }; - - - template - struct greater : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x > __y; } - }; - - - template - struct less : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x < __y; } - }; - - - template - struct greater_equal : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x >= __y; } - }; - - - template - struct less_equal : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x <= __y; } - }; - - - template - struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x > __y; - - return (long unsigned int)__x > (long unsigned int)__y; - } - }; - - - template - struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x < __y; - - return (long unsigned int)__x < (long unsigned int)__y; - } - }; - - - template - struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x >= __y; - - return (long unsigned int)__x >= (long unsigned int)__y; - } - }; - - - template - struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x <= __y; - - return (long unsigned int)__x <= (long unsigned int)__y; - } - }; -#pragma GCC diagnostic pop - - - - template<> - struct equal_to - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct not_equal_to - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct greater - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return greater>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return greater{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct less - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return less>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return less{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct greater_equal - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return greater_equal>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return greater_equal{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct less_equal - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return less_equal>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return less_equal{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; -# 781 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct logical_and; - - template - struct logical_or; - - template - struct logical_not; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct logical_and : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x && __y; } - }; - - - template - struct logical_or : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x || __y; } - }; - - - template - struct logical_not : public unary_function<_Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x) const - { return !__x; } - }; -#pragma GCC diagnostic pop - - - - template<> - struct logical_and - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct logical_or - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct logical_not - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(!std::forward<_Tp>(__t))) - -> decltype(!std::forward<_Tp>(__t)) - { return !std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; - - - - - template - struct bit_and; - - template - struct bit_or; - - template - struct bit_xor; - - template - struct bit_not; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - - template - struct bit_and : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x & __y; } - }; - - template - struct bit_or : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x | __y; } - }; - - template - struct bit_xor : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x ^ __y; } - }; - - template - struct bit_not : public unary_function<_Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x) const - { return ~__x; } - }; -#pragma GCC diagnostic pop - - - template <> - struct bit_and - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_or - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_xor - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_not - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(~std::forward<_Tp>(__t))) - -> decltype(~std::forward<_Tp>(__t)) - { return ~std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class [[__deprecated__]] unary_negate - : public unary_function - { - protected: - _Predicate _M_pred; - - public: - constexpr - explicit - unary_negate(const _Predicate& __x) : _M_pred(__x) { } - - constexpr - bool - operator()(const typename _Predicate::argument_type& __x) const - { return !_M_pred(__x); } - }; - - - template - __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) - constexpr - inline unary_negate<_Predicate> - not1(const _Predicate& __pred) - { return unary_negate<_Predicate>(__pred); } - - - template - class [[__deprecated__]] binary_negate - : public binary_function - { - protected: - _Predicate _M_pred; - - public: - constexpr - explicit - binary_negate(const _Predicate& __x) : _M_pred(__x) { } - - constexpr - bool - operator()(const typename _Predicate::first_argument_type& __x, - const typename _Predicate::second_argument_type& __y) const - { return !_M_pred(__x, __y); } - }; - - - template - __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) - constexpr - inline binary_negate<_Predicate> - not2(const _Predicate& __pred) - { return binary_negate<_Predicate>(__pred); } -# 1104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class pointer_to_unary_function : public unary_function<_Arg, _Result> - { - protected: - _Result (*_M_ptr)(_Arg); - - public: - pointer_to_unary_function() { } - - explicit - pointer_to_unary_function(_Result (*__x)(_Arg)) - : _M_ptr(__x) { } - - _Result - operator()(_Arg __x) const - { return _M_ptr(__x); } - } __attribute__ ((__deprecated__)); - - - template - __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) - inline pointer_to_unary_function<_Arg, _Result> - ptr_fun(_Result (*__x)(_Arg)) - { return pointer_to_unary_function<_Arg, _Result>(__x); } - - - template - class pointer_to_binary_function - : public binary_function<_Arg1, _Arg2, _Result> - { - protected: - _Result (*_M_ptr)(_Arg1, _Arg2); - - public: - pointer_to_binary_function() { } - - explicit - pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) - : _M_ptr(__x) { } - - _Result - operator()(_Arg1 __x, _Arg2 __y) const - { return _M_ptr(__x, __y); } - } __attribute__ ((__deprecated__)); - - - template - __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) - inline pointer_to_binary_function<_Arg1, _Arg2, _Result> - ptr_fun(_Result (*__x)(_Arg1, _Arg2)) - { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } - - - template - struct _Identity - : public unary_function<_Tp, _Tp> - { - _Tp& - operator()(_Tp& __x) const - { return __x; } - - const _Tp& - operator()(const _Tp& __x) const - { return __x; } - }; - - - template struct _Identity : _Identity<_Tp> { }; - - template - struct _Select1st - : public unary_function<_Pair, typename _Pair::first_type> - { - typename _Pair::first_type& - operator()(_Pair& __x) const - { return __x.first; } - - const typename _Pair::first_type& - operator()(const _Pair& __x) const - { return __x.first; } - - - template - typename _Pair2::first_type& - operator()(_Pair2& __x) const - { return __x.first; } - - template - const typename _Pair2::first_type& - operator()(const _Pair2& __x) const - { return __x.first; } - - }; - - template - struct _Select2nd - : public unary_function<_Pair, typename _Pair::second_type> - { - typename _Pair::second_type& - operator()(_Pair& __x) const - { return __x.second; } - - const typename _Pair::second_type& - operator()(const _Pair& __x) const - { return __x.second; } - }; -# 1231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class mem_fun_t : public unary_function<_Tp*, _Ret> - { - public: - explicit - mem_fun_t(_Ret (_Tp::*__pf)()) - : _M_f(__pf) { } - - _Ret - operator()(_Tp* __p) const - { return (__p->*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)(); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun_t : public unary_function - { - public: - explicit - const_mem_fun_t(_Ret (_Tp::*__pf)() const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp* __p) const - { return (__p->*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)() const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun_ref_t : public unary_function<_Tp, _Ret> - { - public: - explicit - mem_fun_ref_t(_Ret (_Tp::*__pf)()) - : _M_f(__pf) { } - - _Ret - operator()(_Tp& __r) const - { return (__r.*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)(); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> - { - public: - explicit - const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp& __r) const - { return (__r.*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)() const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> - { - public: - explicit - mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) - : _M_f(__pf) { } - - _Ret - operator()(_Tp* __p, _Arg __x) const - { return (__p->*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun1_t : public binary_function - { - public: - explicit - const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp* __p, _Arg __x) const - { return (__p->*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg) const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> - { - public: - explicit - mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) - : _M_f(__pf) { } - - _Ret - operator()(_Tp& __r, _Arg __x) const - { return (__r.*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> - { - public: - explicit - const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp& __r, _Arg __x) const - { return (__r.*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg) const; - } __attribute__ ((__deprecated__)); - - - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun_t<_Ret, _Tp> - mem_fun(_Ret (_Tp::*__f)()) - { return mem_fun_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun_t<_Ret, _Tp> - mem_fun(_Ret (_Tp::*__f)() const) - { return const_mem_fun_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun_ref_t<_Ret, _Tp> - mem_fun_ref(_Ret (_Tp::*__f)()) - { return mem_fun_ref_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun_ref_t<_Ret, _Tp> - mem_fun_ref(_Ret (_Tp::*__f)() const) - { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun1_t<_Ret, _Tp, _Arg> - mem_fun(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun1_t<_Ret, _Tp, _Arg> - mem_fun(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun1_ref_t<_Ret, _Tp, _Arg> - mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> - mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } -#pragma GCC diagnostic pop - - - - - template> - struct __has_is_transparent - { }; - - template - struct __has_is_transparent<_Func, _SfinaeType, - __void_t> - { typedef void type; }; - - template - using __has_is_transparent_t - = typename __has_is_transparent<_Func, _SfinaeType>::type; - - - -} - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 1 3 -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 - template - class binder1st - : public unary_function - { - protected: - _Operation op; - typename _Operation::first_argument_type value; - - public: - binder1st(const _Operation& __x, - const typename _Operation::first_argument_type& __y) - : op(__x), value(__y) { } - - typename _Operation::result_type - operator()(const typename _Operation::second_argument_type& __x) const - { return op(value, __x); } - - - - typename _Operation::result_type - operator()(typename _Operation::second_argument_type& __x) const - { return op(value, __x); } - } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); - - - template - __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) - inline binder1st<_Operation> - bind1st(const _Operation& __fn, const _Tp& __x) - { - typedef typename _Operation::first_argument_type _Arg1_type; - return binder1st<_Operation>(__fn, _Arg1_type(__x)); - } - - - template - class binder2nd - : public unary_function - { - protected: - _Operation op; - typename _Operation::second_argument_type value; - - public: - binder2nd(const _Operation& __x, - const typename _Operation::second_argument_type& __y) - : op(__x), value(__y) { } - - typename _Operation::result_type - operator()(const typename _Operation::first_argument_type& __x) const - { return op(__x, value); } - - - - typename _Operation::result_type - operator()(typename _Operation::first_argument_type& __x) const - { return op(__x, value); } - } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); - - - template - __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) - inline binder2nd<_Operation> - bind2nd(const _Operation& __fn, const _Tp& __x) - { - typedef typename _Operation::second_argument_type _Arg2_type; - return binder2nd<_Operation>(__fn, _Arg2_type(__x)); - } - - - -} - -#pragma GCC diagnostic pop -# 1439 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 2 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hash_bytes.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template - struct __hash_base - { - typedef _Result result_type [[__deprecated__]]; - typedef _Arg argument_type [[__deprecated__]]; - }; - - - template - struct hash; - - template - struct __poison_hash - { - static constexpr bool __enable_hash_call = false; - private: - - __poison_hash(__poison_hash&&); - ~__poison_hash(); - }; - - template - struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> - { - static constexpr bool __enable_hash_call = true; - }; - - - template::value> - struct __hash_enum - { - private: - - __hash_enum(__hash_enum&&); - ~__hash_enum(); - }; - - - template - struct __hash_enum<_Tp, true> : public __hash_base - { - size_t - operator()(_Tp __val) const noexcept - { - using __type = typename underlying_type<_Tp>::type; - return hash<__type>{}(static_cast<__type>(__val)); - } - }; - - - - template - struct hash : __hash_enum<_Tp> - { }; - - - template - struct hash<_Tp*> : public __hash_base - { - size_t - operator()(_Tp* __p) const noexcept - { return reinterpret_cast(__p); } - }; -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; - - - - - - - - template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; -# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - struct _Hash_impl - { - static size_t - hash(const void* __ptr, size_t __clength, - size_t __seed = static_cast(0xc70f6907UL)) - { return _Hash_bytes(__ptr, __clength, __seed); } - - template - static size_t - hash(const _Tp& __val) - { return hash(&__val, sizeof(__val)); } - - template - static size_t - __hash_combine(const _Tp& __val, size_t __hash) - { return hash(&__val, sizeof(__val), __hash); } - }; - - - struct _Fnv_hash_impl - { - static size_t - hash(const void* __ptr, size_t __clength, - size_t __seed = static_cast(2166136261UL)) - { return _Fnv_hash_bytes(__ptr, __clength, __seed); } - - template - static size_t - hash(const _Tp& __val) - { return hash(&__val, sizeof(__val)); } - - template - static size_t - __hash_combine(const _Tp& __val, size_t __hash) - { return hash(&__val, sizeof(__val), __hash); } - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(float __val) const noexcept - { - - return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; - } - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(double __val) const noexcept - { - - return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; - } - }; - - - template<> - struct hash - : public __hash_base - { - __attribute__ ((__pure__)) size_t - operator()(long double __val) const noexcept; - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(nullptr_t) const noexcept - { return 0; } - }; -# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template - struct __is_fast_hash : public std::true_type - { }; - - template<> - struct __is_fast_hash> : public std::false_type - { }; - - -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template class auto_ptr; -#pragma GCC diagnostic pop - - - - - - - - template - struct default_delete - { - - constexpr default_delete() noexcept = default; - - - - - - - template>> - - default_delete(const default_delete<_Up>&) noexcept { } - - - - void - operator()(_Tp* __ptr) const - { - static_assert(!is_void<_Tp>::value, - "can't delete pointer to incomplete type"); - static_assert(sizeof(_Tp)>0, - "can't delete pointer to incomplete type"); - delete __ptr; - } - }; -# 111 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - struct default_delete<_Tp[]> - { - public: - - constexpr default_delete() noexcept = default; -# 127 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template>> - - default_delete(const default_delete<_Up[]>&) noexcept { } - - - template - - typename enable_if::value>::type - operator()(_Up* __ptr) const - { - static_assert(sizeof(_Tp)>0, - "can't delete pointer to incomplete type"); - delete [] __ptr; - } - }; - - - - - template - class __uniq_ptr_impl - { - template - struct _Ptr - { - using type = _Up*; - }; - - template - struct - _Ptr<_Up, _Ep, __void_t::type::pointer>> - { - using type = typename remove_reference<_Ep>::type::pointer; - }; - - public: - using _DeleterConstraint = enable_if< - __and_<__not_>, - is_default_constructible<_Dp>>::value>; - - using pointer = typename _Ptr<_Tp, _Dp>::type; - - static_assert( !is_rvalue_reference<_Dp>::value, - "unique_ptr's deleter type must be a function object type" - " or an lvalue reference type" ); - - __uniq_ptr_impl() = default; - - __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; } - - template - - __uniq_ptr_impl(pointer __p, _Del&& __d) - : _M_t(__p, std::forward<_Del>(__d)) { } - - - __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept - : _M_t(std::move(__u._M_t)) - { __u._M_ptr() = nullptr; } - - - __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept - { - reset(__u.release()); - _M_deleter() = std::forward<_Dp>(__u._M_deleter()); - return *this; - } - - - pointer& _M_ptr() noexcept { return std::get<0>(_M_t); } - - pointer _M_ptr() const noexcept { return std::get<0>(_M_t); } - - _Dp& _M_deleter() noexcept { return std::get<1>(_M_t); } - - const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); } - - - void reset(pointer __p) noexcept - { - const pointer __old_p = _M_ptr(); - _M_ptr() = __p; - if (__old_p) - _M_deleter()(__old_p); - } - - - pointer release() noexcept - { - pointer __p = _M_ptr(); - _M_ptr() = nullptr; - return __p; - } - - - void - swap(__uniq_ptr_impl& __rhs) noexcept - { - using std::swap; - swap(this->_M_ptr(), __rhs._M_ptr()); - swap(this->_M_deleter(), __rhs._M_deleter()); - } - - private: - tuple _M_t; - }; - - - template ::value, - bool = is_move_assignable<_Dp>::value> - struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp> - { - using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; - __uniq_ptr_data(__uniq_ptr_data&&) = default; - __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; - }; - - template - struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp> - { - using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; - __uniq_ptr_data(__uniq_ptr_data&&) = default; - __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; - }; - - template - struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp> - { - using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; - __uniq_ptr_data(__uniq_ptr_data&&) = delete; - __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; - }; - - template - struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp> - { - using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; - __uniq_ptr_data(__uniq_ptr_data&&) = delete; - __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; - }; - - - - - - - - template > - class unique_ptr - { - template - using _DeleterConstraint = - typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; - - __uniq_ptr_data<_Tp, _Dp> _M_t; - - public: - using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; - using element_type = _Tp; - using deleter_type = _Dp; - - private: - - - template - using __safe_conversion_up = __and_< - is_convertible::pointer, pointer>, - __not_> - >; - - public: - - - - template> - constexpr unique_ptr() noexcept - : _M_t() - { } - - - - - - - - template> - - explicit - unique_ptr(pointer __p) noexcept - : _M_t(__p) - { } -# 328 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template>> - - unique_ptr(pointer __p, const deleter_type& __d) noexcept - : _M_t(__p, __d) { } -# 341 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template>> - - unique_ptr(pointer __p, - __enable_if_t::value, - _Del&&> __d) noexcept - : _M_t(__p, std::move(__d)) - { } - - template::type> - - unique_ptr(pointer, - __enable_if_t::value, - _DelUnref&&>) = delete; - - - template> - constexpr unique_ptr(nullptr_t) noexcept - : _M_t() - { } - - - - - unique_ptr(unique_ptr&&) = default; - - - - - - - - template, - __conditional_t::value, - is_same<_Ep, _Dp>, - is_convertible<_Ep, _Dp>>>> - - unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept - : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) - { } - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template, is_same<_Dp, default_delete<_Tp>>>> - unique_ptr(auto_ptr<_Up>&& __u) noexcept; -#pragma GCC diagnostic pop - - - - - - - ~unique_ptr() noexcept - { - static_assert(__is_invocable::value, - "unique_ptr's deleter must be invocable with a pointer"); - auto& __ptr = _M_t._M_ptr(); - if (__ptr != nullptr) - get_deleter()(std::move(__ptr)); - __ptr = pointer(); - } - - - - - - - - unique_ptr& operator=(unique_ptr&&) = default; -# 423 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - - typename enable_if< __and_< - __safe_conversion_up<_Up, _Ep>, - is_assignable - >::value, - unique_ptr&>::type - operator=(unique_ptr<_Up, _Ep>&& __u) noexcept - { - reset(__u.release()); - get_deleter() = std::forward<_Ep>(__u.get_deleter()); - return *this; - } - - - - unique_ptr& - operator=(nullptr_t) noexcept - { - reset(); - return *this; - } - - - - - - typename add_lvalue_reference::type - operator*() const noexcept(noexcept(*std::declval())) - { - do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) __builtin_unreachable(); } while (false); - return *get(); - } - - - - pointer - operator->() const noexcept - { - ; - return get(); - } - - - - pointer - get() const noexcept - { return _M_t._M_ptr(); } - - - - deleter_type& - get_deleter() noexcept - { return _M_t._M_deleter(); } - - - - const deleter_type& - get_deleter() const noexcept - { return _M_t._M_deleter(); } - - - - explicit operator bool() const noexcept - { return get() == pointer() ? false : true; } - - - - - - pointer - release() noexcept - { return _M_t.release(); } -# 504 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - void - reset(pointer __p = pointer()) noexcept - { - static_assert(__is_invocable::value, - "unique_ptr's deleter must be invocable with a pointer"); - _M_t.reset(std::move(__p)); - } - - - - void - swap(unique_ptr& __u) noexcept - { - static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); - _M_t.swap(__u._M_t); - } - - - unique_ptr(const unique_ptr&) = delete; - unique_ptr& operator=(const unique_ptr&) = delete; - }; -# 534 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - class unique_ptr<_Tp[], _Dp> - { - template - using _DeleterConstraint = - typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; - - __uniq_ptr_data<_Tp, _Dp> _M_t; - - - template - using __is_derived_Tp - = __and_< is_base_of<_Tp, _Up>, - __not_, __remove_cv_t<_Up>>> >; - - public: - using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; - using element_type = _Tp; - using deleter_type = _Dp; - - - - template, - typename _UP_pointer = typename _UPtr::pointer, - typename _UP_element_type = typename _UPtr::element_type> - using __safe_conversion_up = __and_< - is_array<_Up>, - is_same, - is_same<_UP_pointer, _UP_element_type*>, - is_convertible<_UP_element_type(*)[], element_type(*)[]> - >; - - - template - using __safe_conversion_raw = __and_< - __or_<__or_, - is_same<_Up, nullptr_t>>, - __and_, - is_same, - is_convertible< - typename remove_pointer<_Up>::type(*)[], - element_type(*)[]> - > - > - >; - - - - - template> - constexpr unique_ptr() noexcept - : _M_t() - { } -# 596 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template, - typename = typename enable_if< - __safe_conversion_raw<_Up>::value, bool>::type> - - explicit - unique_ptr(_Up __p) noexcept - : _M_t(__p) - { } -# 615 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template, - is_copy_constructible<_Del>>> - - unique_ptr(_Up __p, const deleter_type& __d) noexcept - : _M_t(__p, __d) { } -# 630 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template, - is_move_constructible<_Del>>> - - unique_ptr(_Up __p, - __enable_if_t::value, - _Del&&> __d) noexcept - : _M_t(std::move(__p), std::move(__d)) - { } - - template::type, - typename = _Require<__safe_conversion_raw<_Up>>> - unique_ptr(_Up, - __enable_if_t::value, - _DelUnref&&>) = delete; - - - unique_ptr(unique_ptr&&) = default; - - - template> - constexpr unique_ptr(nullptr_t) noexcept - : _M_t() - { } - - template, - __conditional_t::value, - is_same<_Ep, _Dp>, - is_convertible<_Ep, _Dp>>>> - - unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept - : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) - { } - - - - - - ~unique_ptr() - { - auto& __ptr = _M_t._M_ptr(); - if (__ptr != nullptr) - get_deleter()(__ptr); - __ptr = pointer(); - } - - - - - - - - unique_ptr& - operator=(unique_ptr&&) = default; -# 694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - - typename - enable_if<__and_<__safe_conversion_up<_Up, _Ep>, - is_assignable - >::value, - unique_ptr&>::type - operator=(unique_ptr<_Up, _Ep>&& __u) noexcept - { - reset(__u.release()); - get_deleter() = std::forward<_Ep>(__u.get_deleter()); - return *this; - } - - - - unique_ptr& - operator=(nullptr_t) noexcept - { - reset(); - return *this; - } - - - - - - typename std::add_lvalue_reference::type - operator[](size_t __i) const - { - do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) __builtin_unreachable(); } while (false); - return get()[__i]; - } - - - - pointer - get() const noexcept - { return _M_t._M_ptr(); } - - - - deleter_type& - get_deleter() noexcept - { return _M_t._M_deleter(); } - - - - const deleter_type& - get_deleter() const noexcept - { return _M_t._M_deleter(); } - - - - explicit operator bool() const noexcept - { return get() == pointer() ? false : true; } - - - - - - pointer - release() noexcept - { return _M_t.release(); } - - - - - - - - template , - __and_, - is_pointer<_Up>, - is_convertible< - typename remove_pointer<_Up>::type(*)[], - element_type(*)[] - > - > - > - >> - - void - reset(_Up __p) noexcept - { _M_t.reset(std::move(__p)); } - - - void reset(nullptr_t = nullptr) noexcept - { reset(pointer()); } - - - - void - swap(unique_ptr& __u) noexcept - { - static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); - _M_t.swap(__u._M_t); - } - - - unique_ptr(const unique_ptr&) = delete; - unique_ptr& operator=(const unique_ptr&) = delete; - }; - - - - - - template - inline - - - - typename enable_if<__is_swappable<_Dp>::value>::type - - - - swap(unique_ptr<_Tp, _Dp>& __x, - unique_ptr<_Tp, _Dp>& __y) noexcept - { __x.swap(__y); } - - - template - typename enable_if::value>::type - swap(unique_ptr<_Tp, _Dp>&, - unique_ptr<_Tp, _Dp>&) = delete; - - - - template - [[__nodiscard__]] - inline bool - operator==(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return __x.get() == __y.get(); } - - - template - [[__nodiscard__]] - inline bool - operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept - { return !__x; } - - - - template - [[__nodiscard__]] - inline bool - operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept - { return !__x; } - - - template - [[__nodiscard__]] - inline bool - operator!=(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return __x.get() != __y.get(); } - - - template - [[__nodiscard__]] - inline bool - operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept - { return (bool)__x; } - - - template - [[__nodiscard__]] - inline bool - operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept - { return (bool)__x; } - - - - template - [[__nodiscard__]] - inline bool - operator<(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { - typedef typename - std::common_type::pointer, - typename unique_ptr<_Up, _Ep>::pointer>::type _CT; - return std::less<_CT>()(__x.get(), __y.get()); - } - - - template - [[__nodiscard__]] - inline bool - operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) - { - return std::less::pointer>()(__x.get(), - nullptr); - } - - - template - [[__nodiscard__]] - inline bool - operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) - { - return std::less::pointer>()(nullptr, - __x.get()); - } - - - template - [[__nodiscard__]] - inline bool - operator<=(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return !(__y < __x); } - - - template - [[__nodiscard__]] - inline bool - operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) - { return !(nullptr < __x); } - - - template - [[__nodiscard__]] - inline bool - operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) - { return !(__x < nullptr); } - - - template - [[__nodiscard__]] - inline bool - operator>(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return (__y < __x); } - - - template - [[__nodiscard__]] - inline bool - operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) - { - return std::less::pointer>()(nullptr, - __x.get()); - } - - - template - [[__nodiscard__]] - inline bool - operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) - { - return std::less::pointer>()(__x.get(), - nullptr); - } - - - template - [[__nodiscard__]] - inline bool - operator>=(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return !(__x < __y); } - - - template - [[__nodiscard__]] - inline bool - operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) - { return !(__x < nullptr); } - - - template - [[__nodiscard__]] inline bool - operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) - { return !(nullptr < __x); } -# 1006 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template::__enable_hash_call> - struct __uniq_ptr_hash - - : private __poison_hash<_Ptr> - - { - size_t - operator()(const _Up& __u) const - noexcept(noexcept(std::declval>()(std::declval<_Ptr>()))) - { return hash<_Ptr>()(__u.get()); } - }; - - template - struct __uniq_ptr_hash<_Up, _Ptr, false> - : private __poison_hash<_Ptr> - { }; - - - - template - struct hash> - : public __hash_base>, - public __uniq_ptr_hash> - { }; - - - - - -namespace __detail -{ - template - struct _MakeUniq - { typedef unique_ptr<_Tp> __single_object; }; - - template - struct _MakeUniq<_Tp[]> - { typedef unique_ptr<_Tp[]> __array; }; - - template - struct _MakeUniq<_Tp[_Bound]> - { struct __invalid_type { }; }; - - template - using __unique_ptr_t = typename _MakeUniq<_Tp>::__single_object; - template - using __unique_ptr_array_t = typename _MakeUniq<_Tp>::__array; - template - using __invalid_make_unique_t = typename _MakeUniq<_Tp>::__invalid_type; -} -# 1066 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - - inline __detail::__unique_ptr_t<_Tp> - make_unique(_Args&&... __args) - { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } -# 1081 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - - inline __detail::__unique_ptr_array_t<_Tp> - make_unique(size_t __num) - { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); } - - - - - - - template - __detail::__invalid_make_unique_t<_Tp> - make_unique(_Args&&...) = delete; -# 1154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - namespace __detail::__variant - { - template struct _Never_valueless_alt; - - - - template - struct _Never_valueless_alt> - : std::true_type - { }; - } - - - -} -# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 1 3 -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 - template - struct char_traits; - - template<> struct char_traits; - - template<> struct char_traits; - - - - - - - template<> struct char_traits; - template<> struct char_traits; - - -namespace __cxx11 { - - template, - typename _Alloc = allocator<_CharT> > - class basic_string; - -} - - - typedef basic_string string; - - - typedef basic_string wstring; -# 89 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 - typedef basic_string u16string; - - - typedef basic_string u32string; - - - - - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 - - - - -# 1 "/usr/include/wchar.h" 1 3 4 -# 27 "/usr/include/wchar.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/include/bits/floatn.h" 1 3 4 -# 119 "/usr/include/bits/floatn.h" 3 4 -# 1 "/usr/include/bits/floatn-common.h" 1 3 4 -# 24 "/usr/include/bits/floatn-common.h" 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 25 "/usr/include/bits/floatn-common.h" 2 3 4 -# 214 "/usr/include/bits/floatn-common.h" 3 4 -typedef float _Float32; -# 251 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float64; -# 268 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float32x; -# 285 "/usr/include/bits/floatn-common.h" 3 4 -typedef long double _Float64x; -# 120 "/usr/include/bits/floatn.h" 2 3 4 -# 31 "/usr/include/wchar.h" 2 3 4 - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 36 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 -# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 -typedef __builtin_va_list __gnuc_va_list; -# 39 "/usr/include/wchar.h" 2 3 4 - - - - -typedef __gnuc_va_list va_list; -# 52 "/usr/include/wchar.h" 3 4 -# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 -# 20 "/usr/include/bits/types/wint_t.h" 3 4 -typedef unsigned int wint_t; -# 53 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 - - - -# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 -# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 -typedef struct -{ - int __count; - union - { - unsigned int __wch; - char __wchb[4]; - } __value; -} __mbstate_t; -# 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4 - -typedef __mbstate_t mbstate_t; -# 54 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 - - - -struct _IO_FILE; -typedef struct _IO_FILE __FILE; -# 55 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/include/bits/types/FILE.h" 1 3 4 - - - -struct _IO_FILE; - - -typedef struct _IO_FILE FILE; -# 58 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 -# 22 "/usr/include/bits/types/locale_t.h" 3 4 -# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 -# 27 "/usr/include/bits/types/__locale_t.h" 3 4 -struct __locale_struct -{ - - struct __locale_data *__locales[13]; - - - const unsigned short int *__ctype_b; - const int *__ctype_tolower; - const int *__ctype_toupper; - - - const char *__names[13]; -}; - -typedef struct __locale_struct *__locale_t; -# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 - -typedef __locale_t locale_t; -# 61 "/usr/include/wchar.h" 2 3 4 -# 90 "/usr/include/wchar.h" 3 4 -extern "C" { - - - -struct tm; - - - -extern wchar_t *wcscpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern wchar_t *wcsncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern size_t wcslcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern size_t wcslcat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern wchar_t *wcscat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern wchar_t *wcsncat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - -extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - -extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, - size_t __n) noexcept (true); - - - -extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - -extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - - - -extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - - -extern size_t wcsxfrm (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - - - - - -extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - - - - -extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - -extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) - __attribute__ ((__malloc__)) ; -# 189 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); -# 199 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - -extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) - noexcept (true) __attribute__ ((__pure__)); - - -extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 226 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 237 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - -extern wchar_t *wcstok (wchar_t *__restrict __s, - const wchar_t *__restrict __delim, - wchar_t **__restrict __ptr) noexcept (true); - - -extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); -# 258 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) - noexcept (true) __attribute__ ((__pure__)); -# 278 "/usr/include/wchar.h" 3 4 -extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - - -extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - -extern wchar_t *wmemcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - -extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true); - - -extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); - - - - -extern wchar_t *wmempcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) - noexcept (true); - - - - - -extern wint_t btowc (int __c) noexcept (true); - - - -extern int wctob (wint_t __c) noexcept (true); - - - -extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); - - - -extern size_t mbrtowc (wchar_t *__restrict __pwc, - const char *__restrict __s, size_t __n, - mbstate_t *__restrict __p) noexcept (true); - - -extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, - mbstate_t *__restrict __ps) noexcept (true); - - -extern size_t __mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); -extern size_t mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - - -extern wint_t __btowc_alias (int __c) __asm ("btowc"); -extern __inline __attribute__ ((__gnu_inline__)) wint_t - btowc (int __c) noexcept (true) -{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' - ? (wint_t) __c : __btowc_alias (__c)); } - -extern int __wctob_alias (wint_t __c) __asm ("wctob"); -extern __inline __attribute__ ((__gnu_inline__)) int - wctob (wint_t __wc) noexcept (true) -{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' - ? (int) __wc : __wctob_alias (__wc)); } - -extern __inline __attribute__ ((__gnu_inline__)) size_t - mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) - -{ return (__ps != __null - ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } - - - - -extern size_t mbsrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - -extern size_t mbsnrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __nmc, - size_t __len, mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsnrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, - size_t __nwc, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - -extern int wcwidth (wchar_t __c) noexcept (true); - - - -extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); - - - - - -extern double wcstod (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern float wcstof (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -extern long double wcstold (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 422 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 437 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 455 "/usr/include/wchar.h" 3 4 -extern long int wcstol (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) noexcept (true); - - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - - -extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); -# 561 "/usr/include/wchar.h" 3 4 -extern long int wcstol_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base, - locale_t __loc) noexcept (true); - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true); - - - - - -extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); - - - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); - - - - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); - - - - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); -# 630 "/usr/include/wchar.h" 3 4 -extern double wcstod_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern float wcstof_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern long double wcstold_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 649 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 667 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 689 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcpcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) noexcept (true); - - - -extern wchar_t *wcpncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true); -# 718 "/usr/include/wchar.h" 3 4 -extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern int fwide (__FILE *__fp, int __mode) noexcept (true); - - - - - - -extern int fwprintf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wprintf (const wchar_t *__restrict __format, ...) - ; - -extern int swprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, ...) - noexcept (true) ; - - - - - -extern int vfwprintf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwprintf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - -extern int vswprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; - - - - - - -extern int fwscanf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wscanf (const wchar_t *__restrict __format, ...) - ; - -extern int swscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, ...) - noexcept (true) ; -# 795 "/usr/include/wchar.h" 3 4 -extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") - - - ; -extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") - - ; -extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") - - - ; -# 851 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwscanf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - -extern int vswscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; -# 875 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") - - - ; -extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") - - ; -extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") - - - ; -# 935 "/usr/include/wchar.h" 3 4 -extern wint_t fgetwc (__FILE *__stream); -extern wint_t getwc (__FILE *__stream); - - - - - -extern wint_t getwchar (void); - - - - - - -extern wint_t fputwc (wchar_t __wc, __FILE *__stream); -extern wint_t putwc (wchar_t __wc, __FILE *__stream); - - - - - -extern wint_t putwchar (wchar_t __wc); - - - - - - - -extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - -extern int fputws (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern wint_t ungetwc (wint_t __wc, __FILE *__stream); -# 990 "/usr/include/wchar.h" 3 4 -extern wint_t getwc_unlocked (__FILE *__stream); -extern wint_t getwchar_unlocked (void); - - - - - - - -extern wint_t fgetwc_unlocked (__FILE *__stream); - - - - - - - -extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); -# 1016 "/usr/include/wchar.h" 3 4 -extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); -extern wint_t putwchar_unlocked (wchar_t __wc); -# 1026 "/usr/include/wchar.h" 3 4 -extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - - - -extern int fputws_unlocked (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp) noexcept (true); - - - - -extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp, - locale_t __loc) noexcept (true); -# 1073 "/usr/include/wchar.h" 3 4 -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 2 3 -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -namespace std -{ - using ::mbstate_t; -} -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::wint_t; - - using ::btowc; - using ::fgetwc; - using ::fgetws; - using ::fputwc; - using ::fputws; - using ::fwide; - using ::fwprintf; - using ::fwscanf; - using ::getwc; - using ::getwchar; - using ::mbrlen; - using ::mbrtowc; - using ::mbsinit; - using ::mbsrtowcs; - using ::putwc; - using ::putwchar; - - using ::swprintf; - - using ::swscanf; - using ::ungetwc; - using ::vfwprintf; - - using ::vfwscanf; - - - using ::vswprintf; - - - using ::vswscanf; - - using ::vwprintf; - - using ::vwscanf; - - using ::wcrtomb; - using ::wcscat; - using ::wcscmp; - using ::wcscoll; - using ::wcscpy; - using ::wcscspn; - using ::wcsftime; - using ::wcslen; - using ::wcsncat; - using ::wcsncmp; - using ::wcsncpy; - using ::wcsrtombs; - using ::wcsspn; - using ::wcstod; - - using ::wcstof; - - using ::wcstok; - using ::wcstol; - using ::wcstoul; - using ::wcsxfrm; - using ::wctob; - using ::wmemcmp; - using ::wmemcpy; - using ::wmemmove; - using ::wmemset; - using ::wprintf; - using ::wscanf; - using ::wcschr; - using ::wcspbrk; - using ::wcsrchr; - using ::wcsstr; - using ::wmemchr; - - - inline wchar_t* - wcschr(wchar_t* __p, wchar_t __c) - { return wcschr(const_cast(__p), __c); } - - inline wchar_t* - wcspbrk(wchar_t* __s1, const wchar_t* __s2) - { return wcspbrk(const_cast(__s1), __s2); } - - inline wchar_t* - wcsrchr(wchar_t* __p, wchar_t __c) - { return wcsrchr(const_cast(__p), __c); } - - inline wchar_t* - wcsstr(wchar_t* __s1, const wchar_t* __s2) - { return wcsstr(const_cast(__s1), __s2); } - - inline wchar_t* - wmemchr(wchar_t* __p, wchar_t __c, size_t __n) - { return wmemchr(const_cast(__p), __c, __n); } - - - -} -} - - - - - - - -namespace __gnu_cxx -{ - - - - - - using ::wcstold; -# 260 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 - using ::wcstoll; - using ::wcstoull; - -} - -namespace std -{ - using ::__gnu_cxx::wcstold; - using ::__gnu_cxx::wcstoll; - using ::__gnu_cxx::wcstoull; -} -# 280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -namespace std -{ - - using std::wcstof; - - - using std::vfwscanf; - - - using std::vswscanf; - - - using std::vwscanf; - - - - using std::wcstold; - using std::wcstoll; - using std::wcstoull; - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - typedef long int streamoff; - - - - - - typedef ptrdiff_t streamsize; -# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - template - class fpos - { - private: - streamoff _M_off; - _StateT _M_state; - - public: - - - - - fpos() - : _M_off(0), _M_state() { } -# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - fpos(streamoff __off) - : _M_off(__off), _M_state() { } - - - fpos(const fpos&) = default; - fpos& operator=(const fpos&) = default; - ~fpos() = default; - - - - operator streamoff() const { return _M_off; } - - - void - state(_StateT __st) - { _M_state = __st; } - - - _StateT - state() const - { return _M_state; } - - - - - - fpos& - operator+=(streamoff __off) - { - _M_off += __off; - return *this; - } - - - - - - fpos& - operator-=(streamoff __off) - { - _M_off -= __off; - return *this; - } - - - - - - - - fpos - operator+(streamoff __off) const - { - fpos __pos(*this); - __pos += __off; - return __pos; - } - - - - - - - - fpos - operator-(streamoff __off) const - { - fpos __pos(*this); - __pos -= __off; - return __pos; - } - - - - - - - streamoff - operator-(const fpos& __other) const - { return _M_off - __other._M_off; } - }; - - - - - - - template - inline bool - operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) - { return streamoff(__lhs) == streamoff(__rhs); } - - template - inline bool - operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) - { return streamoff(__lhs) != streamoff(__rhs); } - - - - - - typedef fpos streampos; - - typedef fpos wstreampos; -# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - typedef fpos u16streampos; - - typedef fpos u32streampos; - - - -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 76 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 - class ios_base; - - template > - class basic_ios; - - template > - class basic_streambuf; - - template > - class basic_istream; - - template > - class basic_ostream; - - template > - class basic_iostream; - - -namespace __cxx11 { - - template, - typename _Alloc = allocator<_CharT> > - class basic_stringbuf; - - template, - typename _Alloc = allocator<_CharT> > - class basic_istringstream; - - template, - typename _Alloc = allocator<_CharT> > - class basic_ostringstream; - - template, - typename _Alloc = allocator<_CharT> > - class basic_stringstream; - -} - - template > - class basic_filebuf; - - template > - class basic_ifstream; - - template > - class basic_ofstream; - - template > - class basic_fstream; - - template > - class istreambuf_iterator; - - template > - class ostreambuf_iterator; - - - - typedef basic_ios ios; - - - typedef basic_streambuf streambuf; - - - typedef basic_istream istream; - - - typedef basic_ostream ostream; - - - typedef basic_iostream iostream; - - - typedef basic_stringbuf stringbuf; - - - typedef basic_istringstream istringstream; - - - typedef basic_ostringstream ostringstream; - - - typedef basic_stringstream stringstream; - - - typedef basic_filebuf filebuf; - - - typedef basic_ifstream ifstream; - - - typedef basic_ofstream ofstream; - - - typedef basic_fstream fstream; - - - - typedef basic_ios wios; - - - typedef basic_streambuf wstreambuf; - - - typedef basic_istream wistream; - - - typedef basic_ostream wostream; - - - typedef basic_iostream wiostream; - - - typedef basic_stringbuf wstringbuf; - - - typedef basic_istringstream wistringstream; - - - typedef basic_ostringstream wostringstream; - - - typedef basic_stringstream wstringstream; - - - typedef basic_filebuf wfilebuf; - - - typedef basic_ifstream wifstream; - - - typedef basic_ofstream wofstream; - - - typedef basic_fstream wfstream; -# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 -} -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 1 3 -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - - - - - - -#pragma GCC visibility push(default) - - - - - -extern "C++" { - -namespace __cxxabiv1 -{ - class __class_type_info; -} -# 84 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 -namespace std -{ - - - - - - - class type_info - { - public: - - - - - virtual ~type_info(); - - - - const char* name() const noexcept - { return __name[0] == '*' ? __name + 1 : __name; } - - - - bool before(const type_info& __arg) const noexcept; - - - bool operator==(const type_info& __arg) const noexcept; - - - 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&) = delete; - type_info(const type_info&) = delete; -# 167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - }; - - - inline bool - type_info::before(const type_info& __arg) const noexcept - { - - - - - if (__name[0] != '*' || __arg.__name[0] != '*') - return __builtin_strcmp (__name, __arg.__name) < 0; -# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - return __name < __arg.__name; - } - - - - inline bool - type_info::operator==(const type_info& __arg) const noexcept - { - if (std::__is_constant_evaluated()) - return this == &__arg; - - if (__name == __arg.__name) - return true; - - - - - - - return __name[0] != '*' && __builtin_strcmp (__name, __arg.name()) == 0; - - - - } -# 220 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - class bad_cast : public exception - { - public: - bad_cast() noexcept { } - - - - virtual ~bad_cast() noexcept; - - - virtual const char* what() const noexcept; - }; - - - - - - class bad_typeid : public exception - { - public: - bad_typeid () noexcept { } - - - - virtual ~bad_typeid() noexcept; - - - virtual const char* what() const noexcept; - }; -} - -} - -#pragma GCC visibility pop -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 - template - struct _Maybe_unary_or_binary_function { }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct _Maybe_unary_or_binary_function<_Res, _T1> - : std::unary_function<_T1, _Res> { }; - - - template - struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> - : std::binary_function<_T1, _T2, _Res> { }; - -#pragma GCC diagnostic pop - - template - struct _Mem_fn_traits; - - template - struct _Mem_fn_traits_base - { - using __result_type = _Res; - using __maybe_type - = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; - using __arity = integral_constant; - }; -# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; - - -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; - - - - - - - template> - struct _Maybe_get_result_type - { }; - - template - struct _Maybe_get_result_type<_Functor, - __void_t> - { typedef typename _Functor::result_type result_type; }; - - - - - - template - struct _Weak_result_type_impl - : _Maybe_get_result_type<_Functor> - { }; - - - template - struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct - _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)> - { typedef _Res result_type; }; - - - template::value> - struct _Weak_result_type_memfun - : _Weak_result_type_impl<_Functor> - { }; - - - template - struct _Weak_result_type_memfun<_MemFunPtr, true> - { - using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; - }; - - - template - struct _Weak_result_type_memfun<_Func _Class::*, false> - { }; - - - - - - template - struct _Weak_result_type - : _Weak_result_type_memfun::type> - { }; - - - - template> - struct _Refwrap_base_arg1 - { }; - - - template - struct _Refwrap_base_arg1<_Tp, - __void_t> - { - typedef typename _Tp::argument_type argument_type; - }; - - - template> - struct _Refwrap_base_arg2 - { }; - - - template - struct _Refwrap_base_arg2<_Tp, - __void_t> - { - typedef typename _Tp::first_argument_type first_argument_type; - typedef typename _Tp::second_argument_type second_argument_type; - }; - - - - - - - - template - struct _Reference_wrapper_base - : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> - { }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) volatile> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const volatile> - : unary_function<_T1, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> - : binary_function<_T1, _T2, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)> - : unary_function<_T1, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)> - : binary_function<_T1, _T2, _Res> - { }; - - template::value> - struct _Reference_wrapper_base_memfun - : _Reference_wrapper_base<_Tp> - { }; - - template - struct _Reference_wrapper_base_memfun<_MemFunPtr, true> - : _Mem_fn_traits<_MemFunPtr>::__maybe_type - { - using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; - }; -#pragma GCC diagnostic pop - - - - - - - - - template - class reference_wrapper - - - - : public _Reference_wrapper_base_memfun::type> - - { - _Tp* _M_data; - - - static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } - - static void _S_fun(_Tp&&) = delete; - - template> - using __not_same - = typename enable_if::value>::type; - - public: - typedef _Tp type; - - - - - template, typename - = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> - - reference_wrapper(_Up&& __uref) - noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) - : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) - { } - - reference_wrapper(const reference_wrapper&) = default; - - reference_wrapper& - operator=(const reference_wrapper&) = default; - - - operator _Tp&() const noexcept - { return this->get(); } - - - _Tp& - get() const noexcept - { return *_M_data; } - - template - - typename __invoke_result<_Tp&, _Args...>::type - operator()(_Args&&... __args) const - noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value) - { - - - - - return std::__invoke(get(), std::forward<_Args>(__args)...); - } - }; - - - template - reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; - - - - - - template - - inline reference_wrapper<_Tp> - ref(_Tp& __t) noexcept - { return reference_wrapper<_Tp>(__t); } - - - template - - inline reference_wrapper - cref(const _Tp& __t) noexcept - { return reference_wrapper(__t); } - - template - void ref(const _Tp&&) = delete; - - template - void cref(const _Tp&&) = delete; - - - template - - inline reference_wrapper<_Tp> - ref(reference_wrapper<_Tp> __t) noexcept - { return __t; } - - - template - - inline reference_wrapper - cref(reference_wrapper<_Tp> __t) noexcept - { return { __t.get() }; } - - - - -} -# 58 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 1 3 -# 30 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 -#pragma GCC visibility push(default) -# 148 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -# 1 "/usr/include/pthread.h" 1 3 4 -# 22 "/usr/include/pthread.h" 3 4 -# 1 "/usr/include/sched.h" 1 3 4 -# 29 "/usr/include/sched.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 30 "/usr/include/sched.h" 2 3 4 - -# 1 "/usr/include/bits/types/time_t.h" 1 3 4 -# 10 "/usr/include/bits/types/time_t.h" 3 4 -typedef __time_t time_t; -# 32 "/usr/include/sched.h" 2 3 4 -# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 - - - - - -# 1 "/usr/include/bits/endian.h" 1 3 4 -# 35 "/usr/include/bits/endian.h" 3 4 -# 1 "/usr/include/bits/endianness.h" 1 3 4 -# 36 "/usr/include/bits/endian.h" 2 3 4 -# 7 "/usr/include/bits/types/struct_timespec.h" 2 3 4 - - - - -struct timespec -{ - - - - __time_t tv_sec; - - - - - __syscall_slong_t tv_nsec; -# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 -}; -# 33 "/usr/include/sched.h" 2 3 4 - - - - - -typedef __pid_t pid_t; - - - - -# 1 "/usr/include/bits/sched.h" 1 3 4 -# 80 "/usr/include/bits/sched.h" 3 4 -# 1 "/usr/include/bits/types/struct_sched_param.h" 1 3 4 -# 23 "/usr/include/bits/types/struct_sched_param.h" 3 4 -struct sched_param -{ - int sched_priority; -}; -# 81 "/usr/include/bits/sched.h" 2 3 4 - -extern "C" { - - - -extern int clone (int (*__fn) (void *__arg), void *__child_stack, - int __flags, void *__arg, ...) noexcept (true); - - -extern int unshare (int __flags) noexcept (true); - - -extern int sched_getcpu (void) noexcept (true); - - -extern int getcpu (unsigned int *, unsigned int *) noexcept (true); - - -extern int setns (int __fd, int __nstype) noexcept (true); - - -} -# 44 "/usr/include/sched.h" 2 3 4 -# 1 "/usr/include/bits/cpu-set.h" 1 3 4 -# 32 "/usr/include/bits/cpu-set.h" 3 4 -typedef unsigned long int __cpu_mask; - - - - - - -typedef struct -{ - __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; -} cpu_set_t; -# 115 "/usr/include/bits/cpu-set.h" 3 4 -extern "C" { - -extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) - noexcept (true); -extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) ; -extern void __sched_cpufree (cpu_set_t *__set) noexcept (true); - -} -# 45 "/usr/include/sched.h" 2 3 4 - - - - - - -extern "C" { - - -extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) - noexcept (true); - - -extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true); - - -extern int sched_setscheduler (__pid_t __pid, int __policy, - const struct sched_param *__param) noexcept (true); - - -extern int sched_getscheduler (__pid_t __pid) noexcept (true); - - -extern int sched_yield (void) noexcept (true); - - -extern int sched_get_priority_max (int __algorithm) noexcept (true); - - -extern int sched_get_priority_min (int __algorithm) noexcept (true); - - - -extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true); -# 130 "/usr/include/sched.h" 3 4 -extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, - const cpu_set_t *__cpuset) noexcept (true); - - -extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, - cpu_set_t *__cpuset) noexcept (true); - - -} -# 23 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/time.h" 1 3 4 -# 29 "/usr/include/time.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 30 "/usr/include/time.h" 2 3 4 - - - -# 1 "/usr/include/bits/time.h" 1 3 4 -# 73 "/usr/include/bits/time.h" 3 4 -# 1 "/usr/include/bits/timex.h" 1 3 4 -# 22 "/usr/include/bits/timex.h" 3 4 -# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 - - - - - - - -struct timeval -{ - - - - - __time_t tv_sec; - __suseconds_t tv_usec; - -}; -# 23 "/usr/include/bits/timex.h" 2 3 4 - - - -struct timex -{ -# 58 "/usr/include/bits/timex.h" 3 4 - unsigned int modes; - __syscall_slong_t offset; - __syscall_slong_t freq; - __syscall_slong_t maxerror; - __syscall_slong_t esterror; - int status; - __syscall_slong_t constant; - __syscall_slong_t precision; - __syscall_slong_t tolerance; - struct timeval time; - __syscall_slong_t tick; - __syscall_slong_t ppsfreq; - __syscall_slong_t jitter; - int shift; - __syscall_slong_t stabil; - __syscall_slong_t jitcnt; - __syscall_slong_t calcnt; - __syscall_slong_t errcnt; - __syscall_slong_t stbcnt; - - int tai; - - - int :32; int :32; int :32; int :32; - int :32; int :32; int :32; int :32; - int :32; int :32; int :32; - -}; -# 74 "/usr/include/bits/time.h" 2 3 4 - -extern "C" { - - -extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); -# 90 "/usr/include/bits/time.h" 3 4 -} -# 34 "/usr/include/time.h" 2 3 4 - - - -# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 - - - - - - -typedef __clock_t clock_t; -# 38 "/usr/include/time.h" 2 3 4 - -# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 - - - - - - -struct tm -{ - int tm_sec; - int tm_min; - int tm_hour; - int tm_mday; - int tm_mon; - int tm_year; - int tm_wday; - int tm_yday; - int tm_isdst; - - - long int tm_gmtoff; - const char *tm_zone; - - - - -}; -# 40 "/usr/include/time.h" 2 3 4 - - - - - - -# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 - - - - - - -typedef __clockid_t clockid_t; -# 47 "/usr/include/time.h" 2 3 4 -# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 - - - - - - -typedef __timer_t timer_t; -# 48 "/usr/include/time.h" 2 3 4 -# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 - - - - - - - -struct itimerspec - { - struct timespec it_interval; - struct timespec it_value; - }; -# 49 "/usr/include/time.h" 2 3 4 -struct sigevent; -# 68 "/usr/include/time.h" 3 4 -extern "C" { - - - -extern clock_t clock (void) noexcept (true); - - - -extern time_t time (time_t *__timer) noexcept (true); - - -extern double difftime (time_t __time1, time_t __time0) - noexcept (true) __attribute__ ((__const__)); - - -extern time_t mktime (struct tm *__tp) noexcept (true); -# 100 "/usr/include/time.h" 3 4 -extern size_t strftime (char *__restrict __s, size_t __maxsize, - const char *__restrict __format, - const struct tm *__restrict __tp) - noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); - - - - -extern char *strptime (const char *__restrict __s, - const char *__restrict __fmt, struct tm *__tp) - noexcept (true); - - - - - - -extern size_t strftime_l (char *__restrict __s, size_t __maxsize, - const char *__restrict __format, - const struct tm *__restrict __tp, - locale_t __loc) noexcept (true); - - - -extern char *strptime_l (const char *__restrict __s, - const char *__restrict __fmt, struct tm *__tp, - locale_t __loc) noexcept (true); - - - - - - -extern struct tm *gmtime (const time_t *__timer) noexcept (true); - - - -extern struct tm *localtime (const time_t *__timer) noexcept (true); -# 155 "/usr/include/time.h" 3 4 -extern struct tm *gmtime_r (const time_t *__restrict __timer, - struct tm *__restrict __tp) noexcept (true); - - - -extern struct tm *localtime_r (const time_t *__restrict __timer, - struct tm *__restrict __tp) noexcept (true); -# 180 "/usr/include/time.h" 3 4 -extern char *asctime (const struct tm *__tp) noexcept (true); - - - -extern char *ctime (const time_t *__timer) noexcept (true); -# 198 "/usr/include/time.h" 3 4 -extern char *asctime_r (const struct tm *__restrict __tp, - char *__restrict __buf) noexcept (true); - - - -extern char *ctime_r (const time_t *__restrict __timer, - char *__restrict __buf) noexcept (true); -# 218 "/usr/include/time.h" 3 4 -extern char *__tzname[2]; -extern int __daylight; -extern long int __timezone; - - - - -extern char *tzname[2]; - - - -extern void tzset (void) noexcept (true); - - - -extern int daylight; -extern long int timezone; -# 247 "/usr/include/time.h" 3 4 -extern time_t timegm (struct tm *__tp) noexcept (true); -# 264 "/usr/include/time.h" 3 4 -extern time_t timelocal (struct tm *__tp) noexcept (true); - - - - - - - -extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); -# 282 "/usr/include/time.h" 3 4 -extern int nanosleep (const struct timespec *__requested_time, - struct timespec *__remaining); - - -extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); - - -extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - -extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) - noexcept (true) __attribute__ ((__nonnull__ (2))); -# 324 "/usr/include/time.h" 3 4 -extern int clock_nanosleep (clockid_t __clock_id, int __flags, - const struct timespec *__req, - struct timespec *__rem); -# 339 "/usr/include/time.h" 3 4 -extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); - - - - -extern int timer_create (clockid_t __clock_id, - struct sigevent *__restrict __evp, - timer_t *__restrict __timerid) noexcept (true); - - -extern int timer_delete (timer_t __timerid) noexcept (true); - - - -extern int timer_settime (timer_t __timerid, int __flags, - const struct itimerspec *__restrict __value, - struct itimerspec *__restrict __ovalue) noexcept (true); - - -extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) - noexcept (true); -# 377 "/usr/include/time.h" 3 4 -extern int timer_getoverrun (timer_t __timerid) noexcept (true); - - - - - - -extern int timespec_get (struct timespec *__ts, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 400 "/usr/include/time.h" 3 4 -extern int timespec_getres (struct timespec *__ts, int __base) - noexcept (true); -# 426 "/usr/include/time.h" 3 4 -extern int getdate_err; -# 435 "/usr/include/time.h" 3 4 -extern struct tm *getdate (const char *__string); -# 449 "/usr/include/time.h" 3 4 -extern int getdate_r (const char *__restrict __string, - struct tm *__restrict __resbufp); - - -} -# 24 "/usr/include/pthread.h" 2 3 4 - - -# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 -# 23 "/usr/include/bits/pthreadtypes.h" 3 4 -# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 -# 44 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 -# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 -# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 - -# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 -# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 -typedef union -{ - __extension__ unsigned long long int __value64; - struct - { - unsigned int __low; - unsigned int __high; - } __value32; -} __atomic_wide_counter; -# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -typedef struct __pthread_internal_list -{ - struct __pthread_internal_list *__prev; - struct __pthread_internal_list *__next; -} __pthread_list_t; - -typedef struct __pthread_internal_slist -{ - struct __pthread_internal_slist *__next; -} __pthread_slist_t; -# 76 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 -# 22 "/usr/include/bits/struct_mutex.h" 3 4 -struct __pthread_mutex_s -{ - int __lock; - unsigned int __count; - int __owner; - - unsigned int __nusers; - - - - int __kind; - - short __spins; - short __elision; - __pthread_list_t __list; -# 53 "/usr/include/bits/struct_mutex.h" 3 4 -}; -# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 -# 89 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 -# 23 "/usr/include/bits/struct_rwlock.h" 3 4 -struct __pthread_rwlock_arch_t -{ - unsigned int __readers; - unsigned int __writers; - unsigned int __wrphase_futex; - unsigned int __writers_futex; - unsigned int __pad3; - unsigned int __pad4; - - int __cur_writer; - int __shared; - signed char __rwelision; - - - - - unsigned char __pad1[7]; - - - unsigned long int __pad2; - - - unsigned int __flags; -# 55 "/usr/include/bits/struct_rwlock.h" 3 4 -}; -# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -struct __pthread_cond_s -{ - __atomic_wide_counter __wseq; - __atomic_wide_counter __g1_start; - unsigned int __g_refs[2] ; - unsigned int __g_size[2]; - unsigned int __g1_orig_size; - unsigned int __wrefs; - unsigned int __g_signals[2]; -}; - -typedef unsigned int __tss_t; -typedef unsigned long int __thrd_t; - -typedef struct -{ - int __data ; -} __once_flag; -# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 - - - -typedef unsigned long int pthread_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_mutexattr_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_condattr_t; - - - -typedef unsigned int pthread_key_t; - - - -typedef int pthread_once_t; - - -union pthread_attr_t -{ - char __size[56]; - long int __align; -}; - -typedef union pthread_attr_t pthread_attr_t; - - - - -typedef union -{ - struct __pthread_mutex_s __data; - char __size[40]; - long int __align; -} pthread_mutex_t; - - -typedef union -{ - struct __pthread_cond_s __data; - char __size[48]; - __extension__ long long int __align; -} pthread_cond_t; - - - - - -typedef union -{ - struct __pthread_rwlock_arch_t __data; - char __size[56]; - long int __align; -} pthread_rwlock_t; - -typedef union -{ - char __size[8]; - long int __align; -} pthread_rwlockattr_t; - - - - - -typedef volatile int pthread_spinlock_t; - - - - -typedef union -{ - char __size[32]; - long int __align; -} pthread_barrier_t; - -typedef union -{ - char __size[4]; - int __align; -} pthread_barrierattr_t; -# 27 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/bits/setjmp.h" 1 3 4 -# 26 "/usr/include/bits/setjmp.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 27 "/usr/include/bits/setjmp.h" 2 3 4 - - - - -typedef long int __jmp_buf[8]; -# 28 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 29 "/usr/include/pthread.h" 2 3 4 - -# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 - - - - -typedef struct -{ - unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; -} __sigset_t; -# 31 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/bits/types/struct___jmp_buf_tag.h" 1 3 4 -# 26 "/usr/include/bits/types/struct___jmp_buf_tag.h" 3 4 -struct __jmp_buf_tag - { - - - - - __jmp_buf __jmpbuf; - int __mask_was_saved; - __sigset_t __saved_mask; - }; -# 32 "/usr/include/pthread.h" 2 3 4 - -# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 -# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 -extern "C" { -extern long int __sysconf (int __name) noexcept (true); -} -# 34 "/usr/include/pthread.h" 2 3 4 - - - -enum -{ - PTHREAD_CREATE_JOINABLE, - - PTHREAD_CREATE_DETACHED - -}; - - - -enum -{ - PTHREAD_MUTEX_TIMED_NP, - PTHREAD_MUTEX_RECURSIVE_NP, - PTHREAD_MUTEX_ERRORCHECK_NP, - PTHREAD_MUTEX_ADAPTIVE_NP - - , - PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, - PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, - PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, - PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL - - - - , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP - -}; - - - - -enum -{ - PTHREAD_MUTEX_STALLED, - PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, - PTHREAD_MUTEX_ROBUST, - PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST -}; - - - - - -enum -{ - PTHREAD_PRIO_NONE, - PTHREAD_PRIO_INHERIT, - PTHREAD_PRIO_PROTECT -}; -# 104 "/usr/include/pthread.h" 3 4 -enum -{ - PTHREAD_RWLOCK_PREFER_READER_NP, - PTHREAD_RWLOCK_PREFER_WRITER_NP, - PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, - PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP -}; -# 124 "/usr/include/pthread.h" 3 4 -enum -{ - PTHREAD_INHERIT_SCHED, - - PTHREAD_EXPLICIT_SCHED - -}; - - - -enum -{ - PTHREAD_SCOPE_SYSTEM, - - PTHREAD_SCOPE_PROCESS - -}; - - - -enum -{ - PTHREAD_PROCESS_PRIVATE, - - PTHREAD_PROCESS_SHARED - -}; -# 159 "/usr/include/pthread.h" 3 4 -struct _pthread_cleanup_buffer -{ - void (*__routine) (void *); - void *__arg; - int __canceltype; - struct _pthread_cleanup_buffer *__prev; -}; - - -enum -{ - PTHREAD_CANCEL_ENABLE, - - PTHREAD_CANCEL_DISABLE - -}; -enum -{ - PTHREAD_CANCEL_DEFERRED, - - PTHREAD_CANCEL_ASYNCHRONOUS - -}; -# 197 "/usr/include/pthread.h" 3 4 -extern "C" { - - - - -extern int pthread_create (pthread_t *__restrict __newthread, - const pthread_attr_t *__restrict __attr, - void *(*__start_routine) (void *), - void *__restrict __arg) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - - - -extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); - - - - - - - -extern int pthread_join (pthread_t __th, void **__thread_return); - - - - -extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) noexcept (true); -# 233 "/usr/include/pthread.h" 3 4 -extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, - const struct timespec *__abstime); -# 243 "/usr/include/pthread.h" 3 4 -extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return, - clockid_t __clockid, - const struct timespec *__abstime); -# 269 "/usr/include/pthread.h" 3 4 -extern int pthread_detach (pthread_t __th) noexcept (true); - - - -extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__)); - - -extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) - noexcept (true) __attribute__ ((__const__)); - - - - - - - -extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_destroy (pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, - int *__detachstate) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, - int __detachstate) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, - size_t *__guardsize) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setguardsize (pthread_attr_t *__attr, - size_t __guardsize) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, - struct sched_param *__restrict __param) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, - const struct sched_param *__restrict - __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict - __attr, int *__restrict __policy) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict - __attr, int *__restrict __inherit) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, - int __inherit) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, - int *__restrict __scope) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict - __attr, void **__restrict __stackaddr) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); - - - - - -extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, - void *__stackaddr) - noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); - - -extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict - __attr, size_t *__restrict __stacksize) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern int pthread_attr_setstacksize (pthread_attr_t *__attr, - size_t __stacksize) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, - void **__restrict __stackaddr, - size_t *__restrict __stacksize) - noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))); - - - - -extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, - size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, - size_t __cpusetsize, - const cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, - size_t __cpusetsize, - cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - -extern int pthread_getattr_default_np (pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr, - const __sigset_t *sigmask); - - - - -extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr, - __sigset_t *sigmask); - - - - - - - -extern int pthread_setattr_default_np (const pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - - - - -extern int pthread_setschedparam (pthread_t __target_thread, int __policy, - const struct sched_param *__param) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - -extern int pthread_getschedparam (pthread_t __target_thread, - int *__restrict __policy, - struct sched_param *__restrict __param) - noexcept (true) __attribute__ ((__nonnull__ (2, 3))); - - -extern int pthread_setschedprio (pthread_t __target_thread, int __prio) - noexcept (true); - - - - -extern int pthread_getname_np (pthread_t __target_thread, char *__buf, - size_t __buflen) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - -extern int pthread_setname_np (pthread_t __target_thread, const char *__name) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - - -extern int pthread_getconcurrency (void) noexcept (true); - - -extern int pthread_setconcurrency (int __level) noexcept (true); - - - -extern int pthread_yield (void) noexcept (true); - -extern int pthread_yield (void) noexcept (true) __asm__ ("" "sched_yield") - __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead"))); -# 489 "/usr/include/pthread.h" 3 4 -extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, - const cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - -extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, - cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 509 "/usr/include/pthread.h" 3 4 -extern int pthread_once (pthread_once_t *__once_control, - void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); -# 521 "/usr/include/pthread.h" 3 4 -extern int pthread_setcancelstate (int __state, int *__oldstate); - - - -extern int pthread_setcanceltype (int __type, int *__oldtype); - - -extern int pthread_cancel (pthread_t __th); - - - - -extern void pthread_testcancel (void); - - - - -struct __cancel_jmp_buf_tag -{ - __jmp_buf __cancel_jmp_buf; - int __mask_was_saved; -}; - -typedef struct -{ - struct __cancel_jmp_buf_tag __cancel_jmp_buf[1]; - void *__pad[4]; -} __pthread_unwind_buf_t __attribute__ ((__aligned__)); -# 557 "/usr/include/pthread.h" 3 4 -struct __pthread_cleanup_frame -{ - void (*__cancel_routine) (void *); - void *__cancel_arg; - int __do_it; - int __cancel_type; -}; - - - - -class __pthread_cleanup_class -{ - void (*__cancel_routine) (void *); - void *__cancel_arg; - int __do_it; - int __cancel_type; - - public: - __pthread_cleanup_class (void (*__fct) (void *), void *__arg) - : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } - ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } - void __setdoit (int __newval) { __do_it = __newval; } - void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, - &__cancel_type); } - void __restore () const { pthread_setcanceltype (__cancel_type, 0); } -}; -# 773 "/usr/include/pthread.h" 3 4 -extern int __sigsetjmp (struct __jmp_buf_tag __env[1], - int __savemask) noexcept (true); - - - - - - -extern int pthread_mutex_init (pthread_mutex_t *__mutex, - const pthread_mutexattr_t *__mutexattr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_lock (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -# 817 "/usr/include/pthread.h" 3 4 -extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex, - clockid_t __clockid, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 835 "/usr/include/pthread.h" 3 4 -extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutex_getprioceiling (const pthread_mutex_t * - __restrict __mutex, - int *__restrict __prioceiling) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, - int __prioceiling, - int *__restrict __old_ceiling) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - - -extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_consistent_np (pthread_mutex_t *) noexcept (true) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nonnull__ (1))) - - __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent"))); -# 874 "/usr/include/pthread.h" 3 4 -extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, - int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict - __attr, int *__restrict __kind) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __protocol) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, - int __protocol) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __prioceiling) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, - int __prioceiling) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, - int *__robustness) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) noexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nonnull__ (1))) - - - __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust"))); - - - - - - - -extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, - int __robustness) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) noexcept (true) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nonnull__ (1))) - - - __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust"))); -# 967 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, - const pthread_rwlockattr_t *__restrict - __attr) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -# 1004 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock, - clockid_t __clockid, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 1023 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -# 1051 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock, - clockid_t __clockid, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 1071 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, - int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * - __restrict __attr, - int *__restrict __pref) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, - int __pref) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - - -extern int pthread_cond_init (pthread_cond_t *__restrict __cond, - const pthread_condattr_t *__restrict __cond_attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_cond_destroy (pthread_cond_t *__cond) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_cond_signal (pthread_cond_t *__cond) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_cond_broadcast (pthread_cond_t *__cond) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex) - __attribute__ ((__nonnull__ (1, 2))); -# 1145 "/usr/include/pthread.h" 3 4 -extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex, - const struct timespec *__restrict __abstime) - __attribute__ ((__nonnull__ (1, 2, 3))); -# 1171 "/usr/include/pthread.h" 3 4 -extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex, - __clockid_t __clock_id, - const struct timespec *__restrict __abstime) - __attribute__ ((__nonnull__ (1, 2, 4))); -# 1194 "/usr/include/pthread.h" 3 4 -extern int pthread_condattr_init (pthread_condattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_condattr_destroy (pthread_condattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_condattr_getpshared (const pthread_condattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, - int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_condattr_getclock (const pthread_condattr_t * - __restrict __attr, - __clockid_t *__restrict __clock_id) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_condattr_setclock (pthread_condattr_t *__attr, - __clockid_t __clock_id) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 1230 "/usr/include/pthread.h" 3 4 -extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_destroy (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_lock (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_trylock (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_unlock (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, - const pthread_barrierattr_t *__restrict - __attr, unsigned int __count) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrier_wait (pthread_barrier_t *__barrier) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, - int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 1297 "/usr/include/pthread.h" 3 4 -extern int pthread_key_create (pthread_key_t *__key, - void (*__destr_function) (void *)) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_key_delete (pthread_key_t __key) noexcept (true); - - -extern void *pthread_getspecific (pthread_key_t __key) noexcept (true); - - -extern int pthread_setspecific (pthread_key_t __key, - const void *__pointer) - noexcept (true) ; - - - - -extern int pthread_getcpuclockid (pthread_t __thread_id, - __clockid_t *__clock_id) - noexcept (true) __attribute__ ((__nonnull__ (2))); -# 1332 "/usr/include/pthread.h" 3 4 -extern int pthread_atfork (void (*__prepare) (void), - void (*__parent) (void), - void (*__child) (void)) noexcept (true); - - - - -extern __inline __attribute__ ((__gnu_inline__)) int - pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true) -{ - return __thread1 == __thread2; -} - - -} -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -typedef pthread_t __gthread_t; -typedef pthread_key_t __gthread_key_t; -typedef pthread_once_t __gthread_once_t; -typedef pthread_mutex_t __gthread_mutex_t; -typedef pthread_mutex_t __gthread_recursive_mutex_t; -typedef pthread_cond_t __gthread_cond_t; -typedef struct timespec __gthread_time_t; -# 299 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_active_p (void) -{ - return 1; -} -# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), - void *__args) -{ - return pthread_create (__threadid, __null, __func, __args); -} - -static inline int -__gthread_join (__gthread_t __threadid, void **__value_ptr) -{ - return pthread_join (__threadid, __value_ptr); -} - -static inline int -__gthread_detach (__gthread_t __threadid) -{ - return pthread_detach (__threadid); -} - -static inline int -__gthread_equal (__gthread_t __t1, __gthread_t __t2) -{ - return pthread_equal (__t1, __t2); -} - -static inline __gthread_t -__gthread_self (void) -{ - return pthread_self (); -} - -static inline int -__gthread_yield (void) -{ - return sched_yield (); -} - -static inline int -__gthread_once (__gthread_once_t *__once, void (*__func) (void)) -{ - if (__gthread_active_p ()) - return pthread_once (__once, __func); - else - return -1; -} - -static inline int -__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) -{ - return pthread_key_create (__key, __dtor); -} - -static inline int -__gthread_key_delete (__gthread_key_t __key) -{ - return pthread_key_delete (__key); -} - -static inline void * -__gthread_getspecific (__gthread_key_t __key) -{ - return pthread_getspecific (__key); -} - -static inline int -__gthread_setspecific (__gthread_key_t __key, const void *__ptr) -{ - return pthread_setspecific (__key, __ptr); -} - -static inline void -__gthread_mutex_init_function (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - pthread_mutex_init (__mutex, __null); -} - -static inline int -__gthread_mutex_destroy (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_destroy (__mutex); - else - return 0; -} - -static inline int -__gthread_mutex_lock (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_lock (__mutex); - else - return 0; -} - -static inline int -__gthread_mutex_trylock (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_trylock (__mutex); - else - return 0; -} - - -static inline int -__gthread_mutex_timedlock (__gthread_mutex_t *__mutex, - const __gthread_time_t *__abs_timeout) -{ - if (__gthread_active_p ()) - return pthread_mutex_timedlock (__mutex, __abs_timeout); - else - return 0; -} - - -static inline int -__gthread_mutex_unlock (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_unlock (__mutex); - else - return 0; -} -# 808 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_lock (__mutex); -} - -static inline int -__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_trylock (__mutex); -} - - -static inline int -__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, - const __gthread_time_t *__abs_timeout) -{ - return __gthread_mutex_timedlock (__mutex, __abs_timeout); -} - - -static inline int -__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_unlock (__mutex); -} - -static inline int -__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_destroy (__mutex); -} -# 850 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_cond_broadcast (__gthread_cond_t *__cond) -{ - return pthread_cond_broadcast (__cond); -} - -static inline int -__gthread_cond_signal (__gthread_cond_t *__cond) -{ - return pthread_cond_signal (__cond); -} - -static inline int -__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) -{ - return pthread_cond_wait (__cond, __mutex); -} - -static inline int -__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, - const __gthread_time_t *__abs_timeout) -{ - return pthread_cond_timedwait (__cond, __mutex, __abs_timeout); -} - -static inline int -__gthread_cond_wait_recursive (__gthread_cond_t *__cond, - __gthread_recursive_mutex_t *__mutex) -{ - return __gthread_cond_wait (__cond, __mutex); -} - -static inline int -__gthread_cond_destroy (__gthread_cond_t* __cond) -{ - return pthread_cond_destroy (__cond); -} -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 2 3 - - -#pragma GCC visibility pop -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3 -# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 3 -typedef int _Atomic_word; -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 - -# 1 "/usr/include/sys/single_threaded.h" 1 3 4 -# 24 "/usr/include/sys/single_threaded.h" 3 4 -extern "C" { - - - - -extern char __libc_single_threaded; - -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - __attribute__((__always_inline__)) - inline bool - __is_single_threaded() noexcept - { - - - - return ::__libc_single_threaded; - - - - } - - - - - - - inline _Atomic_word - __attribute__((__always_inline__)) - __exchange_and_add(volatile _Atomic_word* __mem, int __val) - { return __atomic_fetch_add(__mem, __val, 4); } - - inline void - __attribute__((__always_inline__)) - __atomic_add(volatile _Atomic_word* __mem, int __val) - { __atomic_fetch_add(__mem, __val, 4); } -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 - inline _Atomic_word - __attribute__((__always_inline__)) - __exchange_and_add_single(_Atomic_word* __mem, int __val) - { - _Atomic_word __result = *__mem; - *__mem += __val; - return __result; - } - - inline void - __attribute__((__always_inline__)) - __atomic_add_single(_Atomic_word* __mem, int __val) - { *__mem += __val; } - - inline _Atomic_word - __attribute__ ((__always_inline__)) - __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) - { - if (__is_single_threaded()) - return __exchange_and_add_single(__mem, __val); - else - return __exchange_and_add(__mem, __val); - } - - inline void - __attribute__ ((__always_inline__)) - __atomic_add_dispatch(_Atomic_word* __mem, int __val) - { - if (__is_single_threaded()) - __atomic_add_single(__mem, __val); - else - __atomic_add(__mem, __val); - } - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - - - - -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - class bad_exception : public exception - { - public: - bad_exception() noexcept { } - - - - virtual ~bad_exception() noexcept; - - - virtual const char* - what() const noexcept; - }; - - - typedef void (*terminate_handler) (); - - - terminate_handler set_terminate(terminate_handler) noexcept; - - - - terminate_handler get_terminate() noexcept; - - - - - void terminate() noexcept __attribute__ ((__noreturn__)); - - - - typedef void (*__attribute__ ((__deprecated__)) unexpected_handler) (); - - - - - - __attribute__ ((__deprecated__)) - unexpected_handler set_unexpected(unexpected_handler) noexcept; - - - - - - - - __attribute__ ((__deprecated__)) - unexpected_handler get_unexpected() noexcept; - - - - - - - - __attribute__ ((__deprecated__)) - void unexpected() __attribute__ ((__noreturn__)); -# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - __attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "' instead"))) - bool uncaught_exception() noexcept __attribute__ ((__pure__)); - - - - - - - - int uncaught_exceptions() noexcept __attribute__ ((__pure__)); - - - -} - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - void __verbose_terminate_handler(); - - -} - -} - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 - -#pragma GCC visibility push(default) - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 2 3 -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 -namespace std -{ - class type_info; -} - -namespace __cxxabiv1 -{ - struct __cxa_refcounted_exception; - - extern "C" - { - - void* - __cxa_allocate_exception(size_t) noexcept; - - void - __cxa_free_exception(void*) noexcept; - - - __cxa_refcounted_exception* - __cxa_init_primary_exception(void *__object, std::type_info *__tinfo, - void ( *__dest) (void *)) - noexcept; - - } -} - - - -#pragma GCC visibility pop -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - class type_info; - - - - - - - namespace __exception_ptr - { - class exception_ptr; - } - - using __exception_ptr::exception_ptr; -# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - exception_ptr current_exception() noexcept; - - template - exception_ptr make_exception_ptr(_Ex) noexcept; - - - void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); - - namespace __exception_ptr - { - using std::rethrow_exception; -# 97 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - class exception_ptr - { - void* _M_exception_object; - - explicit exception_ptr(void* __e) noexcept; - - void _M_addref() noexcept; - void _M_release() noexcept; - - void *_M_get() const noexcept __attribute__ ((__pure__)); - - friend exception_ptr std::current_exception() noexcept; - friend void std::rethrow_exception(exception_ptr); - template - friend exception_ptr std::make_exception_ptr(_Ex) noexcept; - - public: - exception_ptr() noexcept; - - exception_ptr(const exception_ptr&) noexcept; - - - exception_ptr(nullptr_t) noexcept - : _M_exception_object(nullptr) - { } - - exception_ptr(exception_ptr&& __o) noexcept - : _M_exception_object(__o._M_exception_object) - { __o._M_exception_object = nullptr; } -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -# 162 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - explicit operator bool() const noexcept - { return _M_exception_object; } - - - - - - - - friend bool - operator==(const exception_ptr& __x, const exception_ptr& __y) - noexcept - { return __x._M_exception_object == __y._M_exception_object; } - - friend bool - operator!=(const exception_ptr& __x, const exception_ptr& __y) - noexcept - { return __x._M_exception_object != __y._M_exception_object; } - - - const class std::type_info* - __cxa_exception_type() const noexcept - __attribute__ ((__pure__)); - }; - - - inline - exception_ptr::exception_ptr() noexcept - : _M_exception_object(0) - { } - - - inline - exception_ptr::exception_ptr(const exception_ptr& __other) - noexcept - : _M_exception_object(__other._M_exception_object) - { - if (_M_exception_object) - _M_addref(); - } - - - inline - exception_ptr::~exception_ptr() noexcept - { - if (_M_exception_object) - _M_release(); - } - - - inline exception_ptr& - exception_ptr::operator=(const exception_ptr& __other) noexcept - { - exception_ptr(__other).swap(*this); - return *this; - } - - - inline void - exception_ptr::swap(exception_ptr &__other) noexcept - { - void *__tmp = _M_exception_object; - _M_exception_object = __other._M_exception_object; - __other._M_exception_object = __tmp; - } - - - inline void - swap(exception_ptr& __lhs, exception_ptr& __rhs) - { __lhs.swap(__rhs); } - - - template - - inline void - __dest_thunk(void* __x) - { static_cast<_Ex*>(__x)->~_Ex(); } - - - } - - using __exception_ptr::swap; - - - - template - exception_ptr - make_exception_ptr(_Ex __ex) noexcept - { - - using _Ex2 = typename decay<_Ex>::type; - void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); - (void) __cxxabiv1::__cxa_init_primary_exception( - __e, const_cast(&typeid(_Ex)), - __exception_ptr::__dest_thunk<_Ex2>); - try - { - ::new (__e) _Ex2(__ex); - return exception_ptr(__e); - } - catch(...) - { - __cxxabiv1::__cxa_free_exception(__e); - return current_exception(); - } -# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - } -# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 -} - -} -# 165 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - class nested_exception - { - exception_ptr _M_ptr; - - public: - - nested_exception() noexcept : _M_ptr(current_exception()) { } - - nested_exception(const nested_exception&) noexcept = 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)) - { } - }; -# 145 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - 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"); - - - if constexpr (is_class_v<_Up>) - if constexpr (!is_final_v<_Up>) - if constexpr (!is_base_of_v) - throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; - throw std::forward<_Tp>(__t); - - - - - - } -# 203 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - template - - - - inline void - rethrow_if_nested(const _Ex& __ex) - { - const _Ex* __ptr = __builtin_addressof(__ex); -# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - if constexpr (!is_polymorphic_v<_Ex>) - return; - else if constexpr (is_base_of_v - && !is_convertible_v<_Ex*, nested_exception*>) - return; - - - - - else if (auto __ne_ptr = dynamic_cast(__ptr)) - __ne_ptr->rethrow_nested(); - - } - - -} - -} -# 166 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 2 3 - - - - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; - - - - inline const _Lock_policy __default_lock_policy = - - - - _S_atomic; - - - - - - - class __concurrence_lock_error : public std::exception - { - public: - virtual char const* - what() const throw() - { return "__gnu_cxx::__concurrence_lock_error"; } - }; - - class __concurrence_unlock_error : public std::exception - { - public: - virtual char const* - what() const throw() - { return "__gnu_cxx::__concurrence_unlock_error"; } - }; - - class __concurrence_broadcast_error : public std::exception - { - public: - virtual char const* - what() const throw() - { return "__gnu_cxx::__concurrence_broadcast_error"; } - }; - - class __concurrence_wait_error : public std::exception - { - public: - virtual char const* - what() const throw() - { return "__gnu_cxx::__concurrence_wait_error"; } - }; - - - inline void - __throw_concurrence_lock_error() - { (throw (__concurrence_lock_error())); } - - inline void - __throw_concurrence_unlock_error() - { (throw (__concurrence_unlock_error())); } - - - inline void - __throw_concurrence_broadcast_error() - { (throw (__concurrence_broadcast_error())); } - - inline void - __throw_concurrence_wait_error() - { (throw (__concurrence_wait_error())); } - - - class __mutex - { - private: - - __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } }; - - - - - __mutex(const __mutex&); - __mutex& operator=(const __mutex&); - - public: - __mutex() - { - - - - - } -# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 - void lock() - { - - if (__gthread_active_p()) - { - if (__gthread_mutex_lock(&_M_mutex) != 0) - __throw_concurrence_lock_error(); - } - - } - - void unlock() - { - - if (__gthread_active_p()) - { - if (__gthread_mutex_unlock(&_M_mutex) != 0) - __throw_concurrence_unlock_error(); - } - - } - - __gthread_mutex_t* gthread_mutex(void) - { return &_M_mutex; } - }; - - class __recursive_mutex - { - private: - - __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } }; - - - - - __recursive_mutex(const __recursive_mutex&); - __recursive_mutex& operator=(const __recursive_mutex&); - - public: - __recursive_mutex() - { - - - - - } -# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 - void lock() - { - - if (__gthread_active_p()) - { - if (__gthread_recursive_mutex_lock(&_M_mutex) != 0) - __throw_concurrence_lock_error(); - } - - } - - void unlock() - { - - if (__gthread_active_p()) - { - if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0) - __throw_concurrence_unlock_error(); - } - - } - - __gthread_recursive_mutex_t* gthread_recursive_mutex(void) - { return &_M_mutex; } - }; - - - - - class __scoped_lock - { - public: - typedef __mutex __mutex_type; - - private: - __mutex_type& _M_device; - - __scoped_lock(const __scoped_lock&); - __scoped_lock& operator=(const __scoped_lock&); - - public: - explicit __scoped_lock(__mutex_type& __name) : _M_device(__name) - { _M_device.lock(); } - - ~__scoped_lock() throw() - { _M_device.unlock(); } - }; - - - class __cond - { - private: - - __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } }; - - - - - __cond(const __cond&); - __cond& operator=(const __cond&); - - public: - __cond() - { - - - - - } -# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 - void broadcast() - { - - if (__gthread_active_p()) - { - if (__gthread_cond_broadcast(&_M_cond) != 0) - __throw_concurrence_broadcast_error(); - } - - } - - void wait(__mutex *mutex) - { - - { - if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0) - __throw_concurrence_wait_error(); - } - - } - - void wait_recursive(__recursive_mutex *mutex) - { - - { - if (__gthread_cond_wait_recursive(&_M_cond, - mutex->gthread_recursive_mutex()) - != 0) - __throw_concurrence_wait_error(); - } - - } - }; - - - -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template class auto_ptr; -#pragma GCC diagnostic pop - - - - - - - class bad_weak_ptr : public std::exception - { - public: - virtual char const* what() const noexcept; - - virtual ~bad_weak_ptr() noexcept; - }; - - - inline void - __throw_bad_weak_ptr() - { (throw (bad_weak_ptr())); } - - using __gnu_cxx::_Lock_policy; - using __gnu_cxx::__default_lock_policy; - using __gnu_cxx::_S_single; - using __gnu_cxx::_S_mutex; - using __gnu_cxx::_S_atomic; - - - template<_Lock_policy _Lp> - class _Mutex_base - { - protected: - - enum { _S_need_barriers = 0 }; - }; - - template<> - class _Mutex_base<_S_mutex> - : public __gnu_cxx::__mutex - { - protected: - - - - enum { _S_need_barriers = 1 }; - }; - - template<_Lock_policy _Lp = __default_lock_policy> - class _Sp_counted_base - : public _Mutex_base<_Lp> - { - public: - _Sp_counted_base() noexcept - : _M_use_count(1), _M_weak_count(1) { } - - virtual - ~_Sp_counted_base() noexcept - { } - - - - virtual void - _M_dispose() noexcept = 0; - - - virtual void - _M_destroy() noexcept - { delete this; } - - virtual void* - _M_get_deleter(const std::type_info&) noexcept = 0; - - - void - _M_add_ref_copy() - { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } - - - void - _M_add_ref_lock() - { - if (!_M_add_ref_lock_nothrow()) - __throw_bad_weak_ptr(); - } - - - bool - _M_add_ref_lock_nothrow() noexcept; - - - void - _M_release() noexcept; - - - void - _M_release_last_use() noexcept - { - ; - _M_dispose(); - - - - - if (_Mutex_base<_Lp>::_S_need_barriers) - { - __atomic_thread_fence (4); - } - - - ; - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, - -1) == 1) - { - ; - _M_destroy(); - } - } - - - __attribute__((__noinline__)) - void - _M_release_last_use_cold() noexcept - { _M_release_last_use(); } - - - void - _M_weak_add_ref() noexcept - { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } - - - void - _M_weak_release() noexcept - { - - ; - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) - { - ; - if (_Mutex_base<_Lp>::_S_need_barriers) - { - - - __atomic_thread_fence (4); - } - _M_destroy(); - } - } - - long - _M_get_use_count() const noexcept - { - - - return __atomic_load_n(&_M_use_count, 0); - } - - private: - _Sp_counted_base(_Sp_counted_base const&) = delete; - _Sp_counted_base& operator=(_Sp_counted_base const&) = delete; - - _Atomic_word _M_use_count; - _Atomic_word _M_weak_count; - }; - - template<> - inline bool - _Sp_counted_base<_S_single>:: - _M_add_ref_lock_nothrow() noexcept - { - if (_M_use_count == 0) - return false; - ++_M_use_count; - return true; - } - - template<> - inline bool - _Sp_counted_base<_S_mutex>:: - _M_add_ref_lock_nothrow() noexcept - { - __gnu_cxx::__scoped_lock sentry(*this); - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) - { - _M_use_count = 0; - return false; - } - return true; - } - - template<> - inline bool - _Sp_counted_base<_S_atomic>:: - _M_add_ref_lock_nothrow() noexcept - { - - _Atomic_word __count = _M_get_use_count(); - do - { - if (__count == 0) - return false; - - - } - while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, - true, 4, - 0)); - return true; - } - - template<> - inline void - _Sp_counted_base<_S_single>::_M_add_ref_copy() - { ++_M_use_count; } - - template<> - inline void - _Sp_counted_base<_S_single>::_M_release() noexcept - { - if (--_M_use_count == 0) - { - _M_dispose(); - if (--_M_weak_count == 0) - _M_destroy(); - } - } - - template<> - inline void - _Sp_counted_base<_S_mutex>::_M_release() noexcept - { - - ; - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) - { - _M_release_last_use(); - } - } - - template<> - inline void - _Sp_counted_base<_S_atomic>::_M_release() noexcept - { - ; - - constexpr bool __lock_free - = __atomic_always_lock_free(sizeof(long long), 0) - && __atomic_always_lock_free(sizeof(_Atomic_word), 0); - constexpr bool __double_word - = sizeof(long long) == 2 * sizeof(_Atomic_word); - - - constexpr bool __aligned = __alignof(long long) <= alignof(void*); - if constexpr (__lock_free && __double_word && __aligned) - { - constexpr int __wordbits = 8 * sizeof(_Atomic_word); - constexpr int __shiftbits = __double_word ? __wordbits : 0; - constexpr long long __unique_ref = 1LL + (1LL << __shiftbits); - auto __both_counts = reinterpret_cast(&_M_use_count); - - ; - if (__atomic_load_n(__both_counts, 2) == __unique_ref) - { - - - - - _M_weak_count = _M_use_count = 0; - ; - ; - _M_dispose(); - _M_destroy(); - return; - } - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) - [[__unlikely__]] - { - _M_release_last_use_cold(); - return; - } - } - else - - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) - { - _M_release_last_use(); - } - } - - template<> - inline void - _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept - { ++_M_weak_count; } - - template<> - inline void - _Sp_counted_base<_S_single>::_M_weak_release() noexcept - { - if (--_M_weak_count == 0) - _M_destroy(); - } - - template<> - inline long - _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept - { return _M_use_count; } - - - - template - class __shared_ptr; - - template - class __weak_ptr; - - template - class __enable_shared_from_this; - - template - class shared_ptr; - - template - class weak_ptr; - - template - struct owner_less; - - template - class enable_shared_from_this; - - template<_Lock_policy _Lp = __default_lock_policy> - class __weak_count; - - template<_Lock_policy _Lp = __default_lock_policy> - class __shared_count; - - - - - - - - template - class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> - { - public: - explicit - _Sp_counted_ptr(_Ptr __p) noexcept - : _M_ptr(__p) { } - - virtual void - _M_dispose() noexcept - { delete _M_ptr; } - - virtual void - _M_destroy() noexcept - { delete this; } - - virtual void* - _M_get_deleter(const std::type_info&) noexcept - { return nullptr; } - - _Sp_counted_ptr(const _Sp_counted_ptr&) = delete; - _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; - - private: - _Ptr _M_ptr; - }; - - template<> - inline void - _Sp_counted_ptr::_M_dispose() noexcept { } - - template<> - inline void - _Sp_counted_ptr::_M_dispose() noexcept { } - - template<> - inline void - _Sp_counted_ptr::_M_dispose() noexcept { } - - - - - - - template - struct _Sp_ebo_helper; - - - template - struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp - { - explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { } - explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { } - - static _Tp& - _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); } - }; - - - template - struct _Sp_ebo_helper<_Nm, _Tp, false> - { - explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { } - explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { } - - static _Tp& - _S_get(_Sp_ebo_helper& __eboh) - { return __eboh._M_tp; } - - private: - _Tp _M_tp; - }; - - - template - class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> - { - class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> - { - typedef _Sp_ebo_helper<0, _Deleter> _Del_base; - typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base; - - public: - _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept - : _Del_base(std::move(__d)), _Alloc_base(__a), _M_ptr(__p) - { } - - _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); } - _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); } - - _Ptr _M_ptr; - }; - - public: - using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>; - - - _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept - : _M_impl(__p, std::move(__d), _Alloc()) { } - - - _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept - : _M_impl(__p, std::move(__d), __a) { } - - ~_Sp_counted_deleter() noexcept { } - - virtual void - _M_dispose() noexcept - { _M_impl._M_del()(_M_impl._M_ptr); } - - virtual void - _M_destroy() noexcept - { - __allocator_type __a(_M_impl._M_alloc()); - __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; - this->~_Sp_counted_deleter(); - } - - virtual void* - _M_get_deleter(const type_info& __ti [[__gnu__::__unused__]]) noexcept - { - - - - return __ti == typeid(_Deleter) - ? std::__addressof(_M_impl._M_del()) - : nullptr; - - - - } - - private: - _Impl _M_impl; - }; - - - - struct _Sp_make_shared_tag - { - private: - template - friend class _Sp_counted_ptr_inplace; - - static const type_info& - _S_ti() noexcept __attribute__ ((__visibility__ ("default"))) - { - alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { }; - return reinterpret_cast(__tag); - } - - static bool _S_eq(const type_info&) noexcept; - }; - - template - struct _Sp_alloc_shared_tag - { - const _Alloc& _M_a; - }; - - template - class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> - { - class _Impl : _Sp_ebo_helper<0, _Alloc> - { - typedef _Sp_ebo_helper<0, _Alloc> _A_base; - - public: - explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { } - - _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); } - - __gnu_cxx::__aligned_buffer<_Tp> _M_storage; - }; - - public: - using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>; - - - template - _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args) - : _M_impl(__a) - { - - - allocator_traits<_Alloc>::construct(__a, _M_ptr(), - std::forward<_Args>(__args)...); - } - - ~_Sp_counted_ptr_inplace() noexcept { } - - virtual void - _M_dispose() noexcept - { - allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr()); - } - - - virtual void - _M_destroy() noexcept - { - __allocator_type __a(_M_impl._M_alloc()); - __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; - this->~_Sp_counted_ptr_inplace(); - } - - private: - friend class __shared_count<_Lp>; - - - - virtual void* - _M_get_deleter(const std::type_info& __ti) noexcept override - { - auto __ptr = const_cast::type*>(_M_ptr()); - - - - - if (&__ti == &_Sp_make_shared_tag::_S_ti() - || - - __ti == typeid(_Sp_make_shared_tag) - - - - ) - return __ptr; - return nullptr; - } - - _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } - - _Impl _M_impl; - }; -# 886 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - struct __sp_array_delete - { - template - void operator()(_Yp* __p) const { delete[] __p; } - }; - - template<_Lock_policy _Lp> - class __shared_count - { - - template - struct __not_alloc_shared_tag { using type = void; }; - - template - struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { }; - - - - - - - public: - constexpr __shared_count() noexcept : _M_pi(0) - { } - - template - explicit - __shared_count(_Ptr __p) : _M_pi(0) - { - try - { - _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); - } - catch(...) - { - delete __p; - throw; - } - } - - template - __shared_count(_Ptr __p, false_type) - : __shared_count(__p) - { } - - template - __shared_count(_Ptr __p, true_type) - : __shared_count(__p, __sp_array_delete{}, allocator()) - { } - - template::type> - __shared_count(_Ptr __p, _Deleter __d) - : __shared_count(__p, std::move(__d), allocator()) - { } - - template::type> - __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0) - { - typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; - try - { - typename _Sp_cd_type::__allocator_type __a2(__a); - auto __guard = std::__allocate_guarded(__a2); - _Sp_cd_type* __mem = __guard.get(); - ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a)); - _M_pi = __mem; - __guard = nullptr; - } - catch(...) - { - __d(__p); - throw; - } - } - - template - __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a, - _Args&&... __args) - { - typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type; - typename _Sp_cp_type::__allocator_type __a2(__a._M_a); - auto __guard = std::__allocate_guarded(__a2); - _Sp_cp_type* __mem = __guard.get(); - auto __pi = ::new (__mem) - _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...); - __guard = nullptr; - _M_pi = __pi; - __p = __pi->_M_ptr(); - } -# 1024 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template - explicit - __shared_count(std::auto_ptr<_Tp>&& __r); -#pragma GCC diagnostic pop - - - - template - explicit - __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0) - { - - - if (__r.get() == nullptr) - return; - - using _Ptr = typename unique_ptr<_Tp, _Del>::pointer; - using _Del2 = __conditional_t::value, - reference_wrapper::type>, - _Del>; - using _Sp_cd_type - = _Sp_counted_deleter<_Ptr, _Del2, allocator, _Lp>; - using _Alloc = allocator<_Sp_cd_type>; - using _Alloc_traits = allocator_traits<_Alloc>; - _Alloc __a; - _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1); - - - - _Alloc_traits::construct(__a, __mem, __r.release(), - std::forward<_Del>(__r.get_deleter())); - _M_pi = __mem; - } - - - explicit __shared_count(const __weak_count<_Lp>& __r); - - - explicit - __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept; - - ~__shared_count() noexcept - { - if (_M_pi != nullptr) - _M_pi->_M_release(); - } - - __shared_count(const __shared_count& __r) noexcept - : _M_pi(__r._M_pi) - { - if (_M_pi != nullptr) - _M_pi->_M_add_ref_copy(); - } - - __shared_count& - operator=(const __shared_count& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - if (__tmp != _M_pi) - { - if (__tmp != nullptr) - __tmp->_M_add_ref_copy(); - if (_M_pi != nullptr) - _M_pi->_M_release(); - _M_pi = __tmp; - } - return *this; - } - - void - _M_swap(__shared_count& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - __r._M_pi = _M_pi; - _M_pi = __tmp; - } - - long - _M_get_use_count() const noexcept - { return _M_pi ? _M_pi->_M_get_use_count() : 0; } - - bool - _M_unique() const noexcept - { return this->_M_get_use_count() == 1; } - - void* - _M_get_deleter(const std::type_info& __ti) const noexcept - { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; } - - bool - _M_less(const __shared_count& __rhs) const noexcept - { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } - - bool - _M_less(const __weak_count<_Lp>& __rhs) const noexcept - { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } - - - friend inline bool - operator==(const __shared_count& __a, const __shared_count& __b) noexcept - { return __a._M_pi == __b._M_pi; } - - private: - friend class __weak_count<_Lp>; - - - - - _Sp_counted_base<_Lp>* _M_pi; - }; - - - template<_Lock_policy _Lp> - class __weak_count - { - public: - constexpr __weak_count() noexcept : _M_pi(nullptr) - { } - - __weak_count(const __shared_count<_Lp>& __r) noexcept - : _M_pi(__r._M_pi) - { - if (_M_pi != nullptr) - _M_pi->_M_weak_add_ref(); - } - - __weak_count(const __weak_count& __r) noexcept - : _M_pi(__r._M_pi) - { - if (_M_pi != nullptr) - _M_pi->_M_weak_add_ref(); - } - - __weak_count(__weak_count&& __r) noexcept - : _M_pi(__r._M_pi) - { __r._M_pi = nullptr; } - - ~__weak_count() noexcept - { - if (_M_pi != nullptr) - _M_pi->_M_weak_release(); - } - - __weak_count& - operator=(const __shared_count<_Lp>& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - if (__tmp != nullptr) - __tmp->_M_weak_add_ref(); - if (_M_pi != nullptr) - _M_pi->_M_weak_release(); - _M_pi = __tmp; - return *this; - } - - __weak_count& - operator=(const __weak_count& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - if (__tmp != nullptr) - __tmp->_M_weak_add_ref(); - if (_M_pi != nullptr) - _M_pi->_M_weak_release(); - _M_pi = __tmp; - return *this; - } - - __weak_count& - operator=(__weak_count&& __r) noexcept - { - if (_M_pi != nullptr) - _M_pi->_M_weak_release(); - _M_pi = __r._M_pi; - __r._M_pi = nullptr; - return *this; - } - - void - _M_swap(__weak_count& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - __r._M_pi = _M_pi; - _M_pi = __tmp; - } - - long - _M_get_use_count() const noexcept - { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; } - - bool - _M_less(const __weak_count& __rhs) const noexcept - { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } - - bool - _M_less(const __shared_count<_Lp>& __rhs) const noexcept - { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } - - - friend inline bool - operator==(const __weak_count& __a, const __weak_count& __b) noexcept - { return __a._M_pi == __b._M_pi; } - - private: - friend class __shared_count<_Lp>; - - - - - _Sp_counted_base<_Lp>* _M_pi; - }; - - - template<_Lock_policy _Lp> - inline - __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r) - : _M_pi(__r._M_pi) - { - if (_M_pi == nullptr || !_M_pi->_M_add_ref_lock_nothrow()) - __throw_bad_weak_ptr(); - } - - - template<_Lock_policy _Lp> - inline - __shared_count<_Lp>:: - __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept - : _M_pi(__r._M_pi) - { - if (_M_pi && !_M_pi->_M_add_ref_lock_nothrow()) - _M_pi = nullptr; - } - - - - - - template - struct __sp_compatible_with - : false_type - { }; - - template - struct __sp_compatible_with<_Yp*, _Tp*> - : is_convertible<_Yp*, _Tp*>::type - { }; - - template - struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]> - : true_type - { }; - - template - struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]> - : true_type - { }; - - template - struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]> - : true_type - { }; - - template - struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]> - : true_type - { }; - - - template - struct __sp_is_constructible_arrN - : false_type - { }; - - template - struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> - : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type - { }; - - - template - struct __sp_is_constructible_arr - : false_type - { }; - - template - struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> - : is_convertible<_Yp(*)[], _Up(*)[]>::type - { }; - - - template - struct __sp_is_constructible; - - - template - struct __sp_is_constructible<_Up[_Nm], _Yp> - : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type - { }; - - - template - struct __sp_is_constructible<_Up[], _Yp> - : __sp_is_constructible_arr<_Up, _Yp>::type - { }; - - - template - struct __sp_is_constructible - : is_convertible<_Yp*, _Tp*>::type - { }; - - - - template::value, bool = is_void<_Tp>::value> - class __shared_ptr_access - { - public: - using element_type = _Tp; - - element_type& - operator*() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(_M_get() != nullptr)) __builtin_unreachable(); } while (false); - return *_M_get(); - } - - element_type* - operator->() const noexcept - { - ; - return _M_get(); - } - - private: - element_type* - _M_get() const noexcept - { return static_cast*>(this)->get(); } - }; - - - template - class __shared_ptr_access<_Tp, _Lp, false, true> - { - public: - using element_type = _Tp; - - element_type* - operator->() const noexcept - { - auto __ptr = static_cast*>(this)->get(); - ; - return __ptr; - } - }; - - - template - class __shared_ptr_access<_Tp, _Lp, true, false> - { - public: - using element_type = typename remove_extent<_Tp>::type; -# 1407 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - element_type& - operator[](ptrdiff_t __i) const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(_M_get() != nullptr)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(!extent<_Tp>::value || __i < extent<_Tp>::value)) __builtin_unreachable(); } while (false); - return _M_get()[__i]; - } - - private: - element_type* - _M_get() const noexcept - { return static_cast*>(this)->get(); } - }; - - template - class __shared_ptr - : public __shared_ptr_access<_Tp, _Lp> - { - public: - using element_type = typename remove_extent<_Tp>::type; - - private: - - template - using _SafeConv - = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type; - - - template - using _Compatible = typename - enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; - - - template - using _Assignable = _Compatible<_Yp, __shared_ptr&>; - - - template::pointer> - using _UniqCompatible = __enable_if_t<__and_< - __sp_compatible_with<_Yp*, _Tp*>, - is_convertible<_Ptr, element_type*>, - is_move_constructible<_Del> - >::value, _Res>; - - - template - using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>; - - public: - - - using weak_type = __weak_ptr<_Tp, _Lp>; - - - constexpr __shared_ptr() noexcept - : _M_ptr(0), _M_refcount() - { } - - template> - explicit - __shared_ptr(_Yp* __p) - : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type()) - { - static_assert( !is_void<_Yp>::value, "incomplete type" ); - static_assert( sizeof(_Yp) > 0, "incomplete type" ); - _M_enable_shared_from_this_with(__p); - } - - template> - __shared_ptr(_Yp* __p, _Deleter __d) - : _M_ptr(__p), _M_refcount(__p, std::move(__d)) - { - static_assert(__is_invocable<_Deleter&, _Yp*&>::value, - "deleter expression d(p) is well-formed"); - _M_enable_shared_from_this_with(__p); - } - - template> - __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) - : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a)) - { - static_assert(__is_invocable<_Deleter&, _Yp*&>::value, - "deleter expression d(p) is well-formed"); - _M_enable_shared_from_this_with(__p); - } - - template - __shared_ptr(nullptr_t __p, _Deleter __d) - : _M_ptr(0), _M_refcount(__p, std::move(__d)) - { } - - template - __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) - : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a)) - { } - - - template - __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r, - element_type* __p) noexcept - : _M_ptr(__p), _M_refcount(__r._M_refcount) - { } - - - template - __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r, - element_type* __p) noexcept - : _M_ptr(__p), _M_refcount() - { - _M_refcount._M_swap(__r._M_refcount); - __r._M_ptr = nullptr; - } - - __shared_ptr(const __shared_ptr&) noexcept = default; - __shared_ptr& operator=(const __shared_ptr&) noexcept = default; - ~__shared_ptr() = default; - - template> - __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) - { } - - __shared_ptr(__shared_ptr&& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount() - { - _M_refcount._M_swap(__r._M_refcount); - __r._M_ptr = nullptr; - } - - template> - __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount() - { - _M_refcount._M_swap(__r._M_refcount); - __r._M_ptr = nullptr; - } - - template> - explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r) - : _M_refcount(__r._M_refcount) - { - - - _M_ptr = __r._M_ptr; - } - - - template> - __shared_ptr(unique_ptr<_Yp, _Del>&& __r) - : _M_ptr(__r.get()), _M_refcount() - { - auto __raw = __to_address(__r.get()); - _M_refcount = __shared_count<_Lp>(std::move(__r)); - _M_enable_shared_from_this_with(__raw); - } -# 1585 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template> - __shared_ptr(auto_ptr<_Yp>&& __r); -#pragma GCC diagnostic pop - - - constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } - - template - _Assignable<_Yp> - operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept - { - _M_ptr = __r._M_ptr; - _M_refcount = __r._M_refcount; - return *this; - } - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template - _Assignable<_Yp> - operator=(auto_ptr<_Yp>&& __r) - { - __shared_ptr(std::move(__r)).swap(*this); - return *this; - } -#pragma GCC diagnostic pop - - - __shared_ptr& - operator=(__shared_ptr&& __r) noexcept - { - __shared_ptr(std::move(__r)).swap(*this); - return *this; - } - - template - _Assignable<_Yp> - operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept - { - __shared_ptr(std::move(__r)).swap(*this); - return *this; - } - - template - _UniqAssignable<_Yp, _Del> - operator=(unique_ptr<_Yp, _Del>&& __r) - { - __shared_ptr(std::move(__r)).swap(*this); - return *this; - } - - void - reset() noexcept - { __shared_ptr().swap(*this); } - - template - _SafeConv<_Yp> - reset(_Yp* __p) - { - - do { if (std::__is_constant_evaluated() && !bool(__p == nullptr || __p != _M_ptr)) __builtin_unreachable(); } while (false); - __shared_ptr(__p).swap(*this); - } - - template - _SafeConv<_Yp> - reset(_Yp* __p, _Deleter __d) - { __shared_ptr(__p, std::move(__d)).swap(*this); } - - template - _SafeConv<_Yp> - reset(_Yp* __p, _Deleter __d, _Alloc __a) - { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); } - - - element_type* - get() const noexcept - { return _M_ptr; } - - - explicit operator bool() const noexcept - { return _M_ptr != nullptr; } - - - bool - unique() const noexcept - { return _M_refcount._M_unique(); } - - - long - use_count() const noexcept - { return _M_refcount._M_get_use_count(); } - - - void - swap(__shared_ptr<_Tp, _Lp>& __other) noexcept - { - std::swap(_M_ptr, __other._M_ptr); - _M_refcount._M_swap(__other._M_refcount); - } -# 1697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - template - bool - owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept - { return _M_refcount._M_less(__rhs._M_refcount); } - - template - bool - owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept - { return _M_refcount._M_less(__rhs._M_refcount); } - - - protected: - - template - __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) - : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...) - { _M_enable_shared_from_this_with(_M_ptr); } - - template - friend __shared_ptr<_Tp1, _Lp1> - __allocate_shared(const _Alloc& __a, _Args&&... __args); -# 1731 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexcept - : _M_refcount(__r._M_refcount, std::nothrow) - { - _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr; - } - - friend class __weak_ptr<_Tp, _Lp>; - - private: - - template - using __esft_base_t = decltype(__enable_shared_from_this_base( - std::declval&>(), - std::declval<_Yp*>())); - - - template - struct __has_esft_base - : false_type { }; - - template - struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>> - : __not_> { }; - - template::type> - typename enable_if<__has_esft_base<_Yp2>::value>::type - _M_enable_shared_from_this_with(_Yp* __p) noexcept - { - if (auto __base = __enable_shared_from_this_base(_M_refcount, __p)) - __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount); - } - - template::type> - typename enable_if::value>::type - _M_enable_shared_from_this_with(_Yp*) noexcept - { } - - void* - _M_get_deleter(const std::type_info& __ti) const noexcept - { return _M_refcount._M_get_deleter(__ti); } - - template friend class __shared_ptr; - template friend class __weak_ptr; - - template - friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; - - template - friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept; - - - - - - element_type* _M_ptr; - __shared_count<_Lp> _M_refcount; - }; - - - - template - inline bool - operator==(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return __a.get() == __b.get(); } - - template - inline bool - operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return !__a; } -# 1817 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - template - inline bool - operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return !__a; } - - template - inline bool - operator!=(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return __a.get() != __b.get(); } - - template - inline bool - operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return (bool)__a; } - - template - inline bool - operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return (bool)__a; } - - template - inline bool - operator<(const __shared_ptr<_Tp, _Lp>& __a, - const __shared_ptr<_Up, _Lp>& __b) noexcept - { - using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; - using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type; - using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; - return less<_Vp>()(__a.get(), __b.get()); - } - - template - inline bool - operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { - using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; - return less<_Tp_elt*>()(__a.get(), nullptr); - } - - template - inline bool - operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { - using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; - return less<_Tp_elt*>()(nullptr, __a.get()); - } - - template - inline bool - operator<=(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return !(__b < __a); } - - template - inline bool - operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return !(nullptr < __a); } - - template - inline bool - operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return !(__a < nullptr); } - - template - inline bool - operator>(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return (__b < __a); } - - template - inline bool - operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return nullptr < __a; } - - template - inline bool - operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return __a < nullptr; } - - template - inline bool - operator>=(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return !(__a < __b); } - - template - inline bool - operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return !(__a < nullptr); } - - template - inline bool - operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return !(nullptr < __a); } - - - - template - inline void - swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept - { __a.swap(__b); } -# 1927 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - template - inline __shared_ptr<_Tp, _Lp> - static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - using _Sp = __shared_ptr<_Tp, _Lp>; - return _Sp(__r, static_cast(__r.get())); - } - - - - - - - template - inline __shared_ptr<_Tp, _Lp> - const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - using _Sp = __shared_ptr<_Tp, _Lp>; - return _Sp(__r, const_cast(__r.get())); - } - - - - - - - template - inline __shared_ptr<_Tp, _Lp> - dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - using _Sp = __shared_ptr<_Tp, _Lp>; - if (auto* __p = dynamic_cast(__r.get())) - return _Sp(__r, __p); - return _Sp(); - } - - - template - inline __shared_ptr<_Tp, _Lp> - reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - using _Sp = __shared_ptr<_Tp, _Lp>; - return _Sp(__r, reinterpret_cast(__r.get())); - } - - - template - class __weak_ptr - { - template - using _Compatible = typename - enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; - - - template - using _Assignable = _Compatible<_Yp, __weak_ptr&>; - - public: - using element_type = typename remove_extent<_Tp>::type; - - constexpr __weak_ptr() noexcept - : _M_ptr(nullptr), _M_refcount() - { } - - __weak_ptr(const __weak_ptr&) noexcept = default; - - ~__weak_ptr() = default; -# 2009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - template> - __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept - : _M_refcount(__r._M_refcount) - { _M_ptr = __r.lock().get(); } - - template> - __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) - { } - - __weak_ptr(__weak_ptr&& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount)) - { __r._M_ptr = nullptr; } - - template> - __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept - : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount)) - { __r._M_ptr = nullptr; } - - __weak_ptr& - operator=(const __weak_ptr& __r) noexcept = default; - - template - _Assignable<_Yp> - operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept - { - _M_ptr = __r.lock().get(); - _M_refcount = __r._M_refcount; - return *this; - } - - template - _Assignable<_Yp> - operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept - { - _M_ptr = __r._M_ptr; - _M_refcount = __r._M_refcount; - return *this; - } - - __weak_ptr& - operator=(__weak_ptr&& __r) noexcept - { - __weak_ptr(std::move(__r)).swap(*this); - return *this; - } - - template - _Assignable<_Yp> - operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept - { - _M_ptr = __r.lock().get(); - _M_refcount = std::move(__r._M_refcount); - __r._M_ptr = nullptr; - return *this; - } - - __shared_ptr<_Tp, _Lp> - lock() const noexcept - { return __shared_ptr(*this, std::nothrow); } - - long - use_count() const noexcept - { return _M_refcount._M_get_use_count(); } - - bool - expired() const noexcept - { return _M_refcount._M_get_use_count() == 0; } - - template - bool - owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept - { return _M_refcount._M_less(__rhs._M_refcount); } - - template - bool - owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept - { return _M_refcount._M_less(__rhs._M_refcount); } - - void - reset() noexcept - { __weak_ptr().swap(*this); } - - void - swap(__weak_ptr& __s) noexcept - { - std::swap(_M_ptr, __s._M_ptr); - _M_refcount._M_swap(__s._M_refcount); - } - - private: - - void - _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept - { - if (use_count() == 0) - { - _M_ptr = __ptr; - _M_refcount = __refcount; - } - } - - template friend class __shared_ptr; - template friend class __weak_ptr; - friend class __enable_shared_from_this<_Tp, _Lp>; - friend class enable_shared_from_this<_Tp>; - - - - - element_type* _M_ptr; - __weak_count<_Lp> _M_refcount; - }; - - - template - inline void - swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept - { __a.swap(__b); } - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template - struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> - { - bool - operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept - { return __lhs.owner_before(__rhs); } - - bool - operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept - { return __lhs.owner_before(__rhs); } - - bool - operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept - { return __lhs.owner_before(__rhs); } - }; -#pragma GCC diagnostic pop - - template<> - struct _Sp_owner_less - { - template - auto - operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept - -> decltype(__lhs.owner_before(__rhs)) - { return __lhs.owner_before(__rhs); } - - using is_transparent = void; - }; - - template - struct owner_less<__shared_ptr<_Tp, _Lp>> - : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>> - { }; - - template - struct owner_less<__weak_ptr<_Tp, _Lp>> - : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>> - { }; - - - template - class __enable_shared_from_this - { - protected: - constexpr __enable_shared_from_this() noexcept { } - - __enable_shared_from_this(const __enable_shared_from_this&) noexcept { } - - __enable_shared_from_this& - operator=(const __enable_shared_from_this&) noexcept - { return *this; } - - ~__enable_shared_from_this() { } - - public: - __shared_ptr<_Tp, _Lp> - shared_from_this() - { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } - - __shared_ptr - shared_from_this() const - { return __shared_ptr(this->_M_weak_this); } - - - __weak_ptr<_Tp, _Lp> - weak_from_this() noexcept - { return this->_M_weak_this; } - - __weak_ptr - weak_from_this() const noexcept - { return this->_M_weak_this; } - - - private: - template - void - _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept - { _M_weak_this._M_assign(__p, __n); } - - friend const __enable_shared_from_this* - __enable_shared_from_this_base(const __shared_count<_Lp>&, - const __enable_shared_from_this* __p) - { return __p; } - - template - friend class __shared_ptr; - - mutable __weak_ptr<_Tp, _Lp> _M_weak_this; - }; - - template - inline __shared_ptr<_Tp, _Lp> - __allocate_shared(const _Alloc& __a, _Args&&... __args) - { - static_assert(!is_array<_Tp>::value, "make_shared not supported"); - - return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a}, - std::forward<_Args>(__args)...); - } - - template - inline __shared_ptr<_Tp, _Lp> - __make_shared(_Args&&... __args) - { - typedef typename std::remove_const<_Tp>::type _Tp_nc; - return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(), - std::forward<_Args>(__args)...); - } - - - template - struct hash<__shared_ptr<_Tp, _Lp>> - : public __hash_base> - { - size_t - operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept - { - return hash::element_type*>()( - __s.get()); - } - }; - - -} -# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - inline std::basic_ostream<_Ch, _Tr>& - operator<<(std::basic_ostream<_Ch, _Tr>& __os, - const __shared_ptr<_Tp, _Lp>& __p) - { - __os << __p.get(); - return __os; - } - - template - inline _Del* - get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept - { - - return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); - - - - } - - - - - - template - inline _Del* - get_deleter(const shared_ptr<_Tp>& __p) noexcept - { - - return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); - - - - } -# 111 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - using _NonArray = __enable_if_t::value, _Tp>; -# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - class shared_ptr : public __shared_ptr<_Tp> - { - template - using _Constructible = typename enable_if< - is_constructible<__shared_ptr<_Tp>, _Args...>::value - >::type; - - template - using _Assignable = typename enable_if< - is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr& - >::type; - - public: - - - using element_type = typename __shared_ptr<_Tp>::element_type; - - - - - - using weak_type = weak_ptr<_Tp>; - - - - - - constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } - - shared_ptr(const shared_ptr&) noexcept = default; - - - - - - - - template> - explicit - shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { } -# 229 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template> - shared_ptr(_Yp* __p, _Deleter __d) - : __shared_ptr<_Tp>(__p, std::move(__d)) { } -# 247 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - shared_ptr(nullptr_t __p, _Deleter __d) - : __shared_ptr<_Tp>(__p, std::move(__d)) { } -# 266 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template> - shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) - : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } -# 286 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) - : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } -# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept - : __shared_ptr<_Tp>(__r, __p) { } -# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template&>> - shared_ptr(const shared_ptr<_Yp>& __r) noexcept - : __shared_ptr<_Tp>(__r) { } - - - - - - - shared_ptr(shared_ptr&& __r) noexcept - : __shared_ptr<_Tp>(std::move(__r)) { } - - - - - - - template>> - shared_ptr(shared_ptr<_Yp>&& __r) noexcept - : __shared_ptr<_Tp>(std::move(__r)) { } -# 379 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template&>> - explicit shared_ptr(const weak_ptr<_Yp>& __r) - : __shared_ptr<_Tp>(__r) { } - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template>> - shared_ptr(auto_ptr<_Yp>&& __r); -#pragma GCC diagnostic pop - - - - - template>> - shared_ptr(unique_ptr<_Yp, _Del>&& __r) - : __shared_ptr<_Tp>(std::move(__r)) { } -# 412 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } - - shared_ptr& operator=(const shared_ptr&) noexcept = default; - - template - _Assignable&> - operator=(const shared_ptr<_Yp>& __r) noexcept - { - this->__shared_ptr<_Tp>::operator=(__r); - return *this; - } - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template - _Assignable> - operator=(auto_ptr<_Yp>&& __r) - { - this->__shared_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } -#pragma GCC diagnostic pop - - - shared_ptr& - operator=(shared_ptr&& __r) noexcept - { - this->__shared_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } - - template - _Assignable> - operator=(shared_ptr<_Yp>&& __r) noexcept - { - this->__shared_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } - - template - _Assignable> - operator=(unique_ptr<_Yp, _Del>&& __r) - { - this->__shared_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } - - private: - - template - shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) - : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...) - { } - - template - friend shared_ptr<_NonArray<_Yp>> - allocate_shared(const _Alloc&, _Args&&...); - - template - friend shared_ptr<_NonArray<_Yp>> - make_shared(_Args&&...); -# 535 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) noexcept - : __shared_ptr<_Tp>(__r, std::nothrow) { } - - friend class weak_ptr<_Tp>; - }; - - - template - shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; - template - shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>; - - - - - - - - template - [[__nodiscard__]] inline bool - operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return __a.get() == __b.get(); } - - - template - [[__nodiscard__]] inline bool - operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return !__a; } -# 580 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - [[__nodiscard__]] inline bool - operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return !__a; } - - - template - [[__nodiscard__]] inline bool - operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return __a.get() != __b.get(); } - - - template - [[__nodiscard__]] inline bool - operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return (bool)__a; } - - - template - [[__nodiscard__]] inline bool - operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return (bool)__a; } - - - template - [[__nodiscard__]] inline bool - operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { - using _Tp_elt = typename shared_ptr<_Tp>::element_type; - using _Up_elt = typename shared_ptr<_Up>::element_type; - using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; - return less<_Vp>()(__a.get(), __b.get()); - } - - - template - [[__nodiscard__]] inline bool - operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { - using _Tp_elt = typename shared_ptr<_Tp>::element_type; - return less<_Tp_elt*>()(__a.get(), nullptr); - } - - - template - [[__nodiscard__]] inline bool - operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { - using _Tp_elt = typename shared_ptr<_Tp>::element_type; - return less<_Tp_elt*>()(nullptr, __a.get()); - } - - - template - [[__nodiscard__]] inline bool - operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return !(__b < __a); } - - - template - [[__nodiscard__]] inline bool - operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return !(nullptr < __a); } - - - template - [[__nodiscard__]] inline bool - operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return !(__a < nullptr); } - - - template - [[__nodiscard__]] inline bool - operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return (__b < __a); } - - - template - [[__nodiscard__]] inline bool - operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return nullptr < __a; } - - - template - [[__nodiscard__]] inline bool - operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return __a < nullptr; } - - - template - [[__nodiscard__]] inline bool - operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return !(__a < __b); } - - - template - [[__nodiscard__]] inline bool - operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return !(__a < nullptr); } - - - template - [[__nodiscard__]] inline bool - operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return !(nullptr < __a); } - - - - - - template - inline void - swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept - { __a.swap(__b); } - - - - - template - inline shared_ptr<_Tp> - static_pointer_cast(const shared_ptr<_Up>& __r) noexcept - { - using _Sp = shared_ptr<_Tp>; - return _Sp(__r, static_cast(__r.get())); - } - - - template - inline shared_ptr<_Tp> - const_pointer_cast(const shared_ptr<_Up>& __r) noexcept - { - using _Sp = shared_ptr<_Tp>; - return _Sp(__r, const_cast(__r.get())); - } - - - template - inline shared_ptr<_Tp> - dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept - { - using _Sp = shared_ptr<_Tp>; - if (auto* __p = dynamic_cast(__r.get())) - return _Sp(__r, __p); - return _Sp(); - } - - - - - template - inline shared_ptr<_Tp> - reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept - { - using _Sp = shared_ptr<_Tp>; - return _Sp(__r, reinterpret_cast(__r.get())); - } -# 810 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - class weak_ptr : public __weak_ptr<_Tp> - { - template - using _Constructible = typename enable_if< - is_constructible<__weak_ptr<_Tp>, _Arg>::value - >::type; - - template - using _Assignable = typename enable_if< - is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr& - >::type; - - public: - constexpr weak_ptr() noexcept = default; - - template&>> - weak_ptr(const shared_ptr<_Yp>& __r) noexcept - : __weak_ptr<_Tp>(__r) { } - - weak_ptr(const weak_ptr&) noexcept = default; - - template&>> - weak_ptr(const weak_ptr<_Yp>& __r) noexcept - : __weak_ptr<_Tp>(__r) { } - - weak_ptr(weak_ptr&&) noexcept = default; - - template>> - weak_ptr(weak_ptr<_Yp>&& __r) noexcept - : __weak_ptr<_Tp>(std::move(__r)) { } - - weak_ptr& - operator=(const weak_ptr& __r) noexcept = default; - - template - _Assignable&> - operator=(const weak_ptr<_Yp>& __r) noexcept - { - this->__weak_ptr<_Tp>::operator=(__r); - return *this; - } - - template - _Assignable&> - operator=(const shared_ptr<_Yp>& __r) noexcept - { - this->__weak_ptr<_Tp>::operator=(__r); - return *this; - } - - weak_ptr& - operator=(weak_ptr&& __r) noexcept = default; - - template - _Assignable> - operator=(weak_ptr<_Yp>&& __r) noexcept - { - this->__weak_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } - - shared_ptr<_Tp> - lock() const noexcept - { return shared_ptr<_Tp>(*this, std::nothrow); } - }; - - - template - weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; - - - - - - template - inline void - swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept - { __a.swap(__b); } - - - - template - struct owner_less; - - - template<> - struct owner_less : _Sp_owner_less - { }; - - - template - struct owner_less> - : public _Sp_owner_less, weak_ptr<_Tp>> - { }; - - - template - struct owner_less> - : public _Sp_owner_less, shared_ptr<_Tp>> - { }; - - - - - - - template - class enable_shared_from_this - { - protected: - constexpr enable_shared_from_this() noexcept { } - - enable_shared_from_this(const enable_shared_from_this&) noexcept { } - - enable_shared_from_this& - operator=(const enable_shared_from_this&) noexcept - { return *this; } - - ~enable_shared_from_this() { } - - public: - shared_ptr<_Tp> - shared_from_this() - { return shared_ptr<_Tp>(this->_M_weak_this); } - - shared_ptr - shared_from_this() const - { return shared_ptr(this->_M_weak_this); } - - - - - - - - weak_ptr<_Tp> - weak_from_this() noexcept - { return this->_M_weak_this; } - - weak_ptr - weak_from_this() const noexcept - { return this->_M_weak_this; } - - - - private: - template - void - _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept - { _M_weak_this._M_assign(__p, __n); } - - - friend const enable_shared_from_this* - __enable_shared_from_this_base(const __shared_count<>&, - const enable_shared_from_this* __p) - { return __p; } - - template - friend class __shared_ptr; - - mutable weak_ptr<_Tp> _M_weak_this; - }; -# 988 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - inline shared_ptr<_NonArray<_Tp>> - allocate_shared(const _Alloc& __a, _Args&&... __args) - { - return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, - std::forward<_Args>(__args)...); - } -# 1003 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - inline shared_ptr<_NonArray<_Tp>> - make_shared(_Args&&... __args) - { - using _Alloc = allocator; - _Alloc __a; - return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, - std::forward<_Args>(__args)...); - } -# 1152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - struct hash> - : public __hash_base> - { - size_t - operator()(const shared_ptr<_Tp>& __s) const noexcept - { - return std::hash::element_type*>()(__s.get()); - } - }; - - - - - - namespace __detail::__variant - { - template struct _Never_valueless_alt; - - - - template - struct _Never_valueless_alt> - : std::true_type - { }; - - - - template - struct _Never_valueless_alt> - : std::true_type - { }; - } - - - -} -# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_lockfree_defines.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_lockfree_defines.h" 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 2 3 -# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - typedef enum memory_order - { - memory_order_relaxed, - memory_order_consume, - memory_order_acquire, - memory_order_release, - memory_order_acq_rel, - memory_order_seq_cst - } memory_order; - - - - enum __memory_order_modifier - { - __memory_order_mask = 0x0ffff, - __memory_order_modifier_mask = 0xffff0000, - __memory_order_hle_acquire = 0x10000, - __memory_order_hle_release = 0x20000 - }; - - - constexpr memory_order - operator|(memory_order __m, __memory_order_modifier __mod) - { - return memory_order(int(__m) | int(__mod)); - } - - constexpr memory_order - operator&(memory_order __m, __memory_order_modifier __mod) - { - return memory_order(int(__m) & int(__mod)); - } - - - - - constexpr memory_order - __cmpexch_failure_order2(memory_order __m) noexcept - { - return __m == memory_order_acq_rel ? memory_order_acquire - : __m == memory_order_release ? memory_order_relaxed : __m; - } - - constexpr memory_order - __cmpexch_failure_order(memory_order __m) noexcept - { - return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask) - | __memory_order_modifier(__m & __memory_order_modifier_mask)); - } - - constexpr bool - __is_valid_cmpexch_failure_order(memory_order __m) noexcept - { - return (__m & __memory_order_mask) != memory_order_release - && (__m & __memory_order_mask) != memory_order_acq_rel; - } - - - template - struct __atomic_base; - - - - inline __attribute__((__always_inline__)) void - atomic_thread_fence(memory_order __m) noexcept - { __atomic_thread_fence(int(__m)); } - - inline __attribute__((__always_inline__)) void - atomic_signal_fence(memory_order __m) noexcept - { __atomic_signal_fence(int(__m)); } - - - template - inline _Tp - kill_dependency(_Tp __y) noexcept - { - _Tp __ret(__y); - return __ret; - } -# 173 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - template - struct atomic; - - template - struct atomic<_Tp*>; - - - - typedef bool __atomic_flag_data_type; -# 198 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - extern "C" { - - struct __atomic_flag_base - { - __atomic_flag_data_type _M_i ; - }; - - } - - - - - - - struct atomic_flag : public __atomic_flag_base - { - atomic_flag() noexcept = default; - ~atomic_flag() noexcept = default; - atomic_flag(const atomic_flag&) = delete; - atomic_flag& operator=(const atomic_flag&) = delete; - atomic_flag& operator=(const atomic_flag&) volatile = delete; - - - constexpr atomic_flag(bool __i) noexcept - : __atomic_flag_base{ _S_init(__i) } - { } - - inline __attribute__((__always_inline__)) bool - test_and_set(memory_order __m = memory_order_seq_cst) noexcept - { - return __atomic_test_and_set (&_M_i, int(__m)); - } - - inline __attribute__((__always_inline__)) bool - test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept - { - return __atomic_test_and_set (&_M_i, int(__m)); - } -# 284 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - inline __attribute__((__always_inline__)) void - clear(memory_order __m = memory_order_seq_cst) noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - __atomic_clear (&_M_i, int(__m)); - } - - inline __attribute__((__always_inline__)) void - clear(memory_order __m = memory_order_seq_cst) volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - __atomic_clear (&_M_i, int(__m)); - } - - private: - static constexpr __atomic_flag_data_type - _S_init(bool __i) - { return __i ? 1 : 0; } - }; -# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - template - struct __atomic_base - { - using value_type = _ITp; - using difference_type = value_type; - - private: - typedef _ITp __int_type; - - static constexpr int _S_alignment = - sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); - - alignas(_S_alignment) __int_type _M_i ; - - public: - __atomic_base() noexcept = default; - ~__atomic_base() noexcept = default; - __atomic_base(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) volatile = delete; - - - constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } - - operator __int_type() const noexcept - { return load(); } - - operator __int_type() const volatile noexcept - { return load(); } - - __int_type - operator=(__int_type __i) noexcept - { - store(__i); - return __i; - } - - __int_type - operator=(__int_type __i) volatile noexcept - { - store(__i); - return __i; - } - - __int_type - operator++(int) noexcept - { return fetch_add(1); } - - __int_type - operator++(int) volatile noexcept - { return fetch_add(1); } - - __int_type - operator--(int) noexcept - { return fetch_sub(1); } - - __int_type - operator--(int) volatile noexcept - { return fetch_sub(1); } - - __int_type - operator++() noexcept - { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } - - __int_type - operator++() volatile noexcept - { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } - - __int_type - operator--() noexcept - { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } - - __int_type - operator--() volatile noexcept - { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } - - __int_type - operator+=(__int_type __i) noexcept - { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator+=(__int_type __i) volatile noexcept - { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator-=(__int_type __i) noexcept - { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator-=(__int_type __i) volatile noexcept - { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator&=(__int_type __i) noexcept - { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator&=(__int_type __i) volatile noexcept - { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator|=(__int_type __i) noexcept - { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator|=(__int_type __i) volatile noexcept - { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator^=(__int_type __i) noexcept - { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator^=(__int_type __i) volatile noexcept - { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - bool - is_lock_free() const noexcept - { - - return __atomic_is_lock_free(sizeof(_M_i), - reinterpret_cast(-_S_alignment)); - } - - bool - is_lock_free() const volatile noexcept - { - - return __atomic_is_lock_free(sizeof(_M_i), - reinterpret_cast(-_S_alignment)); - } - - inline __attribute__((__always_inline__)) void - store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - - __atomic_store_n(&_M_i, __i, int(__m)); - } - - inline __attribute__((__always_inline__)) void - store(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - - __atomic_store_n(&_M_i, __i, int(__m)); - } - - inline __attribute__((__always_inline__)) __int_type - load(memory_order __m = memory_order_seq_cst) const noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - return __atomic_load_n(&_M_i, int(__m)); - } - - inline __attribute__((__always_inline__)) __int_type - load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - return __atomic_load_n(&_M_i, int(__m)); - } - - inline __attribute__((__always_inline__)) __int_type - exchange(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { - return __atomic_exchange_n(&_M_i, __i, int(__m)); - } - - - inline __attribute__((__always_inline__)) __int_type - exchange(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return __atomic_exchange_n(&_M_i, __i, int(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m1, memory_order __m2) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) noexcept - { - return compare_exchange_weak(__i1, __i2, __m, - __cmpexch_failure_order(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return compare_exchange_weak(__i1, __i2, __m, - __cmpexch_failure_order(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m1, memory_order __m2) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) noexcept - { - return compare_exchange_strong(__i1, __i2, __m, - __cmpexch_failure_order(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return compare_exchange_strong(__i1, __i2, __m, - __cmpexch_failure_order(__m)); - } -# 632 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - inline __attribute__((__always_inline__)) __int_type - fetch_add(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_add(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_add(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_add(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_sub(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_sub(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_and(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_and(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_and(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_and(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_or(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_or(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_or(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_or(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_xor(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_xor(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } - }; - - - - template - struct __atomic_base<_PTp*> - { - private: - typedef _PTp* __pointer_type; - - __pointer_type _M_p ; - - - constexpr ptrdiff_t - _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } - - constexpr ptrdiff_t - _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); } - - public: - __atomic_base() noexcept = default; - ~__atomic_base() noexcept = default; - __atomic_base(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) volatile = delete; - - - constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } - - operator __pointer_type() const noexcept - { return load(); } - - operator __pointer_type() const volatile noexcept - { return load(); } - - __pointer_type - operator=(__pointer_type __p) noexcept - { - store(__p); - return __p; - } - - __pointer_type - operator=(__pointer_type __p) volatile noexcept - { - store(__p); - return __p; - } - - __pointer_type - operator++(int) noexcept - { return fetch_add(1); } - - __pointer_type - operator++(int) volatile noexcept - { return fetch_add(1); } - - __pointer_type - operator--(int) noexcept - { return fetch_sub(1); } - - __pointer_type - operator--(int) volatile noexcept - { return fetch_sub(1); } - - __pointer_type - operator++() noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator++() volatile noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator--() noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator--() volatile noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator+=(ptrdiff_t __d) noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - __pointer_type - operator+=(ptrdiff_t __d) volatile noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - __pointer_type - operator-=(ptrdiff_t __d) noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - __pointer_type - operator-=(ptrdiff_t __d) volatile noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - bool - is_lock_free() const noexcept - { - - return __atomic_is_lock_free(sizeof(_M_p), - reinterpret_cast(-__alignof(_M_p))); - } - - bool - is_lock_free() const volatile noexcept - { - - return __atomic_is_lock_free(sizeof(_M_p), - reinterpret_cast(-__alignof(_M_p))); - } - - inline __attribute__((__always_inline__)) void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - - __atomic_store_n(&_M_p, __p, int(__m)); - } - - inline __attribute__((__always_inline__)) void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - - __atomic_store_n(&_M_p, __p, int(__m)); - } - - inline __attribute__((__always_inline__)) __pointer_type - load(memory_order __m = memory_order_seq_cst) const noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - return __atomic_load_n(&_M_p, int(__m)); - } - - inline __attribute__((__always_inline__)) __pointer_type - load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - return __atomic_load_n(&_M_p, int(__m)); - } - - inline __attribute__((__always_inline__)) __pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - return __atomic_exchange_n(&_M_p, __p, int(__m)); - } - - - inline __attribute__((__always_inline__)) __pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return __atomic_exchange_n(&_M_p, __p, int(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, - int(__m1), int(__m2)); - } -# 935 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - inline __attribute__((__always_inline__)) __pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } - - inline __attribute__((__always_inline__)) __pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } - - inline __attribute__((__always_inline__)) __pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } - - inline __attribute__((__always_inline__)) __pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } - }; - - namespace __atomic_impl - { - - - template - constexpr bool - __maybe_has_padding() - { - - return false; - - - - - - - } - - template - inline __attribute__((__always_inline__)) _Tp* - __clear_padding(_Tp& __val) noexcept - { - auto* __ptr = std::__addressof(__val); - - - - - return __ptr; - } - - - template - using _Val = typename remove_volatile<_Tp>::type; - - template - inline __attribute__((__always_inline__)) bool - __compare_exchange(_Tp& __val, _Val<_Tp>& __e, _Val<_Tp>& __i, - bool __is_weak, - memory_order __s, memory_order __f) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__f))) __builtin_unreachable(); } while (false); - - using _Vp = _Val<_Tp>; - - if constexpr (__atomic_impl::__maybe_has_padding<_Vp>()) - { - - - alignas(_Vp) unsigned char __buf[sizeof(_Vp)]; - _Vp* __exp = ::new((void*)__buf) _Vp(__e); - __atomic_impl::__clear_padding(*__exp); - if (__atomic_compare_exchange(std::__addressof(__val), __exp, - __atomic_impl::__clear_padding(__i), - __is_weak, int(__s), int(__f))) - return true; - __builtin_memcpy(std::__addressof(__e), __exp, sizeof(_Vp)); - return false; - } - else - return __atomic_compare_exchange(std::__addressof(__val), - std::__addressof(__e), - std::__addressof(__i), - __is_weak, int(__s), int(__f)); - } - } -# 2021 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 -} -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 2 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - struct _Sp_locker - { - _Sp_locker(const _Sp_locker&) = delete; - _Sp_locker& operator=(const _Sp_locker&) = delete; - - - explicit - _Sp_locker(const void*) noexcept; - _Sp_locker(const void*, const void*) noexcept; - ~_Sp_locker(); - - private: - unsigned char _M_key1; - unsigned char _M_key2; - - - - }; -# 100 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - inline bool - atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p) - { - - return __gthread_active_p() == 0; - - - - } - - template - inline bool - atomic_is_lock_free(const shared_ptr<_Tp>* __p) - { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); } -# 127 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - inline shared_ptr<_Tp> - atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) - { - _Sp_locker __lock{__p}; - return *__p; - } - - template - inline shared_ptr<_Tp> - atomic_load(const shared_ptr<_Tp>* __p) - { return std::atomic_load_explicit(__p, memory_order_seq_cst); } - - template - inline __shared_ptr<_Tp, _Lp> - atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order) - { - _Sp_locker __lock{__p}; - return *__p; - } - - template - inline __shared_ptr<_Tp, _Lp> - atomic_load(const __shared_ptr<_Tp, _Lp>* __p) - { return std::atomic_load_explicit(__p, memory_order_seq_cst); } -# 163 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - inline void - atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, - memory_order) - { - _Sp_locker __lock{__p}; - __p->swap(__r); - } - - template - inline void - atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) - { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } - - template - inline void - atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp> __r, - memory_order) - { - _Sp_locker __lock{__p}; - __p->swap(__r); - } - - template - inline void - atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) - { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } -# 200 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - inline shared_ptr<_Tp> - atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, - memory_order) - { - _Sp_locker __lock{__p}; - __p->swap(__r); - return __r; - } - - template - inline shared_ptr<_Tp> - atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) - { - return std::atomic_exchange_explicit(__p, std::move(__r), - memory_order_seq_cst); - } - - template - inline __shared_ptr<_Tp, _Lp> - atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp> __r, - memory_order) - { - _Sp_locker __lock{__p}; - __p->swap(__r); - return __r; - } - - template - inline __shared_ptr<_Tp, _Lp> - atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) - { - return std::atomic_exchange_explicit(__p, std::move(__r), - memory_order_seq_cst); - } -# 249 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - bool - atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, - shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w, - memory_order, - memory_order) - { - shared_ptr<_Tp> __x; - _Sp_locker __lock{__p, __v}; - owner_less> __less; - if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) - { - __x = std::move(*__p); - *__p = std::move(__w); - return true; - } - __x = std::move(*__v); - *__v = *__p; - return false; - } - - template - inline bool - atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w) - { - return std::atomic_compare_exchange_strong_explicit(__p, __v, - std::move(__w), memory_order_seq_cst, memory_order_seq_cst); - } - - template - inline bool - atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, - shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w, - memory_order __success, - memory_order __failure) - { - return std::atomic_compare_exchange_strong_explicit(__p, __v, - std::move(__w), __success, __failure); - } - - template - inline bool - atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w) - { - return std::atomic_compare_exchange_weak_explicit(__p, __v, - std::move(__w), memory_order_seq_cst, memory_order_seq_cst); - } - - template - bool - atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp>* __v, - __shared_ptr<_Tp, _Lp> __w, - memory_order, - memory_order) - { - __shared_ptr<_Tp, _Lp> __x; - _Sp_locker __lock{__p, __v}; - owner_less<__shared_ptr<_Tp, _Lp>> __less; - if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) - { - __x = std::move(*__p); - *__p = std::move(__w); - return true; - } - __x = std::move(*__v); - *__v = *__p; - return false; - } - - template - inline bool - atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp>* __v, - __shared_ptr<_Tp, _Lp> __w) - { - return std::atomic_compare_exchange_strong_explicit(__p, __v, - std::move(__w), memory_order_seq_cst, memory_order_seq_cst); - } - - template - inline bool - atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp>* __v, - __shared_ptr<_Tp, _Lp> __w, - memory_order __success, - memory_order __failure) - { - return std::atomic_compare_exchange_strong_explicit(__p, __v, - std::move(__w), __success, __failure); - } - - template - inline bool - atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp>* __v, - __shared_ptr<_Tp, _Lp> __w) - { - return std::atomic_compare_exchange_weak_explicit(__p, __v, - std::move(__w), memory_order_seq_cst, memory_order_seq_cst); - } -# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 -} -# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - template - struct auto_ptr_ref - { - _Tp1* _M_ptr; - - explicit - auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } - } __attribute__ ((__deprecated__)); - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 92 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - template - class auto_ptr - { - private: - _Tp* _M_ptr; - - public: - - typedef _Tp element_type; - - - - - - - - explicit - auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } -# 118 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } -# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - template - auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } -# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - auto_ptr& - operator=(auto_ptr& __a) throw() - { - reset(__a.release()); - return *this; - } -# 158 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - template - auto_ptr& - operator=(auto_ptr<_Tp1>& __a) throw() - { - reset(__a.release()); - return *this; - } -# 176 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - ~auto_ptr() { delete _M_ptr; } -# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - element_type& - operator*() const throw() - { - do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) __builtin_unreachable(); } while (false); - return *_M_ptr; - } - - - - - - - - element_type* - operator->() const throw() - { - do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) __builtin_unreachable(); } while (false); - return _M_ptr; - \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_bridge.cpp-eb644723.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_bridge.cpp-eb644723.cpp.tmp deleted file mode 100644 index 08aaa89..0000000 --- a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/core/__cpp_bridge.cpp-eb644723.cpp.tmp +++ /dev/null @@ -1,6401 +0,0 @@ -# 1 "src/core/bridge.cpp" -# 1 "" 1 -# 1 "" 3 -# 433 "" 3 -# 1 "" 1 -# 1 "" 2 -# 1 "src/core/bridge.cpp" 2 -# 13 "src/core/bridge.cpp" -# 1 "/usr/include/SDL2/SDL.h" 1 3 4 -# 32 "/usr/include/SDL2/SDL.h" 3 4 -# 1 "/usr/include/SDL2/SDL_main.h" 1 3 4 -# 25 "/usr/include/SDL2/SDL_main.h" 3 4 -# 1 "/usr/include/SDL2/SDL_stdinc.h" 1 3 4 -# 31 "/usr/include/SDL2/SDL_stdinc.h" 3 4 -# 1 "/usr/include/SDL2/SDL_config.h" 1 3 4 -# 32 "/usr/include/SDL2/SDL_config.h" 3 4 -# 1 "/usr/include/SDL2/SDL_platform.h" 1 3 4 -# 229 "/usr/include/SDL2/SDL_platform.h" 3 4 -# 1 "/usr/include/SDL2/begin_code.h" 1 3 4 -# 230 "/usr/include/SDL2/SDL_platform.h" 2 3 4 - - -extern "C" { -# 251 "/usr/include/SDL2/SDL_platform.h" 3 4 -extern __attribute__ ((visibility("default"))) const char * SDL_GetPlatform (void); - - - -} - -# 1 "/usr/include/SDL2/close_code.h" 1 3 4 -# 258 "/usr/include/SDL2/SDL_platform.h" 2 3 4 -# 33 "/usr/include/SDL2/SDL_config.h" 2 3 4 -# 32 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - -# 1 "/usr/include/sys/types.h" 1 3 4 -# 25 "/usr/include/sys/types.h" 3 4 -# 1 "/usr/include/features.h" 1 3 4 -# 394 "/usr/include/features.h" 3 4 -# 1 "/usr/include/features-time64.h" 1 3 4 -# 20 "/usr/include/features-time64.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 21 "/usr/include/features-time64.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 22 "/usr/include/features-time64.h" 2 3 4 -# 395 "/usr/include/features.h" 2 3 4 -# 481 "/usr/include/features.h" 3 4 -# 1 "/usr/include/stdc-predef.h" 1 3 4 -# 482 "/usr/include/features.h" 2 3 4 -# 503 "/usr/include/features.h" 3 4 -# 1 "/usr/include/sys/cdefs.h" 1 3 4 -# 576 "/usr/include/sys/cdefs.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 577 "/usr/include/sys/cdefs.h" 2 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 578 "/usr/include/sys/cdefs.h" 2 3 4 -# 504 "/usr/include/features.h" 2 3 4 -# 527 "/usr/include/features.h" 3 4 -# 1 "/usr/include/gnu/stubs.h" 1 3 4 -# 10 "/usr/include/gnu/stubs.h" 3 4 -# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 -# 11 "/usr/include/gnu/stubs.h" 2 3 4 -# 528 "/usr/include/features.h" 2 3 4 -# 26 "/usr/include/sys/types.h" 2 3 4 - -extern "C" { - -# 1 "/usr/include/bits/types.h" 1 3 4 -# 27 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 28 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 29 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned char __u_char; -typedef unsigned short int __u_short; -typedef unsigned int __u_int; -typedef unsigned long int __u_long; - - -typedef signed char __int8_t; -typedef unsigned char __uint8_t; -typedef signed short int __int16_t; -typedef unsigned short int __uint16_t; -typedef signed int __int32_t; -typedef unsigned int __uint32_t; - -typedef signed long int __int64_t; -typedef unsigned long int __uint64_t; - - - - - - -typedef __int8_t __int_least8_t; -typedef __uint8_t __uint_least8_t; -typedef __int16_t __int_least16_t; -typedef __uint16_t __uint_least16_t; -typedef __int32_t __int_least32_t; -typedef __uint32_t __uint_least32_t; -typedef __int64_t __int_least64_t; -typedef __uint64_t __uint_least64_t; - - - -typedef long int __quad_t; -typedef unsigned long int __u_quad_t; - - - - - - - -typedef long int __intmax_t; -typedef unsigned long int __uintmax_t; -# 141 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/typesizes.h" 1 3 4 -# 142 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/time64.h" 1 3 4 -# 143 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned long int __dev_t; -typedef unsigned int __uid_t; -typedef unsigned int __gid_t; -typedef unsigned long int __ino_t; -typedef unsigned long int __ino64_t; -typedef unsigned int __mode_t; -typedef unsigned long int __nlink_t; -typedef long int __off_t; -typedef long int __off64_t; -typedef int __pid_t; -typedef struct { int __val[2]; } __fsid_t; -typedef long int __clock_t; -typedef unsigned long int __rlim_t; -typedef unsigned long int __rlim64_t; -typedef unsigned int __id_t; -typedef long int __time_t; -typedef unsigned int __useconds_t; -typedef long int __suseconds_t; -typedef long int __suseconds64_t; - -typedef int __daddr_t; -typedef int __key_t; - - -typedef int __clockid_t; - - -typedef void * __timer_t; - - -typedef long int __blksize_t; - - - - -typedef long int __blkcnt_t; -typedef long int __blkcnt64_t; - - -typedef unsigned long int __fsblkcnt_t; -typedef unsigned long int __fsblkcnt64_t; - - -typedef unsigned long int __fsfilcnt_t; -typedef unsigned long int __fsfilcnt64_t; - - -typedef long int __fsword_t; - -typedef long int __ssize_t; - - -typedef long int __syscall_slong_t; - -typedef unsigned long int __syscall_ulong_t; - - - -typedef __off64_t __loff_t; -typedef char *__caddr_t; - - -typedef long int __intptr_t; - - -typedef unsigned int __socklen_t; - - - - -typedef int __sig_atomic_t; -# 30 "/usr/include/sys/types.h" 2 3 4 - - - -typedef __u_char u_char; -typedef __u_short u_short; -typedef __u_int u_int; -typedef __u_long u_long; -typedef __quad_t quad_t; -typedef __u_quad_t u_quad_t; -typedef __fsid_t fsid_t; - - -typedef __loff_t loff_t; - - - - -typedef __ino_t ino_t; - - - - - - -typedef __ino64_t ino64_t; - - - - -typedef __dev_t dev_t; - - - - -typedef __gid_t gid_t; - - - - -typedef __mode_t mode_t; - - - - -typedef __nlink_t nlink_t; - - - - -typedef __uid_t uid_t; - - - - - -typedef __off_t off_t; - - - - - - -typedef __off64_t off64_t; - - - - -typedef __pid_t pid_t; - - - - - -typedef __id_t id_t; - - - - -typedef __ssize_t ssize_t; - - - - - -typedef __daddr_t daddr_t; -typedef __caddr_t caddr_t; - - - - - -typedef __key_t key_t; - - - - -# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 - - - - - - -typedef __clock_t clock_t; -# 127 "/usr/include/sys/types.h" 2 3 4 - -# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 - - - - - - -typedef __clockid_t clockid_t; -# 129 "/usr/include/sys/types.h" 2 3 4 -# 1 "/usr/include/bits/types/time_t.h" 1 3 4 -# 10 "/usr/include/bits/types/time_t.h" 3 4 -typedef __time_t time_t; -# 130 "/usr/include/sys/types.h" 2 3 4 -# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 - - - - - - -typedef __timer_t timer_t; -# 131 "/usr/include/sys/types.h" 2 3 4 - - - -typedef __useconds_t useconds_t; - - - -typedef __suseconds_t suseconds_t; - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 -typedef long unsigned int size_t; -# 145 "/usr/include/sys/types.h" 2 3 4 - - - -typedef unsigned long int ulong; -typedef unsigned short int ushort; -typedef unsigned int uint; - - - - -# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-intn.h" 3 4 -typedef __int8_t int8_t; -typedef __int16_t int16_t; -typedef __int32_t int32_t; -typedef __int64_t int64_t; -# 156 "/usr/include/sys/types.h" 2 3 4 - - -typedef __uint8_t u_int8_t; -typedef __uint16_t u_int16_t; -typedef __uint32_t u_int32_t; -typedef __uint64_t u_int64_t; - - -typedef int register_t __attribute__ ((__mode__ (__word__))); -# 176 "/usr/include/sys/types.h" 3 4 -# 1 "/usr/include/endian.h" 1 3 4 -# 24 "/usr/include/endian.h" 3 4 -# 1 "/usr/include/bits/endian.h" 1 3 4 -# 35 "/usr/include/bits/endian.h" 3 4 -# 1 "/usr/include/bits/endianness.h" 1 3 4 -# 36 "/usr/include/bits/endian.h" 2 3 4 -# 25 "/usr/include/endian.h" 2 3 4 -# 35 "/usr/include/endian.h" 3 4 -# 1 "/usr/include/bits/byteswap.h" 1 3 4 -# 33 "/usr/include/bits/byteswap.h" 3 4 -static __inline __uint16_t -__bswap_16 (__uint16_t __bsx) -{ - - - - return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8))); - -} - - - - - - -static __inline __uint32_t -__bswap_32 (__uint32_t __bsx) -{ - - - - return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); - -} -# 69 "/usr/include/bits/byteswap.h" 3 4 -__extension__ static __inline __uint64_t -__bswap_64 (__uint64_t __bsx) -{ - - - - return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56)); - -} -# 36 "/usr/include/endian.h" 2 3 4 -# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 -# 32 "/usr/include/bits/uintn-identity.h" 3 4 -static __inline __uint16_t -__uint16_identity (__uint16_t __x) -{ - return __x; -} - -static __inline __uint32_t -__uint32_identity (__uint32_t __x) -{ - return __x; -} - -static __inline __uint64_t -__uint64_identity (__uint64_t __x) -{ - return __x; -} -# 37 "/usr/include/endian.h" 2 3 4 -# 177 "/usr/include/sys/types.h" 2 3 4 - - -# 1 "/usr/include/sys/select.h" 1 3 4 -# 30 "/usr/include/sys/select.h" 3 4 -# 1 "/usr/include/bits/select.h" 1 3 4 -# 31 "/usr/include/sys/select.h" 2 3 4 - - -# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 - - - -# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 - - - - -typedef struct -{ - unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; -} __sigset_t; -# 5 "/usr/include/bits/types/sigset_t.h" 2 3 4 - - -typedef __sigset_t sigset_t; -# 34 "/usr/include/sys/select.h" 2 3 4 - - - -# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 - - - - - - - -struct timeval -{ - - - - - __time_t tv_sec; - __suseconds_t tv_usec; - -}; -# 38 "/usr/include/sys/select.h" 2 3 4 - -# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 -# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 -struct timespec -{ - - - - __time_t tv_sec; - - - - - __syscall_slong_t tv_nsec; -# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 -}; -# 40 "/usr/include/sys/select.h" 2 3 4 -# 49 "/usr/include/sys/select.h" 3 4 -typedef long int __fd_mask; -# 59 "/usr/include/sys/select.h" 3 4 -typedef struct - { - - - - __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; - - - - - - } fd_set; - - - - - - -typedef __fd_mask fd_mask; -# 91 "/usr/include/sys/select.h" 3 4 -extern "C" { -# 102 "/usr/include/sys/select.h" 3 4 -extern int select (int __nfds, fd_set *__restrict __readfds, - fd_set *__restrict __writefds, - fd_set *__restrict __exceptfds, - struct timeval *__restrict __timeout); -# 127 "/usr/include/sys/select.h" 3 4 -extern int pselect (int __nfds, fd_set *__restrict __readfds, - fd_set *__restrict __writefds, - fd_set *__restrict __exceptfds, - const struct timespec *__restrict __timeout, - const __sigset_t *__restrict __sigmask); -# 153 "/usr/include/sys/select.h" 3 4 -} -# 180 "/usr/include/sys/types.h" 2 3 4 - - - - - -typedef __blksize_t blksize_t; - - - - - - -typedef __blkcnt_t blkcnt_t; - - - -typedef __fsblkcnt_t fsblkcnt_t; - - - -typedef __fsfilcnt_t fsfilcnt_t; -# 219 "/usr/include/sys/types.h" 3 4 -typedef __blkcnt64_t blkcnt64_t; -typedef __fsblkcnt64_t fsblkcnt64_t; -typedef __fsfilcnt64_t fsfilcnt64_t; - - - - - -# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 -# 23 "/usr/include/bits/pthreadtypes.h" 3 4 -# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 -# 44 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 -# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 -# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 - -# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 -# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 -typedef union -{ - __extension__ unsigned long long int __value64; - struct - { - unsigned int __low; - unsigned int __high; - } __value32; -} __atomic_wide_counter; -# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -typedef struct __pthread_internal_list -{ - struct __pthread_internal_list *__prev; - struct __pthread_internal_list *__next; -} __pthread_list_t; - -typedef struct __pthread_internal_slist -{ - struct __pthread_internal_slist *__next; -} __pthread_slist_t; -# 76 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 -# 22 "/usr/include/bits/struct_mutex.h" 3 4 -struct __pthread_mutex_s -{ - int __lock; - unsigned int __count; - int __owner; - - unsigned int __nusers; - - - - int __kind; - - short __spins; - short __elision; - __pthread_list_t __list; -# 53 "/usr/include/bits/struct_mutex.h" 3 4 -}; -# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 -# 89 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 -# 23 "/usr/include/bits/struct_rwlock.h" 3 4 -struct __pthread_rwlock_arch_t -{ - unsigned int __readers; - unsigned int __writers; - unsigned int __wrphase_futex; - unsigned int __writers_futex; - unsigned int __pad3; - unsigned int __pad4; - - int __cur_writer; - int __shared; - signed char __rwelision; - - - - - unsigned char __pad1[7]; - - - unsigned long int __pad2; - - - unsigned int __flags; -# 55 "/usr/include/bits/struct_rwlock.h" 3 4 -}; -# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -struct __pthread_cond_s -{ - __atomic_wide_counter __wseq; - __atomic_wide_counter __g1_start; - unsigned int __g_refs[2] ; - unsigned int __g_size[2]; - unsigned int __g1_orig_size; - unsigned int __wrefs; - unsigned int __g_signals[2]; -}; - -typedef unsigned int __tss_t; -typedef unsigned long int __thrd_t; - -typedef struct -{ - int __data ; -} __once_flag; -# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 - - - -typedef unsigned long int pthread_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_mutexattr_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_condattr_t; - - - -typedef unsigned int pthread_key_t; - - - -typedef int pthread_once_t; - - -union pthread_attr_t -{ - char __size[56]; - long int __align; -}; - -typedef union pthread_attr_t pthread_attr_t; - - - - -typedef union -{ - struct __pthread_mutex_s __data; - char __size[40]; - long int __align; -} pthread_mutex_t; - - -typedef union -{ - struct __pthread_cond_s __data; - char __size[48]; - __extension__ long long int __align; -} pthread_cond_t; - - - - - -typedef union -{ - struct __pthread_rwlock_arch_t __data; - char __size[56]; - long int __align; -} pthread_rwlock_t; - -typedef union -{ - char __size[8]; - long int __align; -} pthread_rwlockattr_t; - - - - - -typedef volatile int pthread_spinlock_t; - - - - -typedef union -{ - char __size[32]; - long int __align; -} pthread_barrier_t; - -typedef union -{ - char __size[4]; - int __align; -} pthread_barrierattr_t; -# 228 "/usr/include/sys/types.h" 2 3 4 - - -} -# 35 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - -# 1 "/usr/include/stdio.h" 1 3 4 -# 27 "/usr/include/stdio.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/stdio.h" 2 3 4 - -extern "C" { - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 34 "/usr/include/stdio.h" 2 3 4 - - -# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 -# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 -typedef __builtin_va_list __gnuc_va_list; -# 37 "/usr/include/stdio.h" 2 3 4 - - -# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4 - - - - -# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 -# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 -typedef struct -{ - int __count; - union - { - unsigned int __wch; - char __wchb[4]; - } __value; -} __mbstate_t; -# 6 "/usr/include/bits/types/__fpos_t.h" 2 3 4 - - - - -typedef struct _G_fpos_t -{ - __off_t __pos; - __mbstate_t __state; -} __fpos_t; -# 40 "/usr/include/stdio.h" 2 3 4 -# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4 -# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4 -typedef struct _G_fpos64_t -{ - __off64_t __pos; - __mbstate_t __state; -} __fpos64_t; -# 41 "/usr/include/stdio.h" 2 3 4 -# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 - - - -struct _IO_FILE; -typedef struct _IO_FILE __FILE; -# 42 "/usr/include/stdio.h" 2 3 4 -# 1 "/usr/include/bits/types/FILE.h" 1 3 4 - - - -struct _IO_FILE; - - -typedef struct _IO_FILE FILE; -# 43 "/usr/include/stdio.h" 2 3 4 -# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4 -# 35 "/usr/include/bits/types/struct_FILE.h" 3 4 -struct _IO_FILE; -struct _IO_marker; -struct _IO_codecvt; -struct _IO_wide_data; - - - - -typedef void _IO_lock_t; - - - - - -struct _IO_FILE -{ - int _flags; - - - char *_IO_read_ptr; - char *_IO_read_end; - char *_IO_read_base; - char *_IO_write_base; - char *_IO_write_ptr; - char *_IO_write_end; - char *_IO_buf_base; - char *_IO_buf_end; - - - char *_IO_save_base; - char *_IO_backup_base; - char *_IO_save_end; - - struct _IO_marker *_markers; - - struct _IO_FILE *_chain; - - int _fileno; - int _flags2; - __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/bits/types/cookie_io_functions_t.h" 1 3 4 -# 27 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4 -typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, - size_t __nbytes); - - - - - - - -typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, - size_t __nbytes); - - - - - - - -typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); - - -typedef int cookie_close_function_t (void *__cookie); - - - - - - -typedef struct _IO_cookie_io_functions_t -{ - cookie_read_function_t *read; - cookie_write_function_t *write; - cookie_seek_function_t *seek; - cookie_close_function_t *close; -} cookie_io_functions_t; -# 47 "/usr/include/stdio.h" 2 3 4 - - - - - -typedef __gnuc_va_list va_list; -# 84 "/usr/include/stdio.h" 3 4 -typedef __fpos_t fpos_t; - - - - -typedef __fpos64_t fpos64_t; -# 128 "/usr/include/stdio.h" 3 4 -# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 -# 129 "/usr/include/stdio.h" 2 3 4 -# 148 "/usr/include/stdio.h" 3 4 -extern FILE *stdin; -extern FILE *stdout; -extern FILE *stderr; - - - - - - -extern int remove (const char *__filename) noexcept (true); - -extern int rename (const char *__old, const char *__new) noexcept (true); - - - -extern int renameat (int __oldfd, const char *__old, int __newfd, - const char *__new) noexcept (true); -# 175 "/usr/include/stdio.h" 3 4 -extern int renameat2 (int __oldfd, const char *__old, int __newfd, - const char *__new, unsigned int __flags) noexcept (true); - - - - - - -extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); -# 193 "/usr/include/stdio.h" 3 4 -extern FILE *tmpfile (void) - __attribute__ ((__malloc__)) ; -# 205 "/usr/include/stdio.h" 3 4 -extern FILE *tmpfile64 (void) - __attribute__ ((__malloc__)) ; - - - -extern char *tmpnam (char[20]) noexcept (true) ; - - - - -extern char *tmpnam_r (char __s[20]) noexcept (true) ; -# 227 "/usr/include/stdio.h" 3 4 -extern char *tempnam (const char *__dir, const char *__pfx) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - - - -extern int fflush (FILE *__stream); -# 244 "/usr/include/stdio.h" 3 4 -extern int fflush_unlocked (FILE *__stream); -# 254 "/usr/include/stdio.h" 3 4 -extern int fcloseall (void); -# 263 "/usr/include/stdio.h" 3 4 -extern FILE *fopen (const char *__restrict __filename, - const char *__restrict __modes) - __attribute__ ((__malloc__)) ; - - - - -extern FILE *freopen (const char *__restrict __filename, - const char *__restrict __modes, - FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); -# 288 "/usr/include/stdio.h" 3 4 -extern FILE *fopen64 (const char *__restrict __filename, - const char *__restrict __modes) - __attribute__ ((__malloc__)) ; -extern FILE *freopen64 (const char *__restrict __filename, - const char *__restrict __modes, - FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); - - - - -extern FILE *fdopen (int __fd, const char *__modes) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern FILE *fopencookie (void *__restrict __magic_cookie, - const char *__restrict __modes, - cookie_io_functions_t __io_funcs) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - -extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - -extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) - __attribute__ ((__malloc__)) ; -# 333 "/usr/include/stdio.h" 3 4 -extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true); - - - -extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, - int __modes, size_t __n) noexcept (true); - - - - -extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, - size_t __size) noexcept (true); - - -extern void setlinebuf (FILE *__stream) noexcept (true); - - - - - - - -extern int fprintf (FILE *__restrict __stream, - const char *__restrict __format, ...); - - - - -extern int printf (const char *__restrict __format, ...); - -extern int sprintf (char *__restrict __s, - const char *__restrict __format, ...) noexcept (true); - - - - - -extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, - __gnuc_va_list __arg); - - - - -extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); - -extern int vsprintf (char *__restrict __s, const char *__restrict __format, - __gnuc_va_list __arg) noexcept (true); - - - -extern int snprintf (char *__restrict __s, size_t __maxlen, - const char *__restrict __format, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); - -extern int vsnprintf (char *__restrict __s, size_t __maxlen, - const char *__restrict __format, __gnuc_va_list __arg) - noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); - - - - - -extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, - __gnuc_va_list __arg) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ; -extern int __asprintf (char **__restrict __ptr, - const char *__restrict __fmt, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; -extern int asprintf (char **__restrict __ptr, - const char *__restrict __fmt, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; - - - - -extern int vdprintf (int __fd, const char *__restrict __fmt, - __gnuc_va_list __arg) - __attribute__ ((__format__ (__printf__, 2, 0))); -extern int dprintf (int __fd, const char *__restrict __fmt, ...) - __attribute__ ((__format__ (__printf__, 2, 3))); - - - - - - - -extern int fscanf (FILE *__restrict __stream, - const char *__restrict __format, ...) ; - - - - -extern int scanf (const char *__restrict __format, ...) ; - -extern int sscanf (const char *__restrict __s, - const char *__restrict __format, ...) noexcept (true); - - - - - -# 1 "/usr/include/bits/floatn.h" 1 3 4 -# 119 "/usr/include/bits/floatn.h" 3 4 -# 1 "/usr/include/bits/floatn-common.h" 1 3 4 -# 24 "/usr/include/bits/floatn-common.h" 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 25 "/usr/include/bits/floatn-common.h" 2 3 4 -# 214 "/usr/include/bits/floatn-common.h" 3 4 -typedef float _Float32; -# 251 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float64; -# 268 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float32x; -# 285 "/usr/include/bits/floatn-common.h" 3 4 -typedef long double _Float64x; -# 120 "/usr/include/bits/floatn.h" 2 3 4 -# 436 "/usr/include/stdio.h" 2 3 4 - - - - -extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") ; - - -extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") ; - -extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf"); -# 486 "/usr/include/stdio.h" 3 4 -extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, - __gnuc_va_list __arg) - __attribute__ ((__format__ (__scanf__, 2, 0))) ; - - - - - -extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) - __attribute__ ((__format__ (__scanf__, 1, 0))) ; - - -extern int vsscanf (const char *__restrict __s, - const char *__restrict __format, __gnuc_va_list __arg) - noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0))); - - - - - - -extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf") - - - - __attribute__ ((__format__ (__scanf__, 2, 0))) ; -extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf") - - __attribute__ ((__format__ (__scanf__, 1, 0))) ; -extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf") - - - - __attribute__ ((__format__ (__scanf__, 2, 0))); -# 571 "/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); -# 596 "/usr/include/stdio.h" 3 4 -extern int fgetc_unlocked (FILE *__stream); -# 607 "/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); -# 623 "/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) - ; -# 673 "/usr/include/stdio.h" 3 4 -extern char *fgets_unlocked (char *__restrict __s, int __n, - FILE *__restrict __stream) - ; -# 690 "/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); -# 749 "/usr/include/stdio.h" 3 4 -extern int fputs_unlocked (const char *__restrict __s, - FILE *__restrict __stream); -# 760 "/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); -# 794 "/usr/include/stdio.h" 3 4 -extern int fseeko (FILE *__stream, __off_t __off, int __whence); - - - - -extern __off_t ftello (FILE *__stream) ; -# 818 "/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); -# 837 "/usr/include/stdio.h" 3 4 -extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); -extern __off64_t ftello64 (FILE *__stream) ; -extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); -extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); - - - -extern void clearerr (FILE *__stream) noexcept (true); - -extern int feof (FILE *__stream) noexcept (true) ; - -extern int ferror (FILE *__stream) noexcept (true) ; - - - -extern void clearerr_unlocked (FILE *__stream) noexcept (true); -extern int feof_unlocked (FILE *__stream) noexcept (true) ; -extern int ferror_unlocked (FILE *__stream) noexcept (true) ; - - - - - - - -extern void perror (const char *__s) __attribute__ ((__cold__)); - - - - -extern int fileno (FILE *__stream) noexcept (true) ; - - - - -extern int fileno_unlocked (FILE *__stream) noexcept (true) ; -# 881 "/usr/include/stdio.h" 3 4 -extern int pclose (FILE *__stream); - - - - - -extern FILE *popen (const char *__command, const char *__modes) - __attribute__ ((__malloc__)) ; - - - - - - -extern char *ctermid (char *__s) noexcept (true) - ; - - - - - -extern char *cuserid (char *__s) - ; - - - - -struct obstack; - - -extern int obstack_printf (struct obstack *__restrict __obstack, - const char *__restrict __format, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); -extern int obstack_vprintf (struct obstack *__restrict __obstack, - const char *__restrict __format, - __gnuc_va_list __args) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); - - - - - - - -extern void flockfile (FILE *__stream) noexcept (true); - - - -extern int ftrylockfile (FILE *__stream) noexcept (true) ; - - -extern void funlockfile (FILE *__stream) noexcept (true); -# 943 "/usr/include/stdio.h" 3 4 -extern int __uflow (FILE *); -extern int __overflow (FILE *, int); -# 960 "/usr/include/stdio.h" 3 4 -# 1 "/usr/include/bits/stdio.h" 1 3 4 -# 38 "/usr/include/bits/stdio.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) int -vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) -{ - return vfprintf (stdout, __fmt, __arg); -} - - - -extern __inline __attribute__ ((__gnu_inline__)) int -getchar (void) -{ - return getc (stdin); -} - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -fgetc_unlocked (FILE *__fp) -{ - return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -getc_unlocked (FILE *__fp) -{ - return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); -} - - -extern __inline __attribute__ ((__gnu_inline__)) int -getchar_unlocked (void) -{ - return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++); -} - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -putchar (int __c) -{ - return putc (__c, stdout); -} - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -fputc_unlocked (int __c, FILE *__stream) -{ - return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -putc_unlocked (int __c, FILE *__stream) -{ - return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); -} - - -extern __inline __attribute__ ((__gnu_inline__)) int -putchar_unlocked (int __c) -{ - return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c))); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) __ssize_t -getline (char **__lineptr, size_t *__n, FILE *__stream) -{ - return __getdelim (__lineptr, __n, '\n', __stream); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) int - feof_unlocked (FILE *__stream) noexcept (true) -{ - return (((__stream)->_flags & 0x0010) != 0); -} - - -extern __inline __attribute__ ((__gnu_inline__)) int - ferror_unlocked (FILE *__stream) noexcept (true) -{ - return (((__stream)->_flags & 0x0020) != 0); -} -# 961 "/usr/include/stdio.h" 2 3 4 - - - - - - -} -# 38 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 1 3 4 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 3 4 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 1 3 4 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 -# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - typedef long unsigned int size_t; - typedef long int ptrdiff_t; - - - typedef decltype(nullptr) nullptr_t; - - -#pragma GCC visibility push(default) - - - extern "C++" __attribute__ ((__noreturn__, __always_inline__)) - inline void __terminate() noexcept - { - void terminate() noexcept __attribute__ ((__noreturn__)); - terminate(); - } -#pragma GCC visibility pop -} -# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -namespace __gnu_cxx -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ -#pragma GCC visibility push(default) - - - - - constexpr inline bool - __is_constant_evaluated() noexcept - { - - - - - - return __builtin_is_constant_evaluated(); - - - - } -#pragma GCC visibility pop -} -# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 -# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 -# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 -# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 -# 1 "/usr/include/stdlib.h" 1 3 4 -# 26 "/usr/include/stdlib.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/stdlib.h" 2 3 4 - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 33 "/usr/include/stdlib.h" 2 3 4 - -extern "C" { - - - - - -# 1 "/usr/include/bits/waitflags.h" 1 3 4 -# 41 "/usr/include/stdlib.h" 2 3 4 -# 1 "/usr/include/bits/waitstatus.h" 1 3 4 -# 42 "/usr/include/stdlib.h" 2 3 4 -# 59 "/usr/include/stdlib.h" 3 4 -typedef struct - { - int quot; - int rem; - } div_t; - - - -typedef struct - { - long int quot; - long int rem; - } ldiv_t; - - - - - -__extension__ typedef struct - { - long long int quot; - long long int rem; - } lldiv_t; -# 98 "/usr/include/stdlib.h" 3 4 -extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; - - - -extern double atof (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - -extern int atoi (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - -extern long int atol (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - -__extension__ extern long long int atoll (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - -extern double strtod (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern float strtof (const char *__restrict __nptr, - char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); - -extern long double strtold (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 141 "/usr/include/stdlib.h" 3 4 -extern _Float32 strtof32 (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern _Float64 strtof64 (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 159 "/usr/include/stdlib.h" 3 4 -extern _Float32x strtof32x (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern _Float64x strtof64x (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 177 "/usr/include/stdlib.h" 3 4 -extern long int strtol (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -extern unsigned long int strtoul (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -__extension__ -extern long long int strtoq (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -__extension__ -extern unsigned long long int strtouq (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -__extension__ -extern long long int strtoll (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -__extension__ -extern unsigned long long int strtoull (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") - - - __attribute__ ((__nonnull__ (1))); -extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") - - - - __attribute__ ((__nonnull__ (1))); - -__extension__ -extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") - - - __attribute__ ((__nonnull__ (1))); -__extension__ -extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") - - - - __attribute__ ((__nonnull__ (1))); - -__extension__ -extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") - - - __attribute__ ((__nonnull__ (1))); -__extension__ -extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") - - - - __attribute__ ((__nonnull__ (1))); -# 278 "/usr/include/stdlib.h" 3 4 -extern int strfromd (char *__dest, size_t __size, const char *__format, - double __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - -extern int strfromf (char *__dest, size_t __size, const char *__format, - float __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - -extern int strfroml (char *__dest, size_t __size, const char *__format, - long double __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 298 "/usr/include/stdlib.h" 3 4 -extern int strfromf32 (char *__dest, size_t __size, const char * __format, - _Float32 __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - - -extern int strfromf64 (char *__dest, size_t __size, const char * __format, - _Float64 __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 316 "/usr/include/stdlib.h" 3 4 -extern int strfromf32x (char *__dest, size_t __size, const char * __format, - _Float32x __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - - -extern int strfromf64x (char *__dest, size_t __size, const char * __format, - _Float64x __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 338 "/usr/include/stdlib.h" 3 4 -# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 -# 22 "/usr/include/bits/types/locale_t.h" 3 4 -# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 -# 27 "/usr/include/bits/types/__locale_t.h" 3 4 -struct __locale_struct -{ - - struct __locale_data *__locales[13]; - - - const unsigned short int *__ctype_b; - const int *__ctype_tolower; - const int *__ctype_toupper; - - - const char *__names[13]; -}; - -typedef struct __locale_struct *__locale_t; -# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 - -typedef __locale_t locale_t; -# 339 "/usr/include/stdlib.h" 2 3 4 - -extern long int strtol_l (const char *__restrict __nptr, - char **__restrict __endptr, int __base, - locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -extern unsigned long int strtoul_l (const char *__restrict __nptr, - char **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -__extension__ -extern long long int strtoll_l (const char *__restrict __nptr, - char **__restrict __endptr, int __base, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -__extension__ -extern unsigned long long int strtoull_l (const char *__restrict __nptr, - char **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - - - - - -extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") - - - - __attribute__ ((__nonnull__ (1, 4))); -extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -__extension__ -extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -__extension__ -extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -# 415 "/usr/include/stdlib.h" 3 4 -extern double strtod_l (const char *__restrict __nptr, - char **__restrict __endptr, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - -extern float strtof_l (const char *__restrict __nptr, - char **__restrict __endptr, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - -extern long double strtold_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 436 "/usr/include/stdlib.h" 3 4 -extern _Float32 strtof32_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern _Float64 strtof64_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 457 "/usr/include/stdlib.h" 3 4 -extern _Float32x strtof32x_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern _Float64x strtof64x_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 480 "/usr/include/stdlib.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) int - atoi (const char *__nptr) noexcept (true) -{ - return (int) strtol (__nptr, (char **) __null, 10); -} -extern __inline __attribute__ ((__gnu_inline__)) long int - atol (const char *__nptr) noexcept (true) -{ - return strtol (__nptr, (char **) __null, 10); -} - - -__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int - atoll (const char *__nptr) noexcept (true) -{ - return strtoll (__nptr, (char **) __null, 10); -} -# 505 "/usr/include/stdlib.h" 3 4 -extern char *l64a (long int __n) noexcept (true) ; - - -extern long int a64l (const char *__s) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; -# 521 "/usr/include/stdlib.h" 3 4 -extern long int random (void) noexcept (true); - - -extern void srandom (unsigned int __seed) noexcept (true); - - - - - -extern char *initstate (unsigned int __seed, char *__statebuf, - size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - -extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - - -struct random_data - { - int32_t *fptr; - int32_t *rptr; - int32_t *state; - int rand_type; - int rand_deg; - int rand_sep; - int32_t *end_ptr; - }; - -extern int random_r (struct random_data *__restrict __buf, - int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern int srandom_r (unsigned int __seed, struct random_data *__buf) - noexcept (true) __attribute__ ((__nonnull__ (2))); - -extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, - size_t __statelen, - struct random_data *__restrict __buf) - noexcept (true) __attribute__ ((__nonnull__ (2, 4))); - -extern int setstate_r (char *__restrict __statebuf, - struct random_data *__restrict __buf) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - - -extern int rand (void) noexcept (true); - -extern void srand (unsigned int __seed) noexcept (true); - - - -extern int rand_r (unsigned int *__seed) noexcept (true); - - - - - - - -extern double drand48 (void) noexcept (true); -extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern long int lrand48 (void) noexcept (true); -extern long int nrand48 (unsigned short int __xsubi[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern long int mrand48 (void) noexcept (true); -extern long int jrand48 (unsigned short int __xsubi[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern void srand48 (long int __seedval) noexcept (true); -extern unsigned short int *seed48 (unsigned short int __seed16v[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); -extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -struct drand48_data - { - unsigned short int __x[3]; - unsigned short int __old_x[3]; - unsigned short int __c; - unsigned short int __init; - __extension__ unsigned long long int __a; - - }; - - -extern int drand48_r (struct drand48_data *__restrict __buffer, - double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int erand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int lrand48_r (struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int nrand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int mrand48_r (struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int jrand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int srand48_r (long int __seedval, struct drand48_data *__buffer) - noexcept (true) __attribute__ ((__nonnull__ (2))); - -extern int seed48_r (unsigned short int __seed16v[3], - struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern int lcong48_r (unsigned short int __param[7], - struct drand48_data *__buffer) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern __uint32_t arc4random (void) - noexcept (true) ; - - -extern void arc4random_buf (void *__buf, size_t __size) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) - noexcept (true) ; - - - - -extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) - ; - -extern void *calloc (size_t __nmemb, size_t __size) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - - - -extern void *realloc (void *__ptr, size_t __size) - noexcept (true) __attribute__ ((__warn_unused_result__)) ; - - -extern void free (void *__ptr) noexcept (true); - - - - - - - -extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) - noexcept (true) __attribute__ ((__warn_unused_result__)) - - ; - - -extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) - noexcept (true) ; - - - -# 1 "/usr/include/alloca.h" 1 3 4 -# 24 "/usr/include/alloca.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 25 "/usr/include/alloca.h" 2 3 4 - -extern "C" { - - - - - -extern void *alloca (size_t __size) noexcept (true); - - - - - -} -# 707 "/usr/include/stdlib.h" 2 3 4 - - - - - -extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) - ; - - - - -extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) - noexcept (true) __attribute__ ((__nonnull__ (1))) ; - - - - -extern void *aligned_alloc (size_t __alignment, size_t __size) - noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) - ; - - - -extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)); - - - -extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern "C++" int at_quick_exit (void (*__func) (void)) - noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); -# 749 "/usr/include/stdlib.h" 3 4 -extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); - - - - - -extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); - - - - - -extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); - - - - -extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; - - - - -extern char *secure_getenv (const char *__name) - noexcept (true) __attribute__ ((__nonnull__ (1))) ; - - - - - - -extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern int setenv (const char *__name, const char *__value, int __replace) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - -extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int clearenv (void) noexcept (true); -# 814 "/usr/include/stdlib.h" 3 4 -extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); -# 827 "/usr/include/stdlib.h" 3 4 -extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; -# 837 "/usr/include/stdlib.h" 3 4 -extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; -# 849 "/usr/include/stdlib.h" 3 4 -extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; -# 859 "/usr/include/stdlib.h" 3 4 -extern int mkstemps64 (char *__template, int __suffixlen) - __attribute__ ((__nonnull__ (1))) ; -# 870 "/usr/include/stdlib.h" 3 4 -extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; -# 881 "/usr/include/stdlib.h" 3 4 -extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; -# 891 "/usr/include/stdlib.h" 3 4 -extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; -# 901 "/usr/include/stdlib.h" 3 4 -extern int mkostemps (char *__template, int __suffixlen, int __flags) - __attribute__ ((__nonnull__ (1))) ; -# 913 "/usr/include/stdlib.h" 3 4 -extern int mkostemps64 (char *__template, int __suffixlen, int __flags) - __attribute__ ((__nonnull__ (1))) ; -# 923 "/usr/include/stdlib.h" 3 4 -extern int system (const char *__command) ; - - - - - -extern char *canonicalize_file_name (const char *__name) - noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) - ; -# 940 "/usr/include/stdlib.h" 3 4 -extern char *realpath (const char *__restrict __name, - char *__restrict __resolved) noexcept (true) ; - - - - - - -typedef int (*__compar_fn_t) (const void *, const void *); - - -typedef __compar_fn_t comparison_fn_t; - - - -typedef int (*__compar_d_fn_t) (const void *, const void *, void *); - - - - -extern void *bsearch (const void *__key, const void *__base, - size_t __nmemb, size_t __size, __compar_fn_t __compar) - __attribute__ ((__nonnull__ (1, 2, 5))) ; - - -# 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4 -# 19 "/usr/include/bits/stdlib-bsearch.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) void * -bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, - __compar_fn_t __compar) -{ - size_t __l, __u, __idx; - const void *__p; - int __comparison; - - __l = 0; - __u = __nmemb; - while (__l < __u) - { - __idx = (__l + __u) / 2; - __p = (const void *) (((const char *) __base) + (__idx * __size)); - __comparison = (*__compar) (__key, __p); - if (__comparison < 0) - __u = __idx; - else if (__comparison > 0) - __l = __idx + 1; - else - { - - - - - return (void *) __p; - - - - } - } - - return __null; -} -# 966 "/usr/include/stdlib.h" 2 3 4 - - - - -extern void qsort (void *__base, size_t __nmemb, size_t __size, - __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); - -extern void qsort_r (void *__base, size_t __nmemb, size_t __size, - __compar_d_fn_t __compar, void *__arg) - __attribute__ ((__nonnull__ (1, 4))); - - - - -extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; -extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; - - -__extension__ extern long long int llabs (long long int __x) - noexcept (true) __attribute__ ((__const__)) ; - - - - - - -extern div_t div (int __numer, int __denom) - noexcept (true) __attribute__ ((__const__)) ; -extern ldiv_t ldiv (long int __numer, long int __denom) - noexcept (true) __attribute__ ((__const__)) ; - - -__extension__ extern lldiv_t lldiv (long long int __numer, - long long int __denom) - noexcept (true) __attribute__ ((__const__)) ; -# 1012 "/usr/include/stdlib.h" 3 4 -extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; - - - - -extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; - - - - -extern char *gcvt (double __value, int __ndigit, char *__buf) - noexcept (true) __attribute__ ((__nonnull__ (3))) ; - - - - -extern char *qecvt (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign) - noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; -extern char *qfcvt (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign) - noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; -extern char *qgcvt (long double __value, int __ndigit, char *__buf) - noexcept (true) __attribute__ ((__nonnull__ (3))) ; - - - - -extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign, char *__restrict __buf, - size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); -extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign, char *__restrict __buf, - size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); - -extern int qecvt_r (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign, - char *__restrict __buf, size_t __len) - noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); -extern int qfcvt_r (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign, - char *__restrict __buf, size_t __len) - noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); - - - - - -extern int mblen (const char *__s, size_t __n) noexcept (true); - - -extern int mbtowc (wchar_t *__restrict __pwc, - const char *__restrict __s, size_t __n) noexcept (true); - - -extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); - - - -extern size_t mbstowcs (wchar_t *__restrict __pwcs, - const char *__restrict __s, size_t __n) noexcept (true) - ; - -extern size_t wcstombs (char *__restrict __s, - const wchar_t *__restrict __pwcs, size_t __n) - noexcept (true) - - ; - - - - - - -extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; -# 1099 "/usr/include/stdlib.h" 3 4 -extern int getsubopt (char **__restrict __optionp, - char *const *__restrict __tokens, - char **__restrict __valuep) - noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; - - - - - - - -extern int posix_openpt (int __oflag) ; - - - - - - - -extern int grantpt (int __fd) noexcept (true); - - - -extern int unlockpt (int __fd) noexcept (true); - - - - -extern char *ptsname (int __fd) noexcept (true) ; - - - - - - -extern int ptsname_r (int __fd, char *__buf, size_t __buflen) - noexcept (true) __attribute__ ((__nonnull__ (2))) ; - - -extern int getpt (void); - - - - - - -extern int getloadavg (double __loadavg[], int __nelem) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 1155 "/usr/include/stdlib.h" 3 4 -# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 -# 24 "/usr/include/bits/stdlib-float.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) double - atof (const char *__nptr) noexcept (true) -{ - return strtod (__nptr, (char **) __null); -} -# 1156 "/usr/include/stdlib.h" 2 3 4 -# 1167 "/usr/include/stdlib.h" 3 4 -} -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::abs; - - - inline long - abs(long __i) { return __builtin_labs(__i); } - - - - inline long long - abs(long long __x) { return __builtin_llabs (__x); } -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 - inline constexpr double - abs(double __x) - { return __builtin_fabs(__x); } - - inline constexpr float - abs(float __x) - { return __builtin_fabsf(__x); } - - inline constexpr long double - abs(long double __x) - { return __builtin_fabsl(__x); } -# 151 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 -} -} -# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::div_t; - using ::ldiv_t; - - using ::abort; - - using ::aligned_alloc; - - using ::atexit; - - - using ::at_quick_exit; - - - using ::atof; - using ::atoi; - using ::atol; - using ::bsearch; - using ::calloc; - using ::div; - using ::exit; - using ::free; - using ::getenv; - using ::labs; - using ::ldiv; - using ::malloc; - - using ::mblen; - using ::mbstowcs; - using ::mbtowc; - - using ::qsort; - - - using ::quick_exit; - - - using ::rand; - using ::realloc; - using ::srand; - using ::strtod; - using ::strtol; - using ::strtoul; - using ::system; - - using ::wcstombs; - using ::wctomb; - - - - inline ldiv_t - div(long __i, long __j) noexcept { return ldiv(__i, __j); } - - - - -} -# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -# 231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 2 3 4 - -using std::abort; -using std::atexit; -using std::exit; - - - using std::at_quick_exit; - - - using std::quick_exit; - - - using std::_Exit; - - - - -using std::div_t; -using std::ldiv_t; - -using std::abs; -using std::atof; -using std::atoi; -using std::atol; -using std::bsearch; -using std::calloc; -using std::div; -using std::free; -using std::getenv; -using std::labs; -using std::ldiv; -using std::malloc; - -using std::mblen; -using std::mbstowcs; -using std::mbtowc; - -using std::qsort; -using std::rand; -using std::realloc; -using std::srand; -using std::strtod; -using std::strtol; -using std::strtoul; -using std::system; - -using std::wcstombs; -using std::wctomb; -# 41 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 35 "/usr/lib/clang/16/include/stddef.h" 3 4 -typedef long int ptrdiff_t; -# 109 "/usr/lib/clang/16/include/stddef.h" 3 4 -# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 4 -# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 4 -typedef struct { - long long __clang_max_align_nonce1 - __attribute__((__aligned__(__alignof__(long long)))); - long double __clang_max_align_nonce2 - __attribute__((__aligned__(__alignof__(long double)))); -} max_align_t; -# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 4 -# 42 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 -# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 -# 22 "/usr/lib/clang/16/include/stdarg.h" 3 4 -typedef __builtin_va_list va_list; -# 43 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 -# 60 "/usr/include/SDL2/SDL_stdinc.h" 3 4 -# 1 "/usr/include/string.h" 1 3 4 -# 26 "/usr/include/string.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/string.h" 2 3 4 - -extern "C" { - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 34 "/usr/include/string.h" 2 3 4 -# 43 "/usr/include/string.h" 3 4 -extern void *memcpy (void *__restrict __dest, const void *__restrict __src, - size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern void *memmove (void *__dest, const void *__src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - - -extern void *memccpy (void *__restrict __dest, const void *__restrict __src, - int __c, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - - -extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int memcmp (const void *__s1, const void *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -# 80 "/usr/include/string.h" 3 4 -extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - - -extern "C++" -{ -extern void *memchr (void *__s, int __c, size_t __n) - noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern const void *memchr (const void *__s, int __c, size_t __n) - noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void * -memchr (void *__s, int __c, size_t __n) noexcept (true) -{ - return __builtin_memchr (__s, __c, __n); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void * -memchr (const void *__s, int __c, size_t __n) noexcept (true) -{ - return __builtin_memchr (__s, __c, __n); -} - -} -# 115 "/usr/include/string.h" 3 4 -extern "C++" void *rawmemchr (void *__s, int __c) - noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern "C++" const void *rawmemchr (const void *__s, int __c) - noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - - - - - - -extern "C++" void *memrchr (void *__s, int __c, size_t __n) - noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) - ; -extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) - noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) - ; -# 141 "/usr/include/string.h" 3 4 -extern char *strcpy (char *__restrict __dest, const char *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern char *strncpy (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern char *strcat (char *__restrict __dest, const char *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern char *strncat (char *__restrict __dest, const char *__restrict __src, - size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int strcmp (const char *__s1, const char *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - -extern int strncmp (const char *__s1, const char *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern int strcoll (const char *__s1, const char *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - -extern size_t strxfrm (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (2))) ; - - - - - - -extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); - - -extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, - locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) - ; - - - - - -extern char *strdup (const char *__s) - noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); - - - - - - -extern char *strndup (const char *__string, size_t __n) - noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); -# 224 "/usr/include/string.h" 3 4 -extern "C++" -{ -extern char *strchr (char *__s, int __c) - noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern const char *strchr (const char *__s, int __c) - noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * -strchr (char *__s, int __c) noexcept (true) -{ - return __builtin_strchr (__s, __c); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * -strchr (const char *__s, int __c) noexcept (true) -{ - return __builtin_strchr (__s, __c); -} - -} - - - - - - -extern "C++" -{ -extern char *strrchr (char *__s, int __c) - noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern const char *strrchr (const char *__s, int __c) - noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * -strrchr (char *__s, int __c) noexcept (true) -{ - return __builtin_strrchr (__s, __c); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * -strrchr (const char *__s, int __c) noexcept (true) -{ - return __builtin_strrchr (__s, __c); -} - -} -# 281 "/usr/include/string.h" 3 4 -extern "C++" char *strchrnul (char *__s, int __c) - noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern "C++" const char *strchrnul (const char *__s, int __c) - noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -# 293 "/usr/include/string.h" 3 4 -extern size_t strcspn (const char *__s, const char *__reject) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern size_t strspn (const char *__s, const char *__accept) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern "C++" -{ -extern char *strpbrk (char *__s, const char *__accept) - noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -extern const char *strpbrk (const char *__s, const char *__accept) - noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * -strpbrk (char *__s, const char *__accept) noexcept (true) -{ - return __builtin_strpbrk (__s, __accept); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * -strpbrk (const char *__s, const char *__accept) noexcept (true) -{ - return __builtin_strpbrk (__s, __accept); -} - -} - - - - - - -extern "C++" -{ -extern char *strstr (char *__haystack, const char *__needle) - noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -extern const char *strstr (const char *__haystack, const char *__needle) - noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * -strstr (char *__haystack, const char *__needle) noexcept (true) -{ - return __builtin_strstr (__haystack, __needle); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * -strstr (const char *__haystack, const char *__needle) noexcept (true) -{ - return __builtin_strstr (__haystack, __needle); -} - -} - - - - - - - -extern char *strtok (char *__restrict __s, const char *__restrict __delim) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - - -extern char *__strtok_r (char *__restrict __s, - const char *__restrict __delim, - char **__restrict __save_ptr) - noexcept (true) __attribute__ ((__nonnull__ (2, 3))); - -extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, - char **__restrict __save_ptr) - noexcept (true) __attribute__ ((__nonnull__ (2, 3))); - - - - - -extern "C++" char *strcasestr (char *__haystack, const char *__needle) - noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -extern "C++" const char *strcasestr (const char *__haystack, - const char *__needle) - noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -# 389 "/usr/include/string.h" 3 4 -extern void *memmem (const void *__haystack, size_t __haystacklen, - const void *__needle, size_t __needlelen) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) - - ; - - - -extern void *__mempcpy (void *__restrict __dest, - const void *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern void *mempcpy (void *__restrict __dest, - const void *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern size_t strlen (const char *__s) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - - - -extern size_t strnlen (const char *__string, size_t __maxlen) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - - - -extern char *strerror (int __errnum) noexcept (true); -# 444 "/usr/include/string.h" 3 4 -extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) - noexcept (true) __attribute__ ((__nonnull__ (2))) ; - - - - -extern const char *strerrordesc_np (int __err) noexcept (true); - -extern const char *strerrorname_np (int __err) noexcept (true); - - - - - -extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); - - - -# 1 "/usr/include/strings.h" 1 3 4 -# 23 "/usr/include/strings.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 24 "/usr/include/strings.h" 2 3 4 - - - - - - -extern "C" { - - - -extern int bcmp (const void *__s1, const void *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern void bcopy (const void *__src, void *__dest, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); -# 68 "/usr/include/strings.h" 3 4 -extern char *index (const char *__s, int __c) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -# 96 "/usr/include/strings.h" 3 4 -extern char *rindex (const char *__s, int __c) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); - - - - - -extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); -__extension__ extern int ffsll (long long int __ll) - noexcept (true) __attribute__ ((__const__)); - - - -extern int strcasecmp (const char *__s1, const char *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - - - - - -extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); - - - -extern int strncasecmp_l (const char *__s1, const char *__s2, - size_t __n, locale_t __loc) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); - - -} -# 463 "/usr/include/string.h" 2 3 4 - - - -extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) - ; - - - -extern char *strsep (char **__restrict __stringp, - const char *__restrict __delim) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern char *strsignal (int __sig) noexcept (true); - - - -extern const char *sigabbrev_np (int __sig) noexcept (true); - - -extern const char *sigdescr_np (int __sig) noexcept (true); - - - -extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern char *__stpncpy (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern char *stpncpy (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern size_t strlcpy (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern size_t strlcat (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - - -extern int strverscmp (const char *__s1, const char *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) - ; - - - - - - - -extern "C++" char *basename (char *__filename) - noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); -extern "C++" const char *basename (const char *__filename) - noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); -# 552 "/usr/include/string.h" 3 4 -} -# 61 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - - - - -# 1 "/usr/include/wchar.h" 1 3 4 -# 27 "/usr/include/wchar.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/wchar.h" 2 3 4 - - - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 36 "/usr/include/wchar.h" 2 3 4 -# 51 "/usr/include/wchar.h" 3 4 -# 1 "/usr/include/bits/wchar.h" 1 3 4 -# 52 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 -# 20 "/usr/include/bits/types/wint_t.h" 3 4 -typedef unsigned int wint_t; -# 53 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 - - - - - -typedef __mbstate_t mbstate_t; -# 54 "/usr/include/wchar.h" 2 3 4 -# 90 "/usr/include/wchar.h" 3 4 -extern "C" { - - - -struct tm; - - - -extern wchar_t *wcscpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern wchar_t *wcsncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern size_t wcslcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern size_t wcslcat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern wchar_t *wcscat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern wchar_t *wcsncat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - -extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - -extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, - size_t __n) noexcept (true); - - - -extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - -extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - - - -extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - - -extern size_t wcsxfrm (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - - - - - -extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - - - - -extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - -extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) - __attribute__ ((__malloc__)) ; -# 189 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); -# 199 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - -extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) - noexcept (true) __attribute__ ((__pure__)); - - -extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 226 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 237 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - -extern wchar_t *wcstok (wchar_t *__restrict __s, - const wchar_t *__restrict __delim, - wchar_t **__restrict __ptr) noexcept (true); - - -extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); -# 258 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) - noexcept (true) __attribute__ ((__pure__)); -# 278 "/usr/include/wchar.h" 3 4 -extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - - -extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - -extern wchar_t *wmemcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - -extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true); - - -extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); - - - - -extern wchar_t *wmempcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) - noexcept (true); - - - - - -extern wint_t btowc (int __c) noexcept (true); - - - -extern int wctob (wint_t __c) noexcept (true); - - - -extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); - - - -extern size_t mbrtowc (wchar_t *__restrict __pwc, - const char *__restrict __s, size_t __n, - mbstate_t *__restrict __p) noexcept (true); - - -extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, - mbstate_t *__restrict __ps) noexcept (true); - - -extern size_t __mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); -extern size_t mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - - -extern wint_t __btowc_alias (int __c) __asm ("btowc"); -extern __inline __attribute__ ((__gnu_inline__)) wint_t - btowc (int __c) noexcept (true) -{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' - ? (wint_t) __c : __btowc_alias (__c)); } - -extern int __wctob_alias (wint_t __c) __asm ("wctob"); -extern __inline __attribute__ ((__gnu_inline__)) int - wctob (wint_t __wc) noexcept (true) -{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' - ? (int) __wc : __wctob_alias (__wc)); } - -extern __inline __attribute__ ((__gnu_inline__)) size_t - mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) - -{ return (__ps != __null - ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } - - - - -extern size_t mbsrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - -extern size_t mbsnrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __nmc, - size_t __len, mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsnrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, - size_t __nwc, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - -extern int wcwidth (wchar_t __c) noexcept (true); - - - -extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); - - - - - -extern double wcstod (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern float wcstof (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -extern long double wcstold (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 422 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 437 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 455 "/usr/include/wchar.h" 3 4 -extern long int wcstol (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) noexcept (true); - - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - - -extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); -# 561 "/usr/include/wchar.h" 3 4 -extern long int wcstol_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base, - locale_t __loc) noexcept (true); - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true); - - - - - -extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); - - - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); - - - - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); - - - - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); -# 630 "/usr/include/wchar.h" 3 4 -extern double wcstod_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern float wcstof_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern long double wcstold_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 649 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 667 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 689 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcpcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) noexcept (true); - - - -extern wchar_t *wcpncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true); -# 718 "/usr/include/wchar.h" 3 4 -extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern int fwide (__FILE *__fp, int __mode) noexcept (true); - - - - - - -extern int fwprintf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wprintf (const wchar_t *__restrict __format, ...) - ; - -extern int swprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, ...) - noexcept (true) ; - - - - - -extern int vfwprintf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwprintf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - -extern int vswprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; - - - - - - -extern int fwscanf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wscanf (const wchar_t *__restrict __format, ...) - ; - -extern int swscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, ...) - noexcept (true) ; -# 795 "/usr/include/wchar.h" 3 4 -extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") - - - ; -extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") - - ; -extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") - - - ; -# 851 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwscanf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - -extern int vswscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; -# 875 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") - - - ; -extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") - - ; -extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") - - - ; -# 935 "/usr/include/wchar.h" 3 4 -extern wint_t fgetwc (__FILE *__stream); -extern wint_t getwc (__FILE *__stream); - - - - - -extern wint_t getwchar (void); - - - - - - -extern wint_t fputwc (wchar_t __wc, __FILE *__stream); -extern wint_t putwc (wchar_t __wc, __FILE *__stream); - - - - - -extern wint_t putwchar (wchar_t __wc); - - - - - - - -extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - -extern int fputws (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern wint_t ungetwc (wint_t __wc, __FILE *__stream); -# 990 "/usr/include/wchar.h" 3 4 -extern wint_t getwc_unlocked (__FILE *__stream); -extern wint_t getwchar_unlocked (void); - - - - - - - -extern wint_t fgetwc_unlocked (__FILE *__stream); - - - - - - - -extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); -# 1016 "/usr/include/wchar.h" 3 4 -extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); -extern wint_t putwchar_unlocked (wchar_t __wc); -# 1026 "/usr/include/wchar.h" 3 4 -extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - - - -extern int fputws_unlocked (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp) noexcept (true); - - - - -extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp, - locale_t __loc) noexcept (true); -# 1073 "/usr/include/wchar.h" 3 4 -} -# 67 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - -# 1 "/usr/lib/clang/16/include/inttypes.h" 1 3 4 -# 21 "/usr/lib/clang/16/include/inttypes.h" 3 4 -# 1 "/usr/include/inttypes.h" 1 3 4 -# 27 "/usr/include/inttypes.h" 3 4 -# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 4 -# 52 "/usr/lib/clang/16/include/stdint.h" 3 4 -# 1 "/usr/include/stdint.h" 1 3 4 -# 26 "/usr/include/stdint.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/stdint.h" 2 3 4 - - -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 30 "/usr/include/stdint.h" 2 3 4 - - - - - - - -# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-uintn.h" 3 4 -typedef __uint8_t uint8_t; -typedef __uint16_t uint16_t; -typedef __uint32_t uint32_t; -typedef __uint64_t uint64_t; -# 38 "/usr/include/stdint.h" 2 3 4 - - - - - -typedef __int_least8_t int_least8_t; -typedef __int_least16_t int_least16_t; -typedef __int_least32_t int_least32_t; -typedef __int_least64_t int_least64_t; - - -typedef __uint_least8_t uint_least8_t; -typedef __uint_least16_t uint_least16_t; -typedef __uint_least32_t uint_least32_t; -typedef __uint_least64_t uint_least64_t; - - - - - -typedef signed char int_fast8_t; - -typedef long int int_fast16_t; -typedef long int int_fast32_t; -typedef long int int_fast64_t; -# 71 "/usr/include/stdint.h" 3 4 -typedef unsigned char uint_fast8_t; - -typedef unsigned long int uint_fast16_t; -typedef unsigned long int uint_fast32_t; -typedef unsigned long int uint_fast64_t; -# 87 "/usr/include/stdint.h" 3 4 -typedef long int intptr_t; - - -typedef unsigned long int uintptr_t; -# 101 "/usr/include/stdint.h" 3 4 -typedef __intmax_t intmax_t; -typedef __uintmax_t uintmax_t; -# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 4 -# 28 "/usr/include/inttypes.h" 2 3 4 -# 327 "/usr/include/inttypes.h" 3 4 -extern "C" { - - - - -typedef struct - { - long int quot; - long int rem; - } imaxdiv_t; -# 351 "/usr/include/inttypes.h" 3 4 -extern intmax_t imaxabs (intmax_t __n) noexcept (true) __attribute__ ((__const__)); - - -extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom) - noexcept (true) __attribute__ ((__const__)); - - -extern intmax_t strtoimax (const char *__restrict __nptr, - char **__restrict __endptr, int __base) noexcept (true); - - -extern uintmax_t strtoumax (const char *__restrict __nptr, - char ** __restrict __endptr, int __base) noexcept (true); - - -extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - -extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, - wchar_t ** __restrict __endptr, int __base) - noexcept (true); - - - - - -extern intmax_t strtoimax (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoimax"); - - -extern uintmax_t strtoumax (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoumax"); - - -extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoimax"); - - - -extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoumax"); -# 415 "/usr/include/inttypes.h" 3 4 -} -# 22 "/usr/lib/clang/16/include/inttypes.h" 2 3 4 -# 70 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - - - -# 1 "/usr/include/ctype.h" 1 3 4 -# 28 "/usr/include/ctype.h" 3 4 -extern "C" { -# 46 "/usr/include/ctype.h" 3 4 -enum -{ - _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), - _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), - _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), - _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), - _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), - _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), - _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), - _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), - _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), - _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), - _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), - _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) -}; -# 79 "/usr/include/ctype.h" 3 4 -extern const unsigned short int **__ctype_b_loc (void) - noexcept (true) __attribute__ ((__const__)); -extern const __int32_t **__ctype_tolower_loc (void) - noexcept (true) __attribute__ ((__const__)); -extern const __int32_t **__ctype_toupper_loc (void) - noexcept (true) __attribute__ ((__const__)); -# 108 "/usr/include/ctype.h" 3 4 -extern int isalnum (int) noexcept (true); -extern int isalpha (int) noexcept (true); -extern int iscntrl (int) noexcept (true); -extern int isdigit (int) noexcept (true); -extern int islower (int) noexcept (true); -extern int isgraph (int) noexcept (true); -extern int isprint (int) noexcept (true); -extern int ispunct (int) noexcept (true); -extern int isspace (int) noexcept (true); -extern int isupper (int) noexcept (true); -extern int isxdigit (int) noexcept (true); - - - -extern int tolower (int __c) noexcept (true); - - -extern int toupper (int __c) noexcept (true); - - - - -extern int isblank (int) noexcept (true); - - - - -extern int isctype (int __c, int __mask) noexcept (true); - - - - - - -extern int isascii (int __c) noexcept (true); - - - -extern int toascii (int __c) noexcept (true); - - - -extern int _toupper (int) noexcept (true); -extern int _tolower (int) noexcept (true); -# 251 "/usr/include/ctype.h" 3 4 -extern int isalnum_l (int, locale_t) noexcept (true); -extern int isalpha_l (int, locale_t) noexcept (true); -extern int iscntrl_l (int, locale_t) noexcept (true); -extern int isdigit_l (int, locale_t) noexcept (true); -extern int islower_l (int, locale_t) noexcept (true); -extern int isgraph_l (int, locale_t) noexcept (true); -extern int isprint_l (int, locale_t) noexcept (true); -extern int ispunct_l (int, locale_t) noexcept (true); -extern int isspace_l (int, locale_t) noexcept (true); -extern int isupper_l (int, locale_t) noexcept (true); -extern int isxdigit_l (int, locale_t) noexcept (true); - -extern int isblank_l (int, locale_t) noexcept (true); - - - -extern int __tolower_l (int __c, locale_t __l) noexcept (true); -extern int tolower_l (int __c, locale_t __l) noexcept (true); - - -extern int __toupper_l (int __c, locale_t __l) noexcept (true); -extern int toupper_l (int __c, locale_t __l) noexcept (true); -# 327 "/usr/include/ctype.h" 3 4 -} -# 75 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 -# 86 "/usr/include/SDL2/SDL_stdinc.h" 3 4 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/math.h" 1 3 4 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/math.h" 3 4 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 1 3 4 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - struct __true_type { }; - struct __false_type { }; - - template - struct __truth_type - { typedef __false_type __type; }; - - template<> - struct __truth_type - { typedef __true_type __type; }; - - - - template - struct __traitor - { - enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; - typedef typename __truth_type<__value>::__type __type; - }; - - - template - struct __are_same - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __are_same<_Tp, _Tp> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_void - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_void - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_integer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; - }; -# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template - struct __is_pointer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __is_pointer<_Tp*> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_arithmetic - : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > - { }; - - - - - template - struct __is_scalar - : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > - { }; - - - - - template - struct __is_char - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_byte - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - enum class byte : unsigned char; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template struct iterator_traits; - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = __is_trivially_copyable(_Tp) }; - }; - - - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = 0 }; - }; - - - template - struct __memcpyable - { - enum { __value = 0 }; - }; - - template - struct __memcpyable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcpyable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - template - struct __memcmpable - { - enum { __value = 0 }; - }; - - - template - struct __memcmpable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - - template::__value - - > - struct __is_memcmp_ordered - { - static const bool __value = _Tp(-1) > _Tp(1); - }; - - template - struct __is_memcmp_ordered<_Tp, false> - { - static const bool __value = false; - }; - - - template - struct __is_memcmp_ordered_with - { - static const bool __value = __is_memcmp_ordered<_Tp>::__value - && __is_memcmp_ordered<_Up>::__value; - }; - - template - struct __is_memcmp_ordered_with<_Tp, _Up, false> - { - static const bool __value = false; - }; -# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_memcmp_ordered_with - { static constexpr bool __value = true; }; - - template - struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> - { static constexpr bool __value = false; }; - - template - struct __is_memcmp_ordered_with - { static constexpr bool __value = false; }; - - - - - - template - struct __is_move_iterator - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - template - - inline _Iterator - __miter_base(_Iterator __it) - { return __it; } - - -} -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - - - - -extern "C++" { - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct __enable_if - { }; - - template - struct __enable_if - { typedef _Tp __type; }; - - - - template - struct __conditional_type - { typedef _Iftrue __type; }; - - template - struct __conditional_type - { typedef _Iffalse __type; }; - - - - template - struct __add_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned short __type; }; - - template<> - struct __add_unsigned - { typedef unsigned int __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long long __type; }; - - - template<> - struct __add_unsigned; - - template<> - struct __add_unsigned; - - - - template - struct __remove_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef short __type; }; - - template<> - struct __remove_unsigned - { typedef int __type; }; - - template<> - struct __remove_unsigned - { typedef long __type; }; - - template<> - struct __remove_unsigned - { typedef long long __type; }; - - - template<> - struct __remove_unsigned; - - template<> - struct __remove_unsigned; - - - - template - constexpr - inline bool - __is_null_pointer(_Type* __ptr) - { return __ptr == 0; } - - template - constexpr - inline bool - __is_null_pointer(_Type) - { return false; } - - - constexpr bool - __is_null_pointer(std::nullptr_t) - { return true; } - - - - - template::__value> - struct __promote - { typedef double __type; }; - - - - - template - struct __promote<_Tp, false> - { }; - - template<> - struct __promote - { typedef long double __type; }; - - template<> - struct __promote - { typedef double __type; }; - - template<> - struct __promote - { typedef float __type; }; -# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - template - using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); - - - - template - using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; - - template - using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; - - template - using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 -} -} -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 - -# 1 "/usr/include/math.h" 1 3 4 -# 27 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/math.h" 2 3 4 - - - - - - -extern "C" { - - - - - -# 1 "/usr/include/bits/math-vector.h" 1 3 4 -# 25 "/usr/include/bits/math-vector.h" 3 4 -# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4 -# 26 "/usr/include/bits/math-vector.h" 2 3 4 -# 41 "/usr/include/math.h" 2 3 4 -# 152 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4 -# 153 "/usr/include/math.h" 2 3 4 -# 163 "/usr/include/math.h" 3 4 -typedef float float_t; -typedef double double_t; -# 204 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/fp-logb.h" 1 3 4 -# 205 "/usr/include/math.h" 2 3 4 -# 247 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/fp-fast.h" 1 3 4 -# 248 "/usr/include/math.h" 2 3 4 - - - -enum - { - FP_INT_UPWARD = - - 0, - FP_INT_DOWNWARD = - - 1, - FP_INT_TOWARDZERO = - - 2, - FP_INT_TONEARESTFROMZERO = - - 3, - FP_INT_TONEAREST = - - 4, - }; -# 312 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 -# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 -extern int __fpclassify (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __signbit (double __value) noexcept (true) - __attribute__ ((__const__)); - - - -extern int __isinf (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __finite (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __isnan (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __iseqsig (double __x, double __y) noexcept (true); - - -extern int __issignaling (double __value) noexcept (true) - __attribute__ ((__const__)); -# 313 "/usr/include/math.h" 2 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true); - - extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true); - - extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true); - - extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true); - - - extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true); - - extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true); - - extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true); - - - - - extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true); - - extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true); - - extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true); - - - - extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true); - - - - - - extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true); - - extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true); - - extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true); - - - - - - extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true); - - -extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true); - - -extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true); - - - extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true); - - - extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true); - - -extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true); - - - - - extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true); - - - extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true); - - -extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true); - - - - - extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true); - - - extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true); - - - - - - - extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true); - - -extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true); - - - - extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true); - - - - - extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true); - - - - - - -extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); extern double __ceil (double __x) noexcept (true) __attribute__ ((__const__)); - - -extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); extern double __fabs (double __x) noexcept (true) __attribute__ ((__const__)); - - -extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); extern double __floor (double __x) noexcept (true) __attribute__ ((__const__)); - - -extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true); -# 183 "/usr/include/bits/mathcalls.h" 3 4 -extern int finite (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); - - - -extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); - - - - - - -extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true); -# 220 "/usr/include/bits/mathcalls.h" 3 4 -extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true); -extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true); -extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true); -extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true); -extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true); -extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true); - - - - - - extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true); - extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true); -extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true); - - - - -extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true); - - - - - -extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true); - - - - - - - -extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true); - - - - - - -extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true); - - -extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true); - -extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true); - - - - -extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true); - -extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true); - - - -extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true); - - - -extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true); - - - -extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true); - - - - -extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true); - - - - -extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true); - - - -extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true); - - - -extern double round (double __x) noexcept (true) __attribute__ ((__const__)); extern double __round (double __x) noexcept (true) __attribute__ ((__const__)); - - - -extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); extern double __trunc (double __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true); - - - - - - -extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true); -__extension__ -extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true); - - - -extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true); -__extension__ -extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true); - - - -extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true); - - - -extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - - -extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); - - - - -extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); extern double __roundeven (double __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalize (double *__cx, const double *__x) noexcept (true); - - - - - - -extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorder (const double *__x, const double *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermag (const double *__x, const double *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true); - - -extern int setpayload (double *__x, double __payload) noexcept (true); - - -extern int setpayloadsig (double *__x, double __payload) noexcept (true); - - - - - - - -extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true); -# 314 "/usr/include/math.h" 2 3 4 -# 329 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 -# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 -extern int __fpclassifyf (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __signbitf (float __value) noexcept (true) - __attribute__ ((__const__)); - - - -extern int __isinff (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __finitef (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __isnanf (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __iseqsigf (float __x, float __y) noexcept (true); - - -extern int __issignalingf (float __value) noexcept (true) - __attribute__ ((__const__)); -# 330 "/usr/include/math.h" 2 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true); - - extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true); - - extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true); - - extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true); - - - extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true); - - extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true); - - extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true); - - - - - extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true); - - extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true); - - extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true); - - - - extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); - - - - - - extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true); - - extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true); - - extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true); - - - - - - extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true); - - -extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true); - - -extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true); - - - extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true); - - - extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true); - - -extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true); - - - - - extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true); - - - extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true); - - -extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true); - - - - - extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true); - - - extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true); - - - - - - - extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true); - - -extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true); - - - - extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true); - - - - - extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true); - - - - - - -extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __ceilf (float __x) noexcept (true) __attribute__ ((__const__)); - - -extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__)); - - -extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__)); - - -extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); -# 177 "/usr/include/bits/mathcalls.h" 3 4 -extern int isinff (float __value) noexcept (true) - __attribute__ ((__const__)); - - - - -extern int finitef (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); - - - -extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); - - - - - - -extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); -# 213 "/usr/include/bits/mathcalls.h" 3 4 -extern int isnanf (float __value) noexcept (true) - __attribute__ ((__const__)); - - - - - -extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true); -extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true); -extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true); -extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true); -extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true); -extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true); - - - - - - extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true); - extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true); -extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true); - - - - -extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true); - - - - - -extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true); - - - - - - - -extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true); - - - - - - -extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true); - - -extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true); - -extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true); - - - - -extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true); - -extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true); - - - -extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true); - - - -extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true); - - - -extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true); - - - - -extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true); - - - - -extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true); - - - -extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true); - - - -extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundf (float __x) noexcept (true) __attribute__ ((__const__)); - - - -extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __truncf (float __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true); - - - - - - -extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true); -__extension__ -extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true); - - - -extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true); -__extension__ -extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true); - - - -extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true); - - - -extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - - -extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); - - - - -extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalizef (float *__cx, const float *__x) noexcept (true); - - - - - - -extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorderf (const float *__x, const float *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermagf (const float *__x, const float *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true); - - -extern int setpayloadf (float *__x, float __payload) noexcept (true); - - -extern int setpayloadsigf (float *__x, float __payload) noexcept (true); - - - - - - - -extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true); -# 331 "/usr/include/math.h" 2 3 4 -# 398 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 -# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 -extern int __fpclassifyl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __signbitl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - - -extern int __isinfl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __finitel (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __isnanl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __iseqsigl (long double __x, long double __y) noexcept (true); - - -extern int __issignalingl (long double __value) noexcept (true) - __attribute__ ((__const__)); -# 399 "/usr/include/math.h" 2 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true); - - extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true); - - extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true); - - extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true); - - - extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true); - - extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true); - - extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true); - - - - - extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true); - - extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true); - - extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true); - - - - extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); - - - - - - extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true); - - extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true); - - extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true); - - - - - - extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true); - - -extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true); - - -extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true); - - - extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true); - - - extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true); - - -extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true); - - - - - extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true); - - - extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true); - - -extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true); - - - - - extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true); - - - extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true); - - - - - - - extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true); - - -extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true); - - - - extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true); - - - - - extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true); - - - - - - -extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __ceill (long double __x) noexcept (true) __attribute__ ((__const__)); - - -extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); - - -extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__)); - - -extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); -# 177 "/usr/include/bits/mathcalls.h" 3 4 -extern int isinfl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - - - -extern int finitel (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); - - - -extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); - - - - - - -extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true); -# 213 "/usr/include/bits/mathcalls.h" 3 4 -extern int isnanl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - - - - -extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); -extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); -extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true); -extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true); -extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true); -extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true); - - - - - - extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true); - extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true); -extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true); - - - - -extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true); - - - - - -extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true); - - - - - - - -extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true); - - - - - - -extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true); - - -extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true); - -extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true); - - - - -extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true); - -extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true); - - - -extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true); - - - -extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true); - - - -extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true); - - - - -extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true); - - - - -extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true); - - - -extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true); - - - -extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundl (long double __x) noexcept (true) __attribute__ ((__const__)); - - - -extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); - - - - - - -extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); -__extension__ -extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true); - - - -extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true); -__extension__ -extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true); - - - -extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true); - - - -extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - - -extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); - - - - -extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true); - - - - - - -extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorderl (const long double *__x, const long double *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true); - - -extern int setpayloadl (long double *__x, long double __payload) noexcept (true); - - -extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true); - - - - - - - -extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true); -# 400 "/usr/include/math.h" 2 3 4 -# 450 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); - - extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); - - extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); - - extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); - - - extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true); - - extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true); - - extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true); - - - - - extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true); - - extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true); - - extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true); - - - - extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); - - - - - - extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true); - - extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true); - - extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true); - - - - - - extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true); - - -extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); - - -extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); - - - extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true); - - - extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true); - - -extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true); - - - - - extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true); - - - extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true); - - -extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true); - - - - - extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true); - - - extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true); - - - - - - - extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); - - -extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true); - - - - extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); - - - - - extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true); - - - - - - -extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); -# 198 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true); -# 220 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); -extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); -extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true); -extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true); -extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true); -extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true); - - - - - - extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true); - extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true); -extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true); - - - - -extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true); -# 252 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); - - - - - - -extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true); - - -extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); - - - - - - -extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true); - -extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true); - - - -extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); - - - -extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); - - - -extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true); - - - - -extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true); - - - - -extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); - - - -extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true); - - - -extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); - - - - - - -extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true); -__extension__ -extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true); - - - -extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true); -__extension__ -extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true); - - - -extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); - - - -extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); - - - - -extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true); - - - - - - -extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); - - -extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true); - - -extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true); -# 451 "/usr/include/math.h" 2 3 4 -# 467 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); - - extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); - - extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 _ \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/platform/__cpp_inputs.cpp-7e53d83f.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/platform/__cpp_inputs.cpp-7e53d83f.cpp.tmp deleted file mode 100644 index 98b8862..0000000 --- a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/platform/__cpp_inputs.cpp-7e53d83f.cpp.tmp +++ /dev/null @@ -1,38940 +0,0 @@ -# 1 "src/platform/inputs.cpp" -# 1 "" 1 -# 1 "" 3 -# 433 "" 3 -# 1 "" 1 -# 1 "" 2 -# 1 "src/platform/inputs.cpp" 2 -# 13 "src/platform/inputs.cpp" -# 1 "src/platform/inputs.h" 1 -# 13 "src/platform/inputs.h" -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/compare" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/compare" 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 3 - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 -# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - typedef long unsigned int size_t; - typedef long int ptrdiff_t; - - - typedef decltype(nullptr) nullptr_t; - - -#pragma GCC visibility push(default) - - - extern "C++" __attribute__ ((__noreturn__, __always_inline__)) - inline void __terminate() noexcept - { - void terminate() noexcept __attribute__ ((__noreturn__)); - terminate(); - } -#pragma GCC visibility pop -} -# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -namespace __gnu_cxx -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ -#pragma GCC visibility push(default) - - - - - constexpr inline bool - __is_constant_evaluated() noexcept - { - - - - - - return __builtin_is_constant_evaluated(); - - - - } -#pragma GCC visibility pop -} -# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 3 -# 1 "/usr/include/features.h" 1 3 4 -# 394 "/usr/include/features.h" 3 4 -# 1 "/usr/include/features-time64.h" 1 3 4 -# 20 "/usr/include/features-time64.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 21 "/usr/include/features-time64.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 22 "/usr/include/features-time64.h" 2 3 4 -# 395 "/usr/include/features.h" 2 3 4 -# 481 "/usr/include/features.h" 3 4 -# 1 "/usr/include/stdc-predef.h" 1 3 4 -# 482 "/usr/include/features.h" 2 3 4 -# 503 "/usr/include/features.h" 3 4 -# 1 "/usr/include/sys/cdefs.h" 1 3 4 -# 576 "/usr/include/sys/cdefs.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 577 "/usr/include/sys/cdefs.h" 2 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 578 "/usr/include/sys/cdefs.h" 2 3 4 -# 504 "/usr/include/features.h" 2 3 4 -# 527 "/usr/include/features.h" 3 4 -# 1 "/usr/include/gnu/stubs.h" 1 3 4 -# 10 "/usr/include/gnu/stubs.h" 3 4 -# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 -# 11 "/usr/include/gnu/stubs.h" 2 3 4 -# 528 "/usr/include/features.h" 2 3 4 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3 -# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 -# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - template - class initializer_list - { - public: - typedef _E value_type; - typedef const _E& reference; - typedef const _E& const_reference; - typedef size_t size_type; - typedef const _E* iterator; - typedef const _E* const_iterator; - - private: - iterator _M_array; - size_type _M_len; - - - constexpr initializer_list(const_iterator __a, size_type __l) - : _M_array(__a), _M_len(__l) { } - - public: - constexpr initializer_list() noexcept - : _M_array(0), _M_len(0) { } - - - constexpr size_type - size() const noexcept { return _M_len; } - - - constexpr const_iterator - begin() const noexcept { return _M_array; } - - - constexpr const_iterator - end() const noexcept { return begin() + size(); } - }; - - - - - - - - template - constexpr const _Tp* - begin(initializer_list<_Tp> __ils) noexcept - { return __ils.begin(); } - - - - - - - - template - constexpr const _Tp* - end(initializer_list<_Tp> __ils) noexcept - { return __ils.end(); } -} -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - class reference_wrapper; -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } - - }; - - - - - - - - using true_type = integral_constant; - - - using false_type = integral_constant; - - - - template - using __bool_constant = integral_constant; - - - - - - - template - using bool_constant = integral_constant; - - - - - - - template - struct enable_if - { }; - - - template - struct enable_if - { typedef _Tp type; }; - - - template - using __enable_if_t = typename enable_if<_Cond, _Tp>::type; - - template - struct __conditional - { - template - using type = _Tp; - }; - - template<> - struct __conditional - { - template - using type = _Up; - }; - - - template - using __conditional_t - = typename __conditional<_Cond>::template type<_If, _Else>; - - - template - struct __type_identity - { using type = _Type; }; - - template - using __type_identity_t = typename __type_identity<_Tp>::type; - - namespace __detail - { - - template - using __first_t = _Tp; - - - template - auto __or_fn(int) -> __first_t...>; - - template - auto __or_fn(...) -> true_type; - - template - auto __and_fn(int) -> __first_t...>; - - template - auto __and_fn(...) -> false_type; - } - - - - - template - struct __or_ - : decltype(__detail::__or_fn<_Bn...>(0)) - { }; - - template - struct __and_ - : decltype(__detail::__and_fn<_Bn...>(0)) - { }; - - template - struct __not_ - : __bool_constant - { }; - - - - - - template - inline constexpr bool __or_v = __or_<_Bn...>::value; - template - inline constexpr bool __and_v = __and_<_Bn...>::value; - - namespace __detail - { - template - struct __disjunction_impl - { using type = _B1; }; - - template - struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __disjunction_impl::type; }; - - template - struct __conjunction_impl - { using type = _B1; }; - - template - struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __conjunction_impl::type; }; - } - - - - - template - struct conjunction - : __detail::__conjunction_impl::type - { }; - - template<> - struct conjunction<> - : true_type - { }; - - template - struct disjunction - : __detail::__disjunction_impl::type - { }; - - template<> - struct disjunction<> - : false_type - { }; - - template - struct negation - : __not_<_Pp>::type - { }; - - - - - template - inline constexpr bool conjunction_v = conjunction<_Bn...>::value; - - template - inline constexpr bool disjunction_v = disjunction<_Bn...>::value; - - template - inline constexpr bool negation_v = negation<_Pp>::value; - - - - - - template - struct is_reference; - template - struct is_function; - template - struct is_void; - template - struct remove_cv; - template - struct is_const; - - - template - struct __is_array_unknown_bounds; - - - - - template - constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) - { return {}; } - - template - constexpr typename __or_< - is_reference<_NestedType>, - is_function<_NestedType>, - is_void<_NestedType>, - __is_array_unknown_bounds<_NestedType> - >::type __is_complete_or_unbounded(_TypeIdentity) - { return {}; } - - - template - using __remove_cv_t = typename remove_cv<_Tp>::type; - - - - - - template - struct is_void - : public false_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - - template - struct __is_integral_helper - : public false_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; -# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_integral - : public __is_integral_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct __is_floating_point_helper - : public false_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; -# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_floating_point - : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_array - : public false_type { }; - - template - struct is_array<_Tp[_Size]> - : public true_type { }; - - template - struct is_array<_Tp[]> - : public true_type { }; - - template - struct __is_pointer_helper - : public false_type { }; - - template - struct __is_pointer_helper<_Tp*> - : public true_type { }; - - - template - struct is_pointer - : public __is_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_lvalue_reference - : public false_type { }; - - template - struct is_lvalue_reference<_Tp&> - : public true_type { }; - - - template - struct is_rvalue_reference - : public false_type { }; - - template - struct is_rvalue_reference<_Tp&&> - : public true_type { }; - - template - struct __is_member_object_pointer_helper - : public false_type { }; - - template - struct __is_member_object_pointer_helper<_Tp _Cp::*> - : public __not_>::type { }; - - - template - struct is_member_object_pointer - : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct __is_member_function_pointer_helper - : public false_type { }; - - template - struct __is_member_function_pointer_helper<_Tp _Cp::*> - : public is_function<_Tp>::type { }; - - - template - struct is_member_function_pointer - : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_enum - : public integral_constant - { }; - - - template - struct is_union - : public integral_constant - { }; - - - template - struct is_class - : public integral_constant - { }; - - - template - struct is_function - : public __bool_constant::value> { }; - - template - struct is_function<_Tp&> - : public false_type { }; - - template - struct is_function<_Tp&&> - : public false_type { }; - - - - - template - struct is_null_pointer - : public false_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - - - template - struct __is_nullptr_t - : public is_null_pointer<_Tp> - { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); - - - - - template - struct is_reference - : public false_type - { }; - - template - struct is_reference<_Tp&> - : public true_type - { }; - - template - struct is_reference<_Tp&&> - : public true_type - { }; - - - template - struct is_arithmetic - : public __or_, is_floating_point<_Tp>>::type - { }; - - - template - struct is_fundamental - : public __or_, is_void<_Tp>, - is_null_pointer<_Tp>>::type - { }; - - - template - struct is_object - : public __not_<__or_, is_reference<_Tp>, - is_void<_Tp>>>::type - { }; - - template - struct is_member_pointer; - - - template - struct is_scalar - : public __or_, is_enum<_Tp>, is_pointer<_Tp>, - is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type - { }; - - - template - struct is_compound - : public __not_>::type { }; - - - template - struct __is_member_pointer_helper - : public false_type { }; - - template - struct __is_member_pointer_helper<_Tp _Cp::*> - : public true_type { }; - - - - template - struct is_member_pointer - : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct is_same; - - - template - using __is_one_of = __or_...>; - - - __extension__ - template - using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, - signed char, signed short, signed int, signed long, - signed long long -# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - __extension__ - template - using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, - unsigned char, unsigned short, unsigned int, unsigned long, - unsigned long long -# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - template - using __is_standard_integer - = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; - - - template using __void_t = void; - - - - - - template - struct is_const - : public false_type { }; - - template - struct is_const<_Tp const> - : public true_type { }; - - - template - struct is_volatile - : public false_type { }; - - template - struct is_volatile<_Tp volatile> - : public true_type { }; - - - template - struct is_trivial - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copyable - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_standard_layout - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - template - struct - - is_pod - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct - [[__deprecated__]] - is_literal_type - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_empty - : public integral_constant - { }; - - - template - struct is_polymorphic - : public integral_constant - { }; - - - - - - template - struct is_final - : public integral_constant - { }; - - - - template - struct is_abstract - : public integral_constant - { }; - - - template::value> - struct __is_signed_helper - : public false_type { }; - - template - struct __is_signed_helper<_Tp, true> - : public integral_constant - { }; - - - - template - struct is_signed - : public __is_signed_helper<_Tp>::type - { }; - - - template - struct is_unsigned - : public __and_, __not_>>::type - { }; - - - template - _Up - __declval(int); - - template - _Tp - __declval(long); - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)); - - template - struct remove_all_extents; - - - template - struct __is_array_known_bounds - : public false_type - { }; - - template - struct __is_array_known_bounds<_Tp[_Size]> - : public true_type - { }; - - template - struct __is_array_unknown_bounds - : public false_type - { }; - - template - struct __is_array_unknown_bounds<_Tp[]> - : public true_type - { }; -# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - struct __do_is_destructible_impl - { - template().~_Tp())> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_destructible_impl - : public __do_is_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_destructible_safe; - - template - struct __is_destructible_safe<_Tp, false, false> - : public __is_destructible_impl::type>::type - { }; - - template - struct __is_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_destructible - : public __is_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - - struct __do_is_nt_destructible_impl - { - template - static __bool_constant().~_Tp())> - __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_nt_destructible_impl - : public __do_is_nt_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_nt_destructible_safe; - - template - struct __is_nt_destructible_safe<_Tp, false, false> - : public __is_nt_destructible_impl::type>::type - { }; - - template - struct __is_nt_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_nt_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_nothrow_destructible - : public __is_nt_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_constructible_impl - = __bool_constant<__is_constructible(_Tp, _Args...)>; - - - - template - struct is_constructible - : public __is_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_default_constructible - : public __is_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_lvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> - { using type = _Tp&; }; - - template - using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; - - - - template - struct is_copy_constructible - : public __is_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_rvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> - { using type = _Tp&&; }; - - template - using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; - - - - template - struct is_move_constructible - : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_constructible_impl - = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; - - - - template - struct is_nothrow_constructible - : public __is_nothrow_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_default_constructible - : public __is_nothrow_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; - - - - template - struct is_assignable - : public __is_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_copy_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_move_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_assignable_impl - = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; - - - - template - struct is_nothrow_assignable - : public __is_nothrow_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_constructible_impl - = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; - - - - template - struct is_trivially_constructible - : public __is_trivially_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_default_constructible - : public __is_trivially_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - struct __do_is_implicitly_default_constructible_impl - { - template - static void __helper(const _Tp&); - - template - static true_type __test(const _Tp&, - decltype(__helper({}))* = 0); - - static false_type __test(...); - }; - - template - struct __is_implicitly_default_constructible_impl - : public __do_is_implicitly_default_constructible_impl - { - typedef decltype(__test(declval<_Tp>())) type; - }; - - template - struct __is_implicitly_default_constructible_safe - : public __is_implicitly_default_constructible_impl<_Tp>::type - { }; - - template - struct __is_implicitly_default_constructible - : public __and_<__is_constructible_impl<_Tp>, - __is_implicitly_default_constructible_safe<_Tp>>::type - { }; - - - template - struct is_trivially_copy_constructible - : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_constructible - : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_assignable_impl - = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; - - - - template - struct is_trivially_assignable - : public __is_trivially_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copy_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_destructible - : public __and_<__is_destructible_safe<_Tp>, - __bool_constant<__has_trivial_destructor(_Tp)>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - struct has_virtual_destructor - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct alignment_of - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct rank - : public integral_constant { }; - - template - struct rank<_Tp[_Size]> - : public integral_constant::value> { }; - - template - struct rank<_Tp[]> - : public integral_constant::value> { }; - - - template - struct extent - : public integral_constant { }; - - template - struct extent<_Tp[_Size], 0> - : public integral_constant { }; - - template - struct extent<_Tp[_Size], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - template - struct extent<_Tp[], 0> - : public integral_constant { }; - - template - struct extent<_Tp[], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - - - - - template - struct is_same - - : public integral_constant - - - - { }; -# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_base_of - : public integral_constant - { }; - - - template - struct is_convertible - : public __bool_constant<__is_convertible(_From, _To)> - { }; -# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - using __is_array_convertible - = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; -# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_const - { typedef _Tp type; }; - - template - struct remove_const<_Tp const> - { typedef _Tp type; }; - - - template - struct remove_volatile - { typedef _Tp type; }; - - template - struct remove_volatile<_Tp volatile> - { typedef _Tp type; }; - - - - template - struct remove_cv - { using type = __remove_cv(_Tp); }; -# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct add_const - { using type = _Tp const; }; - - - template - struct add_volatile - { using type = _Tp volatile; }; - - - template - struct add_cv - { using type = _Tp const volatile; }; - - - - - - - template - using remove_const_t = typename remove_const<_Tp>::type; - - - template - using remove_volatile_t = typename remove_volatile<_Tp>::type; - - - template - using remove_cv_t = typename remove_cv<_Tp>::type; - - - template - using add_const_t = typename add_const<_Tp>::type; - - - template - using add_volatile_t = typename add_volatile<_Tp>::type; - - - template - using add_cv_t = typename add_cv<_Tp>::type; -# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_reference - { using type = _Tp; }; - - template - struct remove_reference<_Tp&> - { using type = _Tp; }; - - template - struct remove_reference<_Tp&&> - { using type = _Tp; }; - - - - template - struct add_lvalue_reference - { using type = __add_lval_ref_t<_Tp>; }; - - - template - struct add_rvalue_reference - { using type = __add_rval_ref_t<_Tp>; }; - - - - template - using remove_reference_t = typename remove_reference<_Tp>::type; - - - template - using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; - - - template - using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; - - - - - - - - template - struct __cv_selector; - - template - struct __cv_selector<_Unqualified, false, false> - { 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; }; -# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_unsigned_selector; - - template - class __make_unsigned_selector<_Tp, true, false> - { - using __unsigned_type - = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - class __make_unsigned_selector_base - { - protected: - template struct _List { }; - - template - struct _List<_Tp, _Up...> : _List<_Up...> - { static constexpr size_t __size = sizeof(_Tp); }; - - template - struct __select; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, true> - { using __type = _Uint; }; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, false> - : __select<_Sz, _List<_UInts...>> - { }; - }; - - - template - class __make_unsigned_selector<_Tp, false, true> - : __make_unsigned_selector_base - { - - using _UInts = _List; - - using __unsigned_type = typename __select::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - - - - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; -# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - - - - - - template - struct make_unsigned - { typedef typename __make_unsigned_selector<_Tp>::__type type; }; - - - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - - - - - template - struct __make_signed - { typedef _Tp __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed short __type; }; - - template<> - struct __make_signed - { typedef signed int __type; }; - - template<> - struct __make_signed - { typedef signed long __type; }; - - template<> - struct __make_signed - { typedef signed long long __type; }; -# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_signed_selector; - - template - class __make_signed_selector<_Tp, true, false> - { - using __signed_type - = typename __make_signed<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; - }; - - - template - class __make_signed_selector<_Tp, false, true> - { - typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; - - public: - typedef typename __make_signed_selector<__unsigned_type>::__type __type; - }; - - - - - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; -# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - - - - - - template - struct make_signed - { typedef typename __make_signed_selector<_Tp>::__type type; }; - - - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - - - - template - using make_signed_t = typename make_signed<_Tp>::type; - - - template - using make_unsigned_t = typename make_unsigned<_Tp>::type; - - - - - - template - struct remove_extent - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[_Size]> - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[]> - { typedef _Tp type; }; - - - template - struct remove_all_extents - { typedef _Tp type; }; - - template - struct remove_all_extents<_Tp[_Size]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - template - struct remove_all_extents<_Tp[]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - - - template - using remove_extent_t = typename remove_extent<_Tp>::type; - - - template - using remove_all_extents_t = typename remove_all_extents<_Tp>::type; - - - - - template - struct __remove_pointer_helper - { typedef _Tp type; }; - - template - struct __remove_pointer_helper<_Tp, _Up*> - { typedef _Up type; }; - - - template - struct remove_pointer - : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> - { }; - - template - struct __add_pointer_helper - { using type = _Tp; }; - - template - struct __add_pointer_helper<_Tp, __void_t<_Tp*>> - { using type = _Tp*; }; - - - template - struct add_pointer - : public __add_pointer_helper<_Tp> - { }; - - template - struct add_pointer<_Tp&> - { using type = _Tp*; }; - - template - struct add_pointer<_Tp&&> - { using type = _Tp*; }; - - - - template - using remove_pointer_t = typename remove_pointer<_Tp>::type; - - - template - using add_pointer_t = typename add_pointer<_Tp>::type; - - - template - struct __aligned_storage_msa - { - union __type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__)) { } __align; - }; - }; -# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::__type)> - struct - - aligned_storage - { - union type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__((_Align)))) { } __align; - }; - }; - - template - struct __strictest_alignment - { - static const size_t _S_alignment = 0; - static const size_t _S_size = 0; - }; - - template - struct __strictest_alignment<_Tp, _Types...> - { - static const size_t _S_alignment = - alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment - ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; - static const size_t _S_size = - sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size - ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -#pragma GCC diagnostic pop - - - - - - template - struct __decay_selector - : __conditional_t::value, - remove_cv<_Up>, - add_pointer<_Up>> - { }; - - template - struct __decay_selector<_Up[_Nm]> - { using type = _Up*; }; - - template - struct __decay_selector<_Up[]> - { using type = _Up*; }; - - - - - template - struct decay - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&> - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&&> - { using type = typename __decay_selector<_Tp>::type; }; - - - - - template - struct __strip_reference_wrapper - { - typedef _Tp __type; - }; - - template - struct __strip_reference_wrapper > - { - typedef _Tp& __type; - }; - - - template - using __decay_t = typename decay<_Tp>::type; - - template - using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; - - - - - - template - using _Require = __enable_if_t<__and_<_Cond...>::value>; - - - template - using __remove_cvref_t - = typename remove_cv::type>::type; - - - - - template - struct conditional - { typedef _Iftrue type; }; - - - template - struct conditional - { typedef _Iffalse type; }; - - - template - struct common_type; -# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __success_type - { typedef _Tp type; }; - - struct __failure_type - { }; - - struct __do_common_type_impl - { - template - using __cond_t - = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); - - - - template - static __success_type<__decay_t<__cond_t<_Tp, _Up>>> - _S_test(int); -# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - static __failure_type - _S_test_2(...); - - template - static decltype(_S_test_2<_Tp, _Up>(0)) - _S_test(...); - }; - - - template<> - struct common_type<> - { }; - - - template - struct common_type<_Tp0> - : public common_type<_Tp0, _Tp0> - { }; - - - template, typename _Dp2 = __decay_t<_Tp2>> - struct __common_type_impl - { - - - using type = common_type<_Dp1, _Dp2>; - }; - - template - struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> - : private __do_common_type_impl - { - - - using type = decltype(_S_test<_Tp1, _Tp2>(0)); - }; - - - template - struct common_type<_Tp1, _Tp2> - : public __common_type_impl<_Tp1, _Tp2>::type - { }; - - template - struct __common_type_pack - { }; - - template - struct __common_type_fold; - - - template - struct common_type<_Tp1, _Tp2, _Rp...> - : public __common_type_fold, - __common_type_pack<_Rp...>> - { }; - - - - - template - struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, - __void_t> - : public common_type - { }; - - - template - struct __common_type_fold<_CTp, _Rp, void> - { }; - - template::value> - struct __underlying_type_impl - { - using type = __underlying_type(_Tp); - }; - - template - struct __underlying_type_impl<_Tp, false> - { }; - - - - template - struct underlying_type - : public __underlying_type_impl<_Tp> - { }; - - - template - struct __declval_protector - { - static const bool __stop = false; - }; - - - - - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)) - { - static_assert(__declval_protector<_Tp>::__stop, - "declval() must not be used!"); - return __declval<_Tp>(0); - } - - - template - struct result_of; - - - - - - - struct __invoke_memfun_ref { }; - struct __invoke_memfun_deref { }; - struct __invoke_memobj_ref { }; - struct __invoke_memobj_deref { }; - struct __invoke_other { }; - - - template - struct __result_of_success : __success_type<_Tp> - { using __invoke_type = _Tag; }; - - - struct __result_of_memfun_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_ref - : private __result_of_memfun_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memfun_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_deref - : private __result_of_memfun_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memobj_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>() - ), __invoke_memobj_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_ref - : private __result_of_memobj_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - - struct __result_of_memobj_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>() - ), __invoke_memobj_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_deref - : private __result_of_memobj_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - template - struct __result_of_memobj; - - template - struct __result_of_memobj<_Res _Class::*, _Arg> - { - typedef __remove_cvref_t<_Arg> _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t<__or_, - is_base_of<_Class, _Argval>>::value, - __result_of_memobj_ref<_MemPtr, _Arg>, - __result_of_memobj_deref<_MemPtr, _Arg> - >::type type; - }; - - template - struct __result_of_memfun; - - template - struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> - { - typedef typename remove_reference<_Arg>::type _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t::value, - __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, - __result_of_memfun_deref<_MemPtr, _Arg, _Args...> - >::type type; - }; - - - - - - - template> - struct __inv_unwrap - { - using type = _Tp; - }; - - template - struct __inv_unwrap<_Tp, reference_wrapper<_Up>> - { - using type = _Up&; - }; - - template - struct __result_of_impl - { - typedef __failure_type type; - }; - - template - struct __result_of_impl - : public __result_of_memobj<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type> - { }; - - template - struct __result_of_impl - : public __result_of_memfun<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type, _Args...> - { }; - - - struct __result_of_other_impl - { - template - static __result_of_success()(std::declval<_Args>()...) - ), __invoke_other> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_impl - : private __result_of_other_impl - { - typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; - }; - - - template - struct __invoke_result - : public __result_of_impl< - is_member_object_pointer< - typename remove_reference<_Functor>::type - >::value, - is_member_function_pointer< - typename remove_reference<_Functor>::type - >::value, - _Functor, _ArgTypes... - >::type - { }; - - - template - struct result_of<_Functor(_ArgTypes...)> - : public __invoke_result<_Functor, _ArgTypes...> - { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template::__type)> - using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; - - template - using aligned_union_t = typename aligned_union<_Len, _Types...>::type; -#pragma GCC diagnostic pop - - - template - using decay_t = typename decay<_Tp>::type; - - - template - using enable_if_t = typename enable_if<_Cond, _Tp>::type; - - - template - using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; - - - template - using common_type_t = typename common_type<_Tp...>::type; - - - template - using underlying_type_t = typename underlying_type<_Tp>::type; - - - template - using result_of_t = typename result_of<_Tp>::type; - - - - - - template using void_t = void; -# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template class _Op, typename... _Args> - struct __detector - { - using type = _Default; - using __is_detected = false_type; - }; - - - template class _Op, - typename... _Args> - struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> - { - using type = _Op<_Args...>; - using __is_detected = true_type; - }; - - template class _Op, - typename... _Args> - using __detected_or = __detector<_Default, void, _Op, _Args...>; - - - - template class _Op, - typename... _Args> - using __detected_or_t - = typename __detected_or<_Default, _Op, _Args...>::type; -# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __is_swappable; - - template - struct __is_nothrow_swappable; - - template - struct __is_tuple_like_impl : false_type - { }; - - - template - struct __is_tuple_like - : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type - { }; - - - template - - inline - _Require<__not_<__is_tuple_like<_Tp>>, - is_move_constructible<_Tp>, - is_move_assignable<_Tp>> - swap(_Tp&, _Tp&) - noexcept(__and_, - is_nothrow_move_assignable<_Tp>>::value); - - template - - inline - __enable_if_t<__is_swappable<_Tp>::value> - swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(__is_nothrow_swappable<_Tp>::value); - - - namespace __swappable_details { - using std::swap; - - struct __do_is_swappable_impl - { - template(), std::declval<_Tp&>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_impl - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_nothrow_swappable_impl - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_swappable - : public __is_swappable_impl<_Tp>::type - { }; - - template - struct __is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { }; - - - - - - - - template - struct is_swappable - : public __is_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_v = - is_swappable<_Tp>::value; - - - template - inline constexpr bool is_nothrow_swappable_v = - is_nothrow_swappable<_Tp>::value; - - - - namespace __swappable_with_details { - using std::swap; - - struct __do_is_swappable_with_impl - { - template(), std::declval<_Up>())), - typename - = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_with_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) - && - noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_with_impl - : public __swappable_with_details::__do_is_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - template - struct __is_nothrow_swappable_with_impl - : public __swappable_with_details::__do_is_nothrow_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - - - template - struct is_swappable_with - : public __is_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable_with - : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_with_v = - is_swappable_with<_Tp, _Up>::value; - - - template - inline constexpr bool is_nothrow_swappable_with_v = - is_nothrow_swappable_with<_Tp, _Up>::value; -# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, typename = void> - struct __is_invocable_impl - : false_type - { - using __nothrow_conv = false_type; - }; - - - template - struct __is_invocable_impl<_Result, _Ret, - true, - __void_t> - : true_type - { - using __nothrow_conv = true_type; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - - template - struct __is_invocable_impl<_Result, _Ret, - false, - __void_t> - { - private: - - using _Res_t = typename _Result::type; - - - - static _Res_t _S_get() noexcept; - - - template - static void _S_conv(__type_identity_t<_Tp>) noexcept; - - - template(_S_get())), - typename = decltype(_S_conv<_Tp>(_S_get())), - - - - bool _Dangle = false - - > - static __bool_constant<_Nothrow && !_Dangle> - _S_test(int); - - template - static false_type - _S_test(...); - - public: - - using type = decltype(_S_test<_Ret, true>(1)); - - - using __nothrow_conv = decltype(_S_test<_Ret>(1)); - }; -#pragma GCC diagnostic pop - - template - struct __is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { }; - - template - constexpr bool __call_is_nt(__invoke_memfun_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept((std::declval<_Up>().*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memfun_deref) - { - return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept(std::declval<_Up>().*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_deref) - { - return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_other) - { - return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); - } - - template - struct __call_is_nothrow - : __bool_constant< - std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) - > - { }; - - template - using __call_is_nothrow_ - = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; - - - template - struct __is_nothrow_invocable - : __and_<__is_invocable<_Fn, _Args...>, - __call_is_nothrow_<_Fn, _Args...>>::type - { }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - struct __nonesuchbase {}; - struct __nonesuch : private __nonesuchbase { - ~__nonesuch() = delete; - __nonesuch(__nonesuch const&) = delete; - void operator=(__nonesuch const&) = delete; - }; -#pragma GCC diagnostic pop - - - - - - - template - struct invoke_result - : public __invoke_result<_Functor, _ArgTypes...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), - "_Functor must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; - - - template - struct is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - struct is_invocable_r - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_invocable - : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - - - - template - using __is_nt_invocable_impl - = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; - - - - template - struct is_nothrow_invocable_r - : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; -# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -template - inline constexpr bool is_void_v = is_void<_Tp>::value; -template - inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; -template - inline constexpr bool is_integral_v = is_integral<_Tp>::value; -template - inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; - -template - inline constexpr bool is_array_v = false; -template - inline constexpr bool is_array_v<_Tp[]> = true; -template - inline constexpr bool is_array_v<_Tp[_Num]> = true; - -template - inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; -template - inline constexpr bool is_lvalue_reference_v = false; -template - inline constexpr bool is_lvalue_reference_v<_Tp&> = true; -template - inline constexpr bool is_rvalue_reference_v = false; -template - inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; -template - inline constexpr bool is_member_object_pointer_v = - is_member_object_pointer<_Tp>::value; -template - inline constexpr bool is_member_function_pointer_v = - is_member_function_pointer<_Tp>::value; -template - inline constexpr bool is_enum_v = __is_enum(_Tp); -template - inline constexpr bool is_union_v = __is_union(_Tp); -template - inline constexpr bool is_class_v = __is_class(_Tp); -template - inline constexpr bool is_function_v = is_function<_Tp>::value; -template - inline constexpr bool is_reference_v = false; -template - inline constexpr bool is_reference_v<_Tp&> = true; -template - inline constexpr bool is_reference_v<_Tp&&> = true; -template - inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; -template - inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; -template - inline constexpr bool is_object_v = is_object<_Tp>::value; -template - inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; -template - inline constexpr bool is_compound_v = is_compound<_Tp>::value; -template - inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; -template - inline constexpr bool is_const_v = false; -template - inline constexpr bool is_const_v = true; -template - inline constexpr bool is_volatile_v = false; -template - inline constexpr bool is_volatile_v = true; - -template - inline constexpr bool is_trivial_v = __is_trivial(_Tp); -template - inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); -template - inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); -template - - inline constexpr bool is_pod_v = __is_pod(_Tp); -template - [[__deprecated__]] - inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); -template - inline constexpr bool is_empty_v = __is_empty(_Tp); -template - inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); -template - inline constexpr bool is_abstract_v = __is_abstract(_Tp); -template - inline constexpr bool is_final_v = __is_final(_Tp); - -template - inline constexpr bool is_signed_v = is_signed<_Tp>::value; -template - inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; - -template - inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); -template - inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); -template - inline constexpr bool is_copy_constructible_v - = __is_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_move_constructible_v - = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); -template - inline constexpr bool is_copy_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); -template - inline constexpr bool is_move_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; - -template - inline constexpr bool is_trivially_constructible_v - = __is_trivially_constructible(_Tp, _Args...); -template - inline constexpr bool is_trivially_default_constructible_v - = __is_trivially_constructible(_Tp); -template - inline constexpr bool is_trivially_copy_constructible_v - = __is_trivially_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_constructible_v - = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_trivially_assignable_v - = __is_trivially_assignable(_Tp, _Up); -template - inline constexpr bool is_trivially_copy_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>); -template - inline constexpr bool is_trivially_destructible_v = - is_trivially_destructible<_Tp>::value; -template - inline constexpr bool is_nothrow_constructible_v - = __is_nothrow_constructible(_Tp, _Args...); -template - inline constexpr bool is_nothrow_default_constructible_v - = __is_nothrow_constructible(_Tp); -template - inline constexpr bool is_nothrow_copy_constructible_v - = __is_nothrow_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_constructible_v - = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_assignable_v - = __is_nothrow_assignable(_Tp, _Up); -template - inline constexpr bool is_nothrow_copy_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_destructible_v = - is_nothrow_destructible<_Tp>::value; - -template - inline constexpr bool has_virtual_destructor_v - = __has_virtual_destructor(_Tp); - -template - inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; - -template - inline constexpr size_t rank_v = 0; -template - inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; -template - inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; - -template - inline constexpr size_t extent_v = 0; -template - inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; -template - inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; -template - inline constexpr size_t extent_v<_Tp[], 0> = 0; -template - inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; - - -template - inline constexpr bool is_same_v = __is_same(_Tp, _Up); - - - - - - -template - inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); -template - inline constexpr bool is_convertible_v = __is_convertible(_From, _To); -template - inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_v - = is_nothrow_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_invocable_r_v - = is_invocable_r<_Ret, _Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_r_v - = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; - - - - - - - template - struct has_unique_object_representations - : bool_constant<__has_unique_object_representations( - remove_cv_t> - )> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - inline constexpr bool has_unique_object_representations_v - = has_unique_object_representations<_Tp>::value; - - - - - - - template - struct is_aggregate - : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> - { }; - - - - - - template - inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); -# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - void - __throw_bad_exception(void) __attribute__((__noreturn__)); - - - void - __throw_bad_alloc(void) __attribute__((__noreturn__)); - - void - __throw_bad_array_new_length(void) __attribute__((__noreturn__)); - - - void - __throw_bad_cast(void) __attribute__((__noreturn__)); - - void - __throw_bad_typeid(void) __attribute__((__noreturn__)); - - - void - __throw_logic_error(const char*) __attribute__((__noreturn__)); - - void - __throw_domain_error(const char*) __attribute__((__noreturn__)); - - void - __throw_invalid_argument(const char*) __attribute__((__noreturn__)); - - void - __throw_length_error(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) - __attribute__((__format__(__gnu_printf__, 1, 2))); - - void - __throw_runtime_error(const char*) __attribute__((__noreturn__)); - - void - __throw_range_error(const char*) __attribute__((__noreturn__)); - - void - __throw_overflow_error(const char*) __attribute__((__noreturn__)); - - void - __throw_underflow_error(const char*) __attribute__((__noreturn__)); - - - void - __throw_ios_failure(const char*) __attribute__((__noreturn__)); - - void - __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); - - - void - __throw_system_error(int) __attribute__((__noreturn__)); - - - void - __throw_future_error(int) __attribute__((__noreturn__)); - - - void - __throw_bad_function_call() __attribute__((__noreturn__)); -# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - struct __true_type { }; - struct __false_type { }; - - template - struct __truth_type - { typedef __false_type __type; }; - - template<> - struct __truth_type - { typedef __true_type __type; }; - - - - template - struct __traitor - { - enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; - typedef typename __truth_type<__value>::__type __type; - }; - - - template - struct __are_same - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __are_same<_Tp, _Tp> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_void - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_void - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_integer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; - }; -# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template - struct __is_pointer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __is_pointer<_Tp*> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_arithmetic - : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > - { }; - - - - - template - struct __is_scalar - : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > - { }; - - - - - template - struct __is_char - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_byte - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - enum class byte : unsigned char; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template struct iterator_traits; - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = __is_trivially_copyable(_Tp) }; - }; - - - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = 0 }; - }; - - - template - struct __memcpyable - { - enum { __value = 0 }; - }; - - template - struct __memcpyable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcpyable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - template - struct __memcmpable - { - enum { __value = 0 }; - }; - - - template - struct __memcmpable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - - template::__value - - > - struct __is_memcmp_ordered - { - static const bool __value = _Tp(-1) > _Tp(1); - }; - - template - struct __is_memcmp_ordered<_Tp, false> - { - static const bool __value = false; - }; - - - template - struct __is_memcmp_ordered_with - { - static const bool __value = __is_memcmp_ordered<_Tp>::__value - && __is_memcmp_ordered<_Up>::__value; - }; - - template - struct __is_memcmp_ordered_with<_Tp, _Up, false> - { - static const bool __value = false; - }; -# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_memcmp_ordered_with - { static constexpr bool __value = true; }; - - template - struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> - { static constexpr bool __value = false; }; - - template - struct __is_memcmp_ordered_with - { static constexpr bool __value = false; }; - - - - - - template - struct __is_move_iterator - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - template - - inline _Iterator - __miter_base(_Iterator __it) - { return __it; } - - -} -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - - - - -extern "C++" { - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct __enable_if - { }; - - template - struct __enable_if - { typedef _Tp __type; }; - - - - template - struct __conditional_type - { typedef _Iftrue __type; }; - - template - struct __conditional_type - { typedef _Iffalse __type; }; - - - - template - struct __add_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned short __type; }; - - template<> - struct __add_unsigned - { typedef unsigned int __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long long __type; }; - - - template<> - struct __add_unsigned; - - template<> - struct __add_unsigned; - - - - template - struct __remove_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef short __type; }; - - template<> - struct __remove_unsigned - { typedef int __type; }; - - template<> - struct __remove_unsigned - { typedef long __type; }; - - template<> - struct __remove_unsigned - { typedef long long __type; }; - - - template<> - struct __remove_unsigned; - - template<> - struct __remove_unsigned; - - - - template - constexpr - inline bool - __is_null_pointer(_Type* __ptr) - { return __ptr == 0; } - - template - constexpr - inline bool - __is_null_pointer(_Type) - { return false; } - - - constexpr bool - __is_null_pointer(std::nullptr_t) - { return true; } - - - - - template::__value> - struct __promote - { typedef double __type; }; - - - - - template - struct __promote<_Tp, false> - { }; - - template<> - struct __promote - { typedef long double __type; }; - - template<> - struct __promote - { typedef double __type; }; - - template<> - struct __promote - { typedef float __type; }; -# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - template - using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); - - - - template - using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; - - template - using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; - - template - using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 -} -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - - - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __is_integer_nonstrict - : public std::__is_integer<_Tp> - { - using std::__is_integer<_Tp>::__value; - - - enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; - }; - - template - struct __numeric_traits_integer - { - - static_assert(__is_integer_nonstrict<_Value>::__value, - "invalid specialization"); - - - - - static const bool __is_signed = (_Value)(-1) < 0; - static const int __digits - = __is_integer_nonstrict<_Value>::__width - __is_signed; - - - static const _Value __max = __is_signed - ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) - : ~(_Value)0; - static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; - }; - - template - const _Value __numeric_traits_integer<_Value>::__min; - - template - const _Value __numeric_traits_integer<_Value>::__max; - - template - const bool __numeric_traits_integer<_Value>::__is_signed; - - template - const int __numeric_traits_integer<_Value>::__digits; -# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; - - - - - - - template - using __int_traits = __numeric_traits_integer<_Tp>; -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __numeric_traits_floating - { - - static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); - - - static const bool __is_signed = true; - static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); - static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); - }; - - template - const int __numeric_traits_floating<_Value>::__max_digits10; - - template - const bool __numeric_traits_floating<_Value>::__is_signed; - - template - const int __numeric_traits_floating<_Value>::__digits10; - - template - const int __numeric_traits_floating<_Value>::__max_exponent10; - - - - - - - template - struct __numeric_traits - : public __numeric_traits_integer<_Value> - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; -# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 -} -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - inline constexpr _Tp* - __addressof(_Tp& __r) noexcept - { return __builtin_addressof(__r); } -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type& __t) noexcept - { return static_cast<_Tp&&>(__t); } - - - - - - - - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type&& __t) noexcept - { - static_assert(!std::is_lvalue_reference<_Tp>::value, - "std::forward must not be used to convert an rvalue to an lvalue"); - return static_cast<_Tp&&>(__t); - } - - - - - - - template - [[__nodiscard__]] - constexpr typename std::remove_reference<_Tp>::type&& - move(_Tp&& __t) noexcept - { return static_cast::type&&>(__t); } - - - template - struct __move_if_noexcept_cond - : public __and_<__not_>, - is_copy_constructible<_Tp>>::type { }; -# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr - __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> - move_if_noexcept(_Tp& __x) noexcept - { return std::move(__x); } -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - inline constexpr _Tp* - addressof(_Tp& __r) noexcept - { return std::__addressof(__r); } - - - - template - const _Tp* addressof(const _Tp&&) = delete; - - - template - - inline _Tp - __exchange(_Tp& __obj, _Up&& __new_val) - { - _Tp __old_val = std::move(__obj); - __obj = std::forward<_Up>(__new_val); - return __old_val; - } -# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - - inline - - typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, - is_move_constructible<_Tp>, - is_move_assignable<_Tp>>::value>::type - - - - swap(_Tp& __a, _Tp& __b) - noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) - - { - - - - - _Tp __tmp = std::move(__a); - __a = std::move(__b); - __b = std::move(__tmp); - } - - - - - template - - inline - - typename enable_if<__is_swappable<_Tp>::value>::type - - - - swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(__is_nothrow_swappable<_Tp>::value) - { - for (size_t __n = 0; __n < _Nm; ++__n) - swap(__a[__n], __b[__n]); - } - - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct tuple_size; - - - - - - template::type, - typename = typename enable_if::value>::type, - size_t = tuple_size<_Tp>::value> - using __enable_if_has_tuple_size = _Tp; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - - template - inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; - - - - template - struct tuple_element; - - - template - using __tuple_element_t = typename tuple_element<__i, _Tp>::type; - - template - struct tuple_element<__i, const _Tp> - { - using type = const __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, volatile _Tp> - { - using type = volatile __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, const volatile _Tp> - { - using type = const volatile __tuple_element_t<__i, _Tp>; - }; - - - - - - template - constexpr size_t - __find_uniq_type_in_pack() - { - constexpr size_t __sz = sizeof...(_Types); - constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; - size_t __n = __sz; - for (size_t __i = 0; __i < __sz; ++__i) - { - if (__found[__i]) - { - if (__n < __sz) - return __sz; - __n = __i; - } - } - return __n; - } -# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - template - using tuple_element_t = typename tuple_element<__i, _Tp>::type; - - - - - template struct _Index_tuple { }; - - - template - struct _Build_index_tuple - { - - template - using _IdxTuple = _Index_tuple<_Indices...>; - - - using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; - - - - - }; - - - - - - - template - struct integer_sequence - { - typedef _Tp value_type; - static constexpr size_t size() noexcept { return sizeof...(_Idx); } - }; - - - template - using make_integer_sequence - - = __make_integer_seq; - - - - - - template - using index_sequence = integer_sequence; - - - template - using make_index_sequence = make_integer_sequence; - - - template - using index_sequence_for = make_index_sequence; - - - - struct in_place_t { - explicit in_place_t() = default; - }; - - inline constexpr in_place_t in_place{}; - - template struct in_place_type_t - { - explicit in_place_type_t() = default; - }; - - template - inline constexpr in_place_type_t<_Tp> in_place_type{}; - - template struct in_place_index_t - { - explicit in_place_index_t() = default; - }; - - template - inline constexpr in_place_index_t<_Idx> in_place_index{}; - - template - inline constexpr bool __is_in_place_type_v = false; - - template - inline constexpr bool __is_in_place_type_v> = true; - - template - using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; - - - - - template - struct _Nth_type - { }; - - template - struct _Nth_type<0, _Tp0, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Rest...> - { using type = _Tp1; }; - - template - struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp2; }; - - template - - - - struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> - : _Nth_type<_Np - 3, _Rest...> - { }; - - - template - struct _Nth_type<0, _Tp0, _Tp1, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp1; }; - - - - - - - -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; - - - inline constexpr piecewise_construct_t piecewise_construct = - piecewise_construct_t(); - - - - - template - class tuple; - - template - struct _Index_tuple; - - - - - - - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return __and_, - is_constructible<_T2, const _U2&>>::value; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return __and_, - is_convertible>::value; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return __and_, - is_constructible<_T2, _U2&&>>::value; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return __and_, - is_convertible<_U2&&, _T2>>::value; - } - }; - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return false; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return false; - } - }; - - - - template class __pair_base - { - - template friend struct pair; - __pair_base() = default; - ~__pair_base() = default; - __pair_base(const __pair_base&) = default; - __pair_base& operator=(const __pair_base&) = delete; - - }; -# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct pair - : public __pair_base<_T1, _T2> - { - typedef _T1 first_type; - typedef _T2 second_type; - - _T1 first; - _T2 second; - - - constexpr pair(const pair&) = default; - constexpr pair(pair&&) = default; - - template - - pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); - - - void - swap(pair& __p) - noexcept(__and_<__is_nothrow_swappable<_T1>, - __is_nothrow_swappable<_T2>>::value) - { - using std::swap; - swap(first, __p.first); - swap(second, __p.second); - } -# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - template - - pair(tuple<_Args1...>&, tuple<_Args2...>&, - _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); - public: -# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template , - __is_implicitly_default_constructible<_U2>> - ::value, bool>::type = true> - constexpr pair() - : first(), second() { } - - template , - is_default_constructible<_U2>, - __not_< - __and_<__is_implicitly_default_constructible<_U1>, - __is_implicitly_default_constructible<_U2>>>> - ::value, bool>::type = false> - explicit constexpr pair() - : first(), second() { } - - - - using _PCCP = _PCC; - - - - template() - && _PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - template() - && !_PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - - template - using _PCCFP = _PCC::value - || !is_same<_T2, _U2>::value, - _T1, _T2>; - - - template::template - _ConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } - - template::template - _ConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } -# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - - - - struct __zero_as_null_pointer_constant - { - __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) - { } - template::value>> - __zero_as_null_pointer_constant(_Tp) = delete; - }; - - public: - - - - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - is_convertible<_U1, _T1>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - is_convertible<_U2, _T2>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - - - template() - && _PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - template() - && !_PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - - template::template - _MoveConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - template::template - _MoveConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - - - pair& - operator=(__conditional_t<__and_, - is_copy_assignable<_T2>>::value, - const pair&, const __nonesuch&> __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - pair& - operator=(__conditional_t<__and_, - is_move_assignable<_T2>>::value, - pair&&, __nonesuch&&> __p) - noexcept(__and_, - is_nothrow_move_assignable<_T2>>::value) - { - first = std::forward(__p.first); - second = std::forward(__p.second); - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, const _U2&>>::value, - pair&>::type - operator=(const pair<_U1, _U2>& __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, _U2&&>>::value, - pair&>::type - operator=(pair<_U1, _U2>&& __p) - { - first = std::forward<_U1>(__p.first); - second = std::forward<_U2>(__p.second); - return *this; - } -# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - }; - - - - - template pair(_T1, _T2) -> pair<_T1, _T2>; - - - - template - inline constexpr bool - operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first == __y.first && __x.second == __y.second; } -# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline constexpr bool - operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first < __y.first - || (!(__y.first < __x.first) && __x.second < __y.second); } - - - template - inline constexpr bool - operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x == __y); } - - - template - inline constexpr bool - operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __y < __x; } - - - template - inline constexpr bool - operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__y < __x); } - - - template - inline constexpr bool - operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x < __y); } -# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline - - - typename enable_if<__and_<__is_swappable<_T1>, - __is_swappable<_T2>>::value>::type - - - - swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } -# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - typename enable_if, - __is_swappable<_T2>>::value>::type - swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; -# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - constexpr pair::__type, - typename __decay_and_strip<_T2>::__type> - make_pair(_T1&& __x, _T2&& __y) - { - typedef typename __decay_and_strip<_T1>::__type __ds_type1; - typedef typename __decay_and_strip<_T2>::__type __ds_type2; - typedef pair<__ds_type1, __ds_type2> __pair_type; - return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); - } -# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct __is_tuple_like_impl> : true_type - { }; - - - - template - struct tuple_size> - : public integral_constant { }; - - - template - struct tuple_element<0, pair<_Tp1, _Tp2>> - { typedef _Tp1 type; }; - - - template - struct tuple_element<1, pair<_Tp1, _Tp2>> - { typedef _Tp2 type; }; - - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr bool __is_pair = false; - - template - inline constexpr bool __is_pair> = true; - - - - template - struct __pair_get; - - template<> - struct __pair_get<0> - { - template - static constexpr _Tp1& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr _Tp1&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp1>(__pair.first); } - - template - static constexpr const _Tp1& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr const _Tp1&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.first); } - }; - - template<> - struct __pair_get<1> - { - template - static constexpr _Tp2& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr _Tp2&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp2>(__pair.second); } - - template - static constexpr const _Tp2& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr const _Tp2&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.second); } - }; - - - - - - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__get(__in); } - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__move_get(std::move(__in)); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(const pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__const_get(__in); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(const pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__const_move_get(std::move(__in)); } - - - - - - template - constexpr _Tp& - get(pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr const _Tp& - get(const pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr _Tp&& - get(pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr const _Tp&& - get(const pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr _Tp& - get(pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr const _Tp& - get(const pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr _Tp&& - get(pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } - - template - constexpr const _Tp&& - get(const pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } -# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - struct input_iterator_tag { }; - - - struct output_iterator_tag { }; - - - struct forward_iterator_tag : public input_iterator_tag { }; - - - - struct bidirectional_iterator_tag : public forward_iterator_tag { }; - - - - struct random_access_iterator_tag : public bidirectional_iterator_tag { }; -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct [[__deprecated__]] iterator - { - - typedef _Category iterator_category; - - typedef _Tp value_type; - - typedef _Distance difference_type; - - typedef _Pointer pointer; - - typedef _Reference reference; - }; -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits; - - - - - template> - struct __iterator_traits { }; - - - - template - struct __iterator_traits<_Iterator, - __void_t> - { - typedef typename _Iterator::iterator_category iterator_category; - typedef typename _Iterator::value_type value_type; - typedef typename _Iterator::difference_type difference_type; - typedef typename _Iterator::pointer pointer; - typedef typename _Iterator::reference reference; - }; - - - template - struct iterator_traits - : public __iterator_traits<_Iterator> { }; -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits<_Tp*> - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; - }; - - - template - struct iterator_traits - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; - }; - - - - - - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_Iter>::iterator_category - __iterator_category(const _Iter&) - { return typename iterator_traits<_Iter>::iterator_category(); } - - - - - template - using __iterator_category_t - = typename iterator_traits<_Iter>::iterator_category; - - template - using _RequireInputIter = - __enable_if_t, - input_iterator_tag>::value>; - - template> - struct __is_random_access_iter - : is_base_of - { - typedef is_base_of _Base; - enum { __value = _Base::value }; - }; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template struct _List_iterator; - template struct _List_const_iterator; - - - template - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - __distance(_InputIterator __first, _InputIterator __last, - input_iterator_tag) - { - - - - typename iterator_traits<_InputIterator>::difference_type __n = 0; - while (__first != __last) - { - ++__first; - ++__n; - } - return __n; - } - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_RandomAccessIterator>::difference_type - __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, - random_access_iterator_tag) - { - - - - return __last - __first; - } - - - - template - ptrdiff_t - __distance(std::_List_iterator<_Tp>, - std::_List_iterator<_Tp>, - input_iterator_tag); - - template - ptrdiff_t - __distance(std::_List_const_iterator<_Tp>, - std::_List_const_iterator<_Tp>, - input_iterator_tag); - - - - - template - void - __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; -# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - [[__nodiscard__]] __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - distance(_InputIterator __first, _InputIterator __last) - { - - return std::__distance(__first, __last, - std::__iterator_category(__first)); - } - - template - inline constexpr void - __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) - { - - - do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); - while (__n--) - ++__i; - } - - template - inline constexpr void - __advance(_BidirectionalIterator& __i, _Distance __n, - bidirectional_iterator_tag) - { - - - - if (__n > 0) - while (__n--) - ++__i; - else - while (__n++) - --__i; - } - - template - inline constexpr void - __advance(_RandomAccessIterator& __i, _Distance __n, - random_access_iterator_tag) - { - - - - if (__builtin_constant_p(__n) && __n == 1) - ++__i; - else if (__builtin_constant_p(__n) && __n == -1) - --__i; - else - __i += __n; - } - - - - template - void - __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; -# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - __attribute__((__always_inline__)) - inline constexpr void - advance(_InputIterator& __i, _Distance __n) - { - - typename iterator_traits<_InputIterator>::difference_type __d = __n; - std::__advance(__i, __d, std::__iterator_category(__i)); - } - - - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _InputIterator - next(_InputIterator __x, typename - iterator_traits<_InputIterator>::difference_type __n = 1) - { - - - std::advance(__x, __n); - return __x; - } - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _BidirectionalIterator - prev(_BidirectionalIterator __x, typename - iterator_traits<_BidirectionalIterator>::difference_type __n = 1) - { - - - - std::advance(__x, -__n); - return __x; - } - - - - -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 -# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - class __undefined; - - - - template - struct __get_first_arg - { using type = __undefined; }; - - template class _SomeTemplate, typename _Tp, - typename... _Types> - struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> - { using type = _Tp; }; - - - - template - struct __replace_first_arg - { }; - - template class _SomeTemplate, typename _Up, - typename _Tp, typename... _Types> - struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> - { using type = _SomeTemplate<_Up, _Types...>; }; - - - template - struct __ptr_traits_elem : __get_first_arg<_Ptr> - { }; - - - - - - - - template - struct __ptr_traits_elem<_Ptr, __void_t> - { using type = typename _Ptr::element_type; }; - - - template - using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; - - - - - template::value> - struct __ptr_traits_ptr_to - { - using pointer = _Ptr; - using element_type = _Elt; - - - - - - - - static pointer - pointer_to(element_type& __r) - - - - - - { return pointer::pointer_to(__r); } - }; - - - template - struct __ptr_traits_ptr_to<_Ptr, _Elt, true> - { }; - - - template - struct __ptr_traits_ptr_to<_Tp*, _Tp, false> - { - using pointer = _Tp*; - using element_type = _Tp; - - - - - - - static pointer - pointer_to(element_type& __r) noexcept - { return std::addressof(__r); } - }; - - template - struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> - { - private: - template - using __diff_t = typename _Tp::difference_type; - - template - using __rebind = __type_identity>; - - public: - - using pointer = _Ptr; - - - using element_type = _Elt; - - - using difference_type = __detected_or_t; - - - template - using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, - __rebind, _Ptr, _Up>::type; - }; - - - - template - struct __ptr_traits_impl<_Ptr, __undefined> - { }; - - - - - - - - template - struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> - { }; - - - - - - - - template - struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> - { - - typedef _Tp* pointer; - - typedef _Tp element_type; - - typedef ptrdiff_t difference_type; - - template using rebind = _Up*; - }; - - - template - using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; - - template - constexpr _Tp* - __to_address(_Tp* __ptr) noexcept - { - static_assert(!std::is_function<_Tp>::value, "not a function pointer"); - return __ptr; - } - - - template - constexpr typename std::pointer_traits<_Ptr>::element_type* - __to_address(const _Ptr& __ptr) - { return std::__to_address(__ptr.operator->()); } -# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 -# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class reverse_iterator - : public iterator::iterator_category, - typename iterator_traits<_Iterator>::value_type, - typename iterator_traits<_Iterator>::difference_type, - typename iterator_traits<_Iterator>::pointer, - typename iterator_traits<_Iterator>::reference> - { - template - friend class reverse_iterator; -# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - protected: - _Iterator current; - - typedef iterator_traits<_Iterator> __traits_type; - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::pointer pointer; - - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - constexpr - reverse_iterator() - noexcept(noexcept(_Iterator())) - : current() - { } - - - - - explicit constexpr - reverse_iterator(iterator_type __x) - noexcept(noexcept(_Iterator(__x))) - : current(__x) - { } - - - - - constexpr - reverse_iterator(const reverse_iterator& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - reverse_iterator& operator=(const reverse_iterator&) = default; - - - - - - - template - - - - constexpr - reverse_iterator(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - template - - - - - constexpr - reverse_iterator& - operator=(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(current = __x.current)) - { - current = __x.current; - return *this; - } - - - - - - [[__nodiscard__]] - constexpr iterator_type - base() const - noexcept(noexcept(_Iterator(current))) - { return current; } -# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - { - _Iterator __tmp = current; - return *--__tmp; - } - - - - - - - [[__nodiscard__]] - constexpr pointer - operator->() const - - - - - { - - - _Iterator __tmp = current; - --__tmp; - return _S_to_pointer(__tmp); - } - - - - - - - constexpr reverse_iterator& - operator++() - { - --current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator++(int) - { - reverse_iterator __tmp = *this; - --current; - return __tmp; - } - - - - - - - constexpr reverse_iterator& - operator--() - { - ++current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator--(int) - { - reverse_iterator __tmp = *this; - ++current; - return __tmp; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator+(difference_type __n) const - { return reverse_iterator(current - __n); } - - - - - - - - constexpr reverse_iterator& - operator+=(difference_type __n) - { - current -= __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator-(difference_type __n) const - { return reverse_iterator(current + __n); } - - - - - - - - constexpr reverse_iterator& - operator-=(difference_type __n) - { - current += __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - { return *(*this + __n); } -# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - private: - template - static constexpr _Tp* - _S_to_pointer(_Tp* __p) - { return __p; } - - template - static constexpr pointer - _S_to_pointer(_Tp __t) - { return __t.operator->(); } - }; -# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y.base() < __x.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() > __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() != __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() < __y.base(); } - - template - inline constexpr bool - operator<=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() >= __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() <= __y.base(); } -# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr auto - operator-(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - -> decltype(__y.base() - __x.base()) - { return __y.base() - __x.base(); } - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - operator+(typename reverse_iterator<_Iterator>::difference_type __n, - const reverse_iterator<_Iterator>& __x) - { return reverse_iterator<_Iterator>(__x.base() - __n); } - - - - template - inline constexpr reverse_iterator<_Iterator> - __make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } - - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } -# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) - { return __make_reverse_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - : __is_move_iterator<_Iterator> - { }; - - template - - auto - __miter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) - { return __make_reverse_iterator(__miter_base(__it.base())); } -# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class back_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - back_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - back_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_back(__value); - return *this; - } - - - back_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_back(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - back_insert_iterator& - operator*() - { return *this; } - - - - back_insert_iterator& - operator++() - { return *this; } - - - - back_insert_iterator - operator++(int) - { return *this; } - }; -# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline back_insert_iterator<_Container> - back_inserter(_Container& __x) - { return back_insert_iterator<_Container>(__x); } -# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class front_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - front_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - front_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_front(__value); - return *this; - } - - - front_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_front(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - front_insert_iterator& - operator*() - { return *this; } - - - - front_insert_iterator& - operator++() - { return *this; } - - - - front_insert_iterator - operator++(int) - { return *this; } - }; -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline front_insert_iterator<_Container> - front_inserter(_Container& __x) - { return front_insert_iterator<_Container>(__x); } -# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class insert_iterator - : public iterator - { - - - - typedef typename _Container::iterator _Iter; - - protected: - _Container* container; - _Iter iter; - - public: - - typedef _Container container_type; -# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator(_Container& __x, _Iter __i) - : container(std::__addressof(__x)), iter(__i) {} -# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator& - operator=(const typename _Container::value_type& __value) - { - iter = container->insert(iter, __value); - ++iter; - return *this; - } - - - insert_iterator& - operator=(typename _Container::value_type&& __value) - { - iter = container->insert(iter, std::move(__value)); - ++iter; - return *this; - } - - - - [[__nodiscard__]] - insert_iterator& - operator*() - { return *this; } - - - - insert_iterator& - operator++() - { return *this; } - - - - insert_iterator& - operator++(int) - { return *this; } - }; - -#pragma GCC diagnostic pop -# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline insert_iterator<_Container> - inserter(_Container& __x, typename _Container::iterator __i) - { return insert_iterator<_Container>(__x, __i); } - - - - - -} - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class __normal_iterator - { - protected: - _Iterator _M_current; - - typedef std::iterator_traits<_Iterator> __traits_type; - - - template - using __convertible_from - = std::__enable_if_t::value>; - - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; - typedef typename __traits_type::pointer pointer; - - - - - - constexpr __normal_iterator() noexcept - : _M_current(_Iterator()) { } - - explicit - __normal_iterator(const _Iterator& __i) noexcept - : _M_current(__i) { } - - - - template> - - __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) - noexcept -# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - : _M_current(__i.base()) { } - - - - reference - operator*() const noexcept - { return *_M_current; } - - - pointer - operator->() const noexcept - { return _M_current; } - - - __normal_iterator& - operator++() noexcept - { - ++_M_current; - return *this; - } - - - __normal_iterator - operator++(int) noexcept - { return __normal_iterator(_M_current++); } - - - - __normal_iterator& - operator--() noexcept - { - --_M_current; - return *this; - } - - - __normal_iterator - operator--(int) noexcept - { return __normal_iterator(_M_current--); } - - - - reference - operator[](difference_type __n) const noexcept - { return _M_current[__n]; } - - - __normal_iterator& - operator+=(difference_type __n) noexcept - { _M_current += __n; return *this; } - - - __normal_iterator - operator+(difference_type __n) const noexcept - { return __normal_iterator(_M_current + __n); } - - - __normal_iterator& - operator-=(difference_type __n) noexcept - { _M_current -= __n; return *this; } - - - __normal_iterator - operator-(difference_type __n) const noexcept - { return __normal_iterator(_M_current - __n); } - - - const _Iterator& - base() const noexcept - { return _M_current; } - }; -# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - - - - - - template - - - [[__nodiscard__]] - inline auto - operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept - -> decltype(__lhs.base() - __rhs.base()) - - - - - - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline typename __normal_iterator<_Iterator, _Container>::difference_type - operator-(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline __normal_iterator<_Iterator, _Container> - operator+(typename __normal_iterator<_Iterator, _Container>::difference_type - __n, const __normal_iterator<_Iterator, _Container>& __i) - noexcept - { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } - - -} - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - - _Iterator - __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it.base(); } - - - - - - - template - constexpr auto - __to_address(const __gnu_cxx::__normal_iterator<_Iterator, - _Container>& __it) noexcept - -> decltype(std::__to_address(__it.base())) - { return std::__to_address(__it.base()); } -# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - namespace __detail - { -# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - } -# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class move_iterator - - - - { - _Iterator _M_current; - - using __traits_type = iterator_traits<_Iterator>; - - using __base_ref = typename __traits_type::reference; - - - template - friend class move_iterator; -# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - public: - using iterator_type = _Iterator; -# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - - typedef _Iterator pointer; - - - using reference - = __conditional_t::value, - typename remove_reference<__base_ref>::type&&, - __base_ref>; - - - constexpr - move_iterator() - : _M_current() { } - - explicit constexpr - move_iterator(iterator_type __i) - : _M_current(std::move(__i)) { } - - template - - - - constexpr - move_iterator(const move_iterator<_Iter>& __i) - : _M_current(__i._M_current) { } - - template - - - - - constexpr - move_iterator& operator=(const move_iterator<_Iter>& __i) - { - _M_current = __i._M_current; - return *this; - } - - - [[__nodiscard__]] - constexpr iterator_type - base() const - { return _M_current; } -# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - - - - { return static_cast(*_M_current); } - - - [[__nodiscard__]] - constexpr pointer - operator->() const - { return _M_current; } - - constexpr move_iterator& - operator++() - { - ++_M_current; - return *this; - } - - constexpr move_iterator - operator++(int) - { - move_iterator __tmp = *this; - ++_M_current; - return __tmp; - } - - - - - - - - constexpr move_iterator& - operator--() - { - --_M_current; - return *this; - } - - constexpr move_iterator - operator--(int) - { - move_iterator __tmp = *this; - --_M_current; - return __tmp; - } - - [[__nodiscard__]] - constexpr move_iterator - operator+(difference_type __n) const - { return move_iterator(_M_current + __n); } - - constexpr move_iterator& - operator+=(difference_type __n) - { - _M_current += __n; - return *this; - } - - [[__nodiscard__]] - constexpr move_iterator - operator-(difference_type __n) const - { return move_iterator(_M_current - __n); } - - constexpr move_iterator& - operator-=(difference_type __n) - { - _M_current -= __n; - return *this; - } - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - - - - { return std::move(_M_current[__n]); } -# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - }; - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() == __y.base(); } -# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - { return !(__x == __y); } - - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } -# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - template - [[__nodiscard__]] - inline constexpr auto - operator-(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - -> decltype(__x.base() - __y.base()) - { return __x.base() - __y.base(); } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - operator+(typename move_iterator<_Iterator>::difference_type __n, - const move_iterator<_Iterator>& __x) - { return __x + __n; } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - make_move_iterator(_Iterator __i) - { return move_iterator<_Iterator>(std::move(__i)); } - - template::value_type>::value, - _Iterator, move_iterator<_Iterator>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Iterator __i) - { return _ReturnType(__i); } - - - - template::value, - const _Tp*, move_iterator<_Tp*>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Tp* __i) - { return _ReturnType(__i); } -# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(move_iterator<_Iterator> __it) - -> decltype(make_move_iterator(__niter_base(__it.base()))) - { return make_move_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template - - auto - __miter_base(move_iterator<_Iterator> __it) - -> decltype(__miter_base(__it.base())) - { return __miter_base(__it.base()); } -# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - using __iter_key_t = remove_const_t< - typename iterator_traits<_InputIterator>::value_type::first_type>; - - template - using __iter_val_t - = typename iterator_traits<_InputIterator>::value_type::second_type; - - template - struct pair; - - template - using __iter_to_alloc_t - = pair, __iter_val_t<_InputIterator>>; - - - -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 -namespace std -{ - namespace __debug { } -} - - - - -namespace __gnu_debug -{ - using namespace std::__debug; - - template - struct _Safe_iterator; -} -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 -namespace __gnu_cxx -{ -namespace __ops -{ - struct _Iter_less_iter - { - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 < *__it2; } - }; - - constexpr - inline _Iter_less_iter - __iter_less_iter() - { return _Iter_less_iter(); } - - struct _Iter_less_val - { - - constexpr _Iter_less_val() = default; - - - - - - explicit - _Iter_less_val(_Iter_less_iter) { } - - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it < __val; } - }; - - - inline _Iter_less_val - __iter_less_val() - { return _Iter_less_val(); } - - - inline _Iter_less_val - __iter_comp_val(_Iter_less_iter) - { return _Iter_less_val(); } - - struct _Val_less_iter - { - - constexpr _Val_less_iter() = default; - - - - - - explicit - _Val_less_iter(_Iter_less_iter) { } - - template - - bool - operator()(_Value& __val, _Iterator __it) const - { return __val < *__it; } - }; - - - inline _Val_less_iter - __val_less_iter() - { return _Val_less_iter(); } - - - inline _Val_less_iter - __val_comp_iter(_Iter_less_iter) - { return _Val_less_iter(); } - - struct _Iter_equal_to_iter - { - template - - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 == *__it2; } - }; - - - inline _Iter_equal_to_iter - __iter_equal_to_iter() - { return _Iter_equal_to_iter(); } - - struct _Iter_equal_to_val - { - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it == __val; } - }; - - - inline _Iter_equal_to_val - __iter_equal_to_val() - { return _Iter_equal_to_val(); } - - - inline _Iter_equal_to_val - __iter_comp_val(_Iter_equal_to_iter) - { return _Iter_equal_to_val(); } - - template - struct _Iter_comp_iter - { - _Compare _M_comp; - - explicit constexpr - _Iter_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) - { return bool(_M_comp(*__it1, *__it2)); } - }; - - template - constexpr - inline _Iter_comp_iter<_Compare> - __iter_comp_iter(_Compare __comp) - { return _Iter_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_comp_val - { - _Compare _M_comp; - - - explicit - _Iter_comp_val(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Iterator __it, _Value& __val) - { return bool(_M_comp(*__it, __val)); } - }; - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Compare __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Iter_comp_iter<_Compare> __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - struct _Val_comp_iter - { - _Compare _M_comp; - - - explicit - _Val_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Value& __val, _Iterator __it) - { return bool(_M_comp(__val, *__it)); } - }; - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Compare __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Iter_comp_iter<_Compare> __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_equals_val - { - _Value& _M_value; - - - explicit - _Iter_equals_val(_Value& __value) - : _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return *__it == _M_value; } - }; - - template - - inline _Iter_equals_val<_Value> - __iter_equals_val(_Value& __val) - { return _Iter_equals_val<_Value>(__val); } - - template - struct _Iter_equals_iter - { - _Iterator1 _M_it1; - - - explicit - _Iter_equals_iter(_Iterator1 __it1) - : _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return *__it2 == *_M_it1; } - }; - - template - - inline _Iter_equals_iter<_Iterator> - __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) - { return _Iter_equals_iter<_Iterator>(__it); } - - template - struct _Iter_pred - { - _Predicate _M_pred; - - - explicit - _Iter_pred(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_pred<_Predicate> - __pred_iter(_Predicate __pred) - { return _Iter_pred<_Predicate>(std::move(__pred)); } - - template - struct _Iter_comp_to_val - { - _Compare _M_comp; - _Value& _M_value; - - - _Iter_comp_to_val(_Compare __comp, _Value& __value) - : _M_comp(std::move(__comp)), _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_comp(*__it, _M_value)); } - }; - - template - _Iter_comp_to_val<_Compare, _Value> - - __iter_comp_val(_Compare __comp, _Value &__val) - { - return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); - } - - template - struct _Iter_comp_to_iter - { - _Compare _M_comp; - _Iterator1 _M_it1; - - - _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) - : _M_comp(std::move(__comp)), _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return bool(_M_comp(*__it2, *_M_it1)); } - }; - - template - - inline _Iter_comp_to_iter<_Compare, _Iterator> - __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) - { - return _Iter_comp_to_iter<_Compare, _Iterator>( - std::move(__comp._M_comp), __it); - } - - template - struct _Iter_negate - { - _Predicate _M_pred; - - - explicit - _Iter_negate(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return !bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_negate<_Predicate> - __negate(_Iter_pred<_Predicate> __pred) - { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } - -} -} -# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 - template - constexpr _Tp - __rotl(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); - else - return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); - } - - template - constexpr _Tp - __rotr(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); - else - return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); - } - - template - constexpr int - __countl_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - { - constexpr int __diff = _Nd_u - _Nd; - return __builtin_clz(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ul) - { - constexpr int __diff = _Nd_ul - _Nd; - return __builtin_clzl(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ull) - { - constexpr int __diff = _Nd_ull - _Nd; - return __builtin_clzll(__x) - __diff; - } - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - unsigned long long __high = __x >> _Nd_ull; - if (__high != 0) - { - constexpr int __diff = (2 * _Nd_ull) - _Nd; - return __builtin_clzll(__high) - __diff; - } - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - return (_Nd - _Nd_ull) + __builtin_clzll(__low); - } - } - - template - constexpr int - __countl_one(_Tp __x) noexcept - { - return std::__countl_zero<_Tp>((_Tp)~__x); - } - - template - constexpr int - __countr_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_ctz(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_ctzl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_ctzll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - if (__low != 0) - return __builtin_ctzll(__low); - unsigned long long __high = __x >> _Nd_ull; - return __builtin_ctzll(__high) + _Nd_ull; - } - } - - template - constexpr int - __countr_one(_Tp __x) noexcept - { - return std::__countr_zero((_Tp)~__x); - } - - template - constexpr int - __popcount(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_popcount(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_popcountl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_popcountll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - unsigned long long __high = __x >> _Nd_ull; - return __builtin_popcountll(__low) + __builtin_popcountll(__high); - } - } - - template - constexpr bool - __has_single_bit(_Tp __x) noexcept - { return std::__popcount(__x) == 1; } - - template - constexpr _Tp - __bit_ceil(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - if (__x == 0 || __x == 1) - return 1; - auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); - - - - - if (!std::__is_constant_evaluated()) - { - do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); - } - - using __promoted_type = decltype(__x << 1); - if constexpr (!is_same<__promoted_type, _Tp>::value) - { - - - - - - const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; - __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; - } - return (_Tp)1u << __shift_exponent; - } - - template - constexpr _Tp - __bit_floor(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if (__x == 0) - return 0; - return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); - } - - template - constexpr int - __bit_width(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - return _Nd - std::__countl_zero(__x); - } -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -} -# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - template - constexpr - inline int - __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) - { - - static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); -# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); - } -# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) - { -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - swap(*__a, *__b); - - } -# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - _ForwardIterator2 - swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - std::iter_swap(__first1, __first2); - return __first2; - } -# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b) - { - - - - if (__b < __a) - return __b; - return __a; - } -# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b) - { - - - - if (__a < __b) - return __b; - return __a; - } -# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__b, __a)) - return __b; - return __a; - } -# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__a, __b)) - return __b; - return __a; - } - - - - template - - inline _Iterator - __niter_base(_Iterator __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it; } - - template - _Ite - __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, - std::random_access_iterator_tag>&); - - - - - template - - inline _From - __niter_wrap(_From __from, _To __res) - { return __from + (__res - std::__niter_base(__from)); } - - - template - - inline _Iterator - __niter_wrap(const _Iterator&, _Iterator __res) - { return __res; } - - - - - - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = *__first; - return __result; - } - }; - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = std::move(*__first); - return __result; - } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = *__first; - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = *__from; } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = std::move(*__first); - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = std::move(*__from); } - }; - - - template - struct __copy_move<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_m(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result, __first); - return __result + _Num; - } - }; - - - - template - struct _Deque_iterator; - - struct _Bit_iterator; - - - - - - - template - struct char_traits; - - template - class istreambuf_iterator; - - template - class ostreambuf_iterator; - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(_CharT*, _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(const _CharT*, const _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - _CharT*>::__type - __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_move_a2( - istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>); - - - template - - inline _OI - __copy_move_a2(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::iterator_category _Category; - - - - - - return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, - _Category>::__copy_m(__first, __last, __result); - } - - template - _OI - __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_a1(_II __first, _II __last, _OI __result) - { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } - - template - - inline _OI - __copy_move_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_a1<_IsMove>(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); - - template - - _OutputIterator - __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, - bool) - { - if (__n > 0) - { - while (true) - { - *__result = *__first; - ++__result; - if (--__n > 0) - ++__first; - else - break; - } - } - return __result; - } - - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, _CharT*>::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, - _Size, _CharT*, bool); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>, - bool); -# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - copy(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a<__is_move_iterator<_II>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - move(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a(std::__miter_base(__first), - std::__miter_base(__last), __result); - } - - - - - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = *--__last; - return __result; - } - }; - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = *--__last; - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template - struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result - 1, __first); - return __result - _Num; - } - }; - - template - - inline _BI2 - __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) - { - typedef typename iterator_traits<_BI1>::iterator_category _Category; - - - - - - return std::__copy_move_backward<_IsMove, - __memcpyable<_BI2, _BI1>::__value, - _Category>::__copy_move_b(__first, - __last, - __result); - } - - template - - inline _BI2 - __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) - { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } - - template - _OI - __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_backward_a1( - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_backward_a1(_II, _II, - std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_backward_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_backward_a1<_IsMove> - (std::__niter_base(__first), std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_backward_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); -# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - move_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a(std::__miter_base(__first), - std::__miter_base(__last), - __result); - } - - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - for (; __first != __last; ++__first) - *__first = __value; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __first != __last; ++__first) - *__first = __tmp; - } - - - template - - inline typename - __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type - __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) - { - const _Tp __tmp = __c; -# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - if (const size_t __len = __last - __first) - __builtin_memset(__first, static_cast(__tmp), __len); - } - - template - - inline void - __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, - ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, - const _Tp& __value) - { std::__fill_a1(__first.base(), __last.base(), __value); } - - template - void - __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const _VTp&); - - - void - __fill_a1(std::_Bit_iterator, std::_Bit_iterator, - const bool&); - - template - - inline void - __fill_a(_FIte __first, _FIte __last, const _Tp& __value) - { std::__fill_a1(__first, __last, __value); } - - template - void - __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const _Tp&); -# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) - { - - - - ; - - std::__fill_a(__first, __last, __value); - } - - - inline constexpr int - __size_to_integer(int __n) { return __n; } - inline constexpr unsigned - __size_to_integer(unsigned __n) { return __n; } - inline constexpr long - __size_to_integer(long __n) { return __n; } - inline constexpr unsigned long - __size_to_integer(unsigned long __n) { return __n; } - inline constexpr long long - __size_to_integer(long long __n) { return __n; } - inline constexpr unsigned long long - __size_to_integer(unsigned long long __n) { return __n; } -# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - inline constexpr long long - __size_to_integer(float __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(double __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(long double __n) { return (long long)__n; } - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - for (; __n > 0; --__n, (void) ++__first) - *__first = __value; - return __first; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __n > 0; --__n, (void) ++__first) - *__first = __tmp; - return __first; - } - - template - ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, - _Size __n, const _Tp& __value, - std::input_iterator_tag); - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::output_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::input_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::random_access_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - if (__n <= 0) - return __first; - - ; - - std::__fill_a(__first, __first + __n, __value); - return __first + __n; - } -# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - fill_n(_OI __first, _Size __n, const _Tp& __value) - { - - - - return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, - std::__iterator_category(__first)); - } - - template - struct __equal - { - template - - static bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - for (; __first1 != __last1; ++__first1, (void) ++__first2) - if (!(*__first1 == *__first2)) - return false; - return true; - } - }; - - template<> - struct __equal - { - template - - static bool - equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) - { - if (const size_t __len = (__last1 - __first1)) - return !std::__memcmp(__first1, __first2, __len); - return true; - } - }; - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _II); - - template - bool - __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(_II, _II, - std::_Deque_iterator<_Tp, _Ref, _Ptr>); - - template - - inline bool - __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - const bool __simple = ((__is_integer<_ValueType1>::__value - || __is_pointer<_ValueType1>::__value) - && __memcmpable<_II1, _II2>::__value); - return std::__equal<__simple>::equal(__first1, __last1, __first2); - } - - template - - inline bool - __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) - { - return std::__equal_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2)); - } - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - _II2); - - template - bool - __equal_aux(_II1, _II1, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - struct __lc_rai - { - template - - static _II1 - __newlast1(_II1, _II1 __last1, _II2, _II2) - { return __last1; } - - template - - static bool - __cnd2(_II __first, _II __last) - { return __first != __last; } - }; - - template<> - struct __lc_rai - { - template - - static _RAI1 - __newlast1(_RAI1 __first1, _RAI1 __last1, - _RAI2 __first2, _RAI2 __last2) - { - const typename iterator_traits<_RAI1>::difference_type - __diff1 = __last1 - __first1; - const typename iterator_traits<_RAI2>::difference_type - __diff2 = __last2 - __first2; - return __diff2 < __diff1 ? __first1 + __diff2 : __last1; - } - - template - static bool - __cnd2(_RAI, _RAI) - { return true; } - }; - - template - - bool - __lexicographical_compare_impl(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, - _Compare __comp) - { - typedef typename iterator_traits<_II1>::iterator_category _Category1; - typedef typename iterator_traits<_II2>::iterator_category _Category2; - typedef std::__lc_rai<_Category1, _Category2> __rai_type; - - __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); - for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); - ++__first1, (void)++__first2) - { - if (__comp(__first1, __first2)) - return true; - if (__comp(__first2, __first1)) - return false; - } - return __first1 == __last1 && __first2 != __last2; - } - - template - struct __lexicographical_compare - { - template - - static bool - __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using __gnu_cxx::__ops::__iter_less_iter; - return std::__lexicographical_compare_impl(__first1, __last1, - __first2, __last2, - __iter_less_iter()); - } - - template - - static int - __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - while (__first1 != __last1) - { - if (__first2 == __last2) - return +1; - if (*__first1 < *__first2) - return -1; - if (*__first2 < *__first1) - return +1; - ++__first1; - ++__first2; - } - return int(__first2 == __last2) - 1; - } - }; - - template<> - struct __lexicographical_compare - { - template - - static bool - __lc(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { return __3way(__first1, __last1, __first2, __last2) < 0; } - - template - - static ptrdiff_t - __3way(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { - const size_t __len1 = __last1 - __first1; - const size_t __len2 = __last2 - __first2; - if (const size_t __len = std::min(__len1, __len2)) - if (int __result = std::__memcmp(__first1, __first2, __len)) - return __result; - return ptrdiff_t(__len1 - __len2); - } - }; - - template - - inline bool - __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - typedef typename iterator_traits<_II2>::value_type _ValueType2; - const bool __simple = - (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value - && __is_pointer<_II1>::__value - && __is_pointer<_II2>::__value - - - - - - - - ); - - return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, - __first2, __last2); - } - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - _Tp2*, _Tp2*); - - template - bool - __lexicographical_compare_aux1(_Tp1*, _Tp1*, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - - inline bool - __lexicographical_compare_aux(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - return std::__lexicographical_compare_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2), - std::__niter_base(__last2)); - } - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - _II2, _II2); - - template - bool - __lexicographical_compare_aux( - _II1, _II1, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - - _ForwardIterator - __lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val, _Compare __comp) - { - typedef typename iterator_traits<_ForwardIterator>::difference_type - _DistanceType; - - _DistanceType __len = std::distance(__first, __last); - - while (__len > 0) - { - _DistanceType __half = __len >> 1; - _ForwardIterator __middle = __first; - std::advance(__middle, __half); - if (__comp(__middle, __val)) - { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - else - __len = __half; - } - return __first; - } -# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _ForwardIterator - lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val) - { - - - - - ; - - return std::__lower_bound(__first, __last, __val, - __gnu_cxx::__ops::__iter_less_val()); - } - - - - template - inline constexpr _Tp - __lg(_Tp __n) - { - - return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; -# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - } -# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - - - - - - - ; - - return std::__equal_aux(__first1, __last1, __first2); - } -# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return true; - } - - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!(*__first1 == *__first2)) - return false; - return __first1 == __last1 && __first2 == __last2; - } - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, - _BinaryPredicate __binary_pred) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2, - __binary_pred); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return __first1 == __last1 && __first2 == __last2; - } -# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - - - - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2); - } -# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2, - __binary_pred); - } -# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { -# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - ; - ; - - return std::__lexicographical_compare_aux(__first1, __last1, - __first2, __last2); - } -# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, _Compare __comp) - { - - - - ; - ; - - return std::__lexicographical_compare_impl - (__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); - } -# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2) - { - - - - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __first2 != __last2 - && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2) - { - - - - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - - - template - - inline _InputIterator - __find_if(_InputIterator __first, _InputIterator __last, - _Predicate __pred, input_iterator_tag) - { - while (__first != __last && !__pred(__first)) - ++__first; - return __first; - } - - - template - - _RandomAccessIterator - __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Predicate __pred, random_access_iterator_tag) - { - typename iterator_traits<_RandomAccessIterator>::difference_type - __trip_count = (__last - __first) >> 2; - - for (; __trip_count > 0; --__trip_count) - { - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - } - - switch (__last - __first) - { - case 3: - if (__pred(__first)) - return __first; - ++__first; - - case 2: - if (__pred(__first)) - return __first; - ++__first; - - case 1: - if (__pred(__first)) - return __first; - ++__first; - - case 0: - default: - return __last; - } - } - - template - - inline _Iterator - __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) - { - return __find_if(__first, __last, __pred, - std::__iterator_category(__first)); - } - - template - - typename iterator_traits<_InputIterator>::difference_type - __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) - { - typename iterator_traits<_InputIterator>::difference_type __n = 0; - for (; __first != __last; ++__first) - if (__pred(__first)) - ++__n; - return __n; - } - - template - - _ForwardIterator - __remove_if(_ForwardIterator __first, _ForwardIterator __last, - _Predicate __pred) - { - __first = std::__find_if(__first, __last, __pred); - if (__first == __last) - return __first; - _ForwardIterator __result = __first; - ++__first; - for (; __first != __last; ++__first) - if (!__pred(__first)) - { - *__result = std::move(*__first); - ++__result; - } - return __result; - } - - - template - - bool - __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _BinaryPredicate __pred) - { - - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!__pred(__first1, __first2)) - break; - - if (__first1 == __last1) - return true; - - - - _ForwardIterator2 __last2 = __first2; - std::advance(__last2, std::distance(__first1, __last1)); - for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) - { - if (__scan != std::__find_if(__first1, __scan, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) - continue; - - auto __matches - = std::__count_if(__first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); - if (0 == __matches || - std::__count_if(__scan, __last1, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) - != __matches) - return false; - } - return true; - } -# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - - ; - - return std::__is_permutation(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } - - - -} -# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - begin(_Container& __cont) -> decltype(__cont.begin()) - { return __cont.begin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - begin(const _Container& __cont) -> decltype(__cont.begin()) - { return __cont.begin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - end(_Container& __cont) -> decltype(__cont.end()) - { return __cont.end(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - end(const _Container& __cont) -> decltype(__cont.end()) - { return __cont.end(); } - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr _Tp* - begin(_Tp (&__arr)[_Nm]) noexcept - { return __arr; } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr _Tp* - end(_Tp (&__arr)[_Nm]) noexcept - { return __arr + _Nm; } - - - - template class valarray; - - template _Tp* begin(valarray<_Tp>&) noexcept; - template const _Tp* begin(const valarray<_Tp>&) noexcept; - template _Tp* end(valarray<_Tp>&) noexcept; - template const _Tp* end(const valarray<_Tp>&) noexcept; - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - constexpr auto - cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) - -> decltype(std::begin(__cont)) - { return std::begin(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - constexpr auto - cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) - -> decltype(std::end(__cont)) - { return std::end(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rbegin(_Container& __cont) -> decltype(__cont.rbegin()) - { return __cont.rbegin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) - { return __cont.rbegin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rend(_Container& __cont) -> decltype(__cont.rend()) - { return __cont.rend(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rend(const _Container& __cont) -> decltype(__cont.rend()) - { return __cont.rend(); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Tp*> - rbegin(_Tp (&__arr)[_Nm]) noexcept - { return reverse_iterator<_Tp*>(__arr + _Nm); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Tp*> - rend(_Tp (&__arr)[_Nm]) noexcept - { return reverse_iterator<_Tp*>(__arr); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator - rbegin(initializer_list<_Tp> __il) noexcept - { return reverse_iterator(__il.end()); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator - rend(initializer_list<_Tp> __il) noexcept - { return reverse_iterator(__il.begin()); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) - { return std::rbegin(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - crend(const _Container& __cont) -> decltype(std::rend(__cont)) - { return std::rend(__cont); } -# 261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - size(const _Container& __cont) noexcept(noexcept(__cont.size())) - -> decltype(__cont.size()) - { return __cont.size(); } - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr size_t - size(const _Tp (&)[_Nm]) noexcept - { return _Nm; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) - -> decltype(__cont.empty()) - { return __cont.empty(); } - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr bool - empty(const _Tp (&)[_Nm]) noexcept - { return false; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr bool - empty(initializer_list<_Tp> __il) noexcept - { return __il.size() == 0;} - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - data(_Container& __cont) noexcept(noexcept(__cont.data())) - -> decltype(__cont.data()) - { return __cont.data(); } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - data(const _Container& __cont) noexcept(noexcept(__cont.data())) - -> decltype(__cont.data()) - { return __cont.data(); } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr _Tp* - data(_Tp (&__array)[_Nm]) noexcept - { return __array; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr const _Tp* - data(initializer_list<_Tp> __il) noexcept - { return __il.begin(); } -# 371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - struct __array_traits - { - using _Type = _Tp[_Nm]; - using _Is_swappable = __is_swappable<_Tp>; - using _Is_nothrow_swappable = __is_nothrow_swappable<_Tp>; - }; - - template - struct __array_traits<_Tp, 0> - { - - struct _Type - { - - __attribute__((__always_inline__,__noreturn__)) - _Tp& operator[](size_t) const noexcept { __builtin_trap(); } - - - __attribute__((__always_inline__)) - constexpr explicit operator _Tp*() const noexcept { return nullptr; } - }; - - using _Is_swappable = true_type; - using _Is_nothrow_swappable = true_type; - }; -# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 - template - struct array - { - typedef _Tp value_type; - typedef value_type* pointer; - typedef const value_type* const_pointer; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef value_type* iterator; - typedef const value_type* const_iterator; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; - - - typename __array_traits<_Tp, _Nm>::_Type _M_elems; - - - - - void - fill(const value_type& __u) - { std::fill_n(begin(), size(), __u); } - - void - swap(array& __other) - noexcept(__array_traits<_Tp, _Nm>::_Is_nothrow_swappable::value) - { std::swap_ranges(begin(), end(), __other.begin()); } - - - [[__gnu__::__const__, __nodiscard__]] - constexpr iterator - begin() noexcept - { return iterator(data()); } - - [[__nodiscard__]] - constexpr const_iterator - begin() const noexcept - { return const_iterator(data()); } - - [[__gnu__::__const__, __nodiscard__]] - constexpr iterator - end() noexcept - { return iterator(data() + _Nm); } - - [[__nodiscard__]] - constexpr const_iterator - end() const noexcept - { return const_iterator(data() + _Nm); } - - [[__gnu__::__const__, __nodiscard__]] - constexpr reverse_iterator - rbegin() noexcept - { return reverse_iterator(end()); } - - [[__nodiscard__]] - constexpr const_reverse_iterator - rbegin() const noexcept - { return const_reverse_iterator(end()); } - - [[__gnu__::__const__, __nodiscard__]] - constexpr reverse_iterator - rend() noexcept - { return reverse_iterator(begin()); } - - [[__nodiscard__]] - constexpr const_reverse_iterator - rend() const noexcept - { return const_reverse_iterator(begin()); } - - [[__nodiscard__]] - constexpr const_iterator - cbegin() const noexcept - { return const_iterator(data()); } - - [[__nodiscard__]] - constexpr const_iterator - cend() const noexcept - { return const_iterator(data() + _Nm); } - - [[__nodiscard__]] - constexpr const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(end()); } - - [[__nodiscard__]] - constexpr const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(begin()); } - - - [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] - constexpr size_type - size() const noexcept { return _Nm; } - - [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] - constexpr size_type - max_size() const noexcept { return _Nm; } - - [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] - constexpr bool - empty() const noexcept { return size() == 0; } - - - [[__nodiscard__]] - constexpr reference - operator[](size_type __n) noexcept - { - ; - return _M_elems[__n]; - } - - [[__nodiscard__]] - constexpr const_reference - operator[](size_type __n) const noexcept - { - - ; - - return _M_elems[__n]; - } - - constexpr reference - at(size_type __n) - { - if (__n >= _Nm) - std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), - - __n, _Nm); - return _M_elems[__n]; - } - - constexpr const_reference - at(size_type __n) const - { - - - return __n < _Nm ? _M_elems[__n] - : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), - - __n, _Nm), - _M_elems[__n]); - } - - [[__nodiscard__]] - constexpr reference - front() noexcept - { - ; - return _M_elems[(size_type)0]; - } - - [[__nodiscard__]] - constexpr const_reference - front() const noexcept - { - - ; - - return _M_elems[(size_type)0]; - } - - [[__nodiscard__]] - constexpr reference - back() noexcept - { - ; - return _M_elems[_Nm - 1]; - } - - [[__nodiscard__]] - constexpr const_reference - back() const noexcept - { - - ; - - return _M_elems[_Nm - 1]; - } - - [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] - constexpr pointer - data() noexcept - { return static_cast(_M_elems); } - - [[__nodiscard__]] - constexpr const_pointer - data() const noexcept - { return static_cast(_M_elems); } - }; - - - template - array(_Tp, _Up...) - -> array && ...), _Tp>, - 1 + sizeof...(_Up)>; - - - - template - [[__nodiscard__]] - - inline bool - operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return std::equal(__one.begin(), __one.end(), __two.begin()); } -# 322 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 - template - [[__nodiscard__]] - - inline bool - operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return !(__one == __two); } - - template - [[__nodiscard__]] - - inline bool - operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) - { - return std::lexicographical_compare(__a.begin(), __a.end(), - __b.begin(), __b.end()); - } - - template - [[__nodiscard__]] - - inline bool - operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return __two < __one; } - - template - [[__nodiscard__]] - - inline bool - operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return !(__one > __two); } - - template - [[__nodiscard__]] - - inline bool - operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return !(__one < __two); } - - - - template - - inline - - - __enable_if_t<__array_traits<_Tp, _Nm>::_Is_swappable::value> - - - - swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) - noexcept(noexcept(__one.swap(__two))) - { __one.swap(__two); } - - - template - __enable_if_t::_Is_swappable::value> - swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete; - - - template - [[__nodiscard__]] - constexpr _Tp& - get(array<_Tp, _Nm>& __arr) noexcept - { - static_assert(_Int < _Nm, "array index is within bounds"); - return __arr._M_elems[_Int]; - } - - template - [[__nodiscard__]] - constexpr _Tp&& - get(array<_Tp, _Nm>&& __arr) noexcept - { - static_assert(_Int < _Nm, "array index is within bounds"); - return std::move(std::get<_Int>(__arr)); - } - - template - [[__nodiscard__]] - constexpr const _Tp& - get(const array<_Tp, _Nm>& __arr) noexcept - { - static_assert(_Int < _Nm, "array index is within bounds"); - return __arr._M_elems[_Int]; - } - - template - [[__nodiscard__]] - constexpr const _Tp&& - get(const array<_Tp, _Nm>&& __arr) noexcept - { - static_assert(_Int < _Nm, "array index is within bounds"); - return std::move(std::get<_Int>(__arr)); - } -# 460 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 - template - struct tuple_size> - : public integral_constant { }; - - - template - struct tuple_element<_Ind, array<_Tp, _Nm>> - { - static_assert(_Ind < _Nm, "array index is in range"); - using type = _Tp; - }; - - - template - inline constexpr size_t tuple_size_v> = _Nm; - - template - inline constexpr size_t tuple_size_v> = _Nm; - - - template - struct __is_tuple_like_impl> : true_type - { }; - - -} -# 14 "src/platform/inputs.h" 2 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 1 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 1 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 - template - class allocator; - - template<> - class allocator; - - - - - template - struct uses_allocator; - - template - struct allocator_traits; - - - - - -} -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 1 3 -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 - - - -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 - class exception - { - public: - exception() noexcept { } - virtual ~exception() noexcept; - - exception(const exception&) = default; - exception& operator=(const exception&) = default; - exception(exception&&) = default; - exception& operator=(exception&&) = default; - - - - - virtual const char* - what() const noexcept; - }; - - - -} - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 2 3 - -#pragma GCC visibility push(default) - -extern "C++" { - -namespace std -{ - - - - - - - class bad_alloc : public exception - { - public: - bad_alloc() throw() { } - - - bad_alloc(const bad_alloc&) = default; - bad_alloc& operator=(const bad_alloc&) = default; - - - - - virtual ~bad_alloc() throw(); - - - virtual const char* what() const throw(); - }; - - - class bad_array_new_length : public bad_alloc - { - public: - bad_array_new_length() throw() { } - - - - virtual ~bad_array_new_length() throw(); - - - virtual const char* what() const throw(); - }; - - - - enum class align_val_t: size_t {}; - - - struct nothrow_t - { - - explicit nothrow_t() = default; - - }; - - extern const nothrow_t nothrow; - - - - typedef void (*new_handler)(); - - - - new_handler set_new_handler(new_handler) throw(); - - - - new_handler get_new_handler() noexcept; - -} -# 126 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -[[__nodiscard__]] void* operator new(std::size_t) - __attribute__((__externally_visible__)); -[[__nodiscard__]] void* operator new[](std::size_t) - __attribute__((__externally_visible__)); -void operator delete(void*) noexcept - __attribute__((__externally_visible__)); -void operator delete[](void*) noexcept - __attribute__((__externally_visible__)); - - - - - - -[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete(void*, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__)); -void operator delete[](void*, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__)); - -[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete(void*, std::align_val_t) - noexcept __attribute__((__externally_visible__)); -void operator delete(void*, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__)); -[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete[](void*, std::align_val_t) - noexcept __attribute__((__externally_visible__)); -void operator delete[](void*, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__)); -# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept -{ return __p; } -[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept -{ return __p; } - - -inline void operator delete (void*, void*) noexcept { } -inline void operator delete[](void*, void*) noexcept { } - -} - - -namespace std -{ - - - - template - [[nodiscard]] constexpr _Tp* - launder(_Tp* __p) noexcept - { return __builtin_launder(__p); } - - - - - template - void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; - template - void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; - - void launder(void*) = delete; - void launder(const void*) = delete; - void launder(volatile void*) = delete; - void launder(const volatile void*) = delete; - - - - - - - -} -# 236 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -#pragma GCC visibility pop -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - template - class __new_allocator - { - public: - typedef _Tp value_type; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - - template - struct rebind - { typedef __new_allocator<_Tp1> other; }; - - - - - - typedef std::true_type propagate_on_container_move_assignment; - - - __attribute__((__always_inline__)) - - __new_allocator() noexcept { } - - __attribute__((__always_inline__)) - - __new_allocator(const __new_allocator&) noexcept { } - - template - __attribute__((__always_inline__)) - - __new_allocator(const __new_allocator<_Tp1>&) noexcept { } - - - ~__new_allocator() noexcept { } - - pointer - address(reference __x) const noexcept - { return std::__addressof(__x); } - - const_pointer - address(const_reference __x) const noexcept - { return std::__addressof(__x); } -# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - [[__nodiscard__]] _Tp* - allocate(size_type __n, const void* = static_cast(0)) - { - - - - static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); - - - if (__builtin_expect(__n > this->_M_max_size(), false)) - { - - - if (__n > (std::size_t(-1) / sizeof(_Tp))) - std::__throw_bad_array_new_length(); - std::__throw_bad_alloc(); - } - - - if (alignof(_Tp) > 16UL) - { - std::align_val_t __al = std::align_val_t(alignof(_Tp)); - return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp), - __al)); - } - - return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp))); - } - - - void - deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) - { - - - - - - - - if (alignof(_Tp) > 16UL) - { - __builtin_operator_delete((__p), - std::align_val_t(alignof(_Tp))); - return; - } - - __builtin_operator_delete((__p)); - } - - - - - - - __attribute__((__always_inline__)) - size_type - max_size() const noexcept - { return _M_max_size(); } - - - template - __attribute__((__always_inline__)) - void - construct(_Up* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } - - template - __attribute__((__always_inline__)) - void - destroy(_Up* __p) - noexcept(std::is_nothrow_destructible<_Up>::value) - { __p->~_Up(); } -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - template - friend __attribute__((__always_inline__)) bool - operator==(const __new_allocator&, const __new_allocator<_Up>&) - noexcept - { return true; } - - - template - friend __attribute__((__always_inline__)) bool - operator!=(const __new_allocator&, const __new_allocator<_Up>&) - noexcept - { return false; } - - - private: - __attribute__((__always_inline__)) - constexpr size_type - _M_max_size() const noexcept - { - - return std::size_t(9223372036854775807L) / sizeof(_Tp); - - - - } - }; - - -} -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3 - - -namespace std -{ -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 - template - using __allocator_base = __new_allocator<_Tp>; -} -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - template<> - class allocator - { - public: - typedef void value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - - - typedef void* pointer; - typedef const void* const_pointer; - - template - struct rebind - { typedef allocator<_Tp1> other; }; - - - - - - using propagate_on_container_move_assignment = true_type; - - using is_always_equal - - = true_type; -# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - }; -# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - template - class allocator : public __allocator_base<_Tp> - { - public: - typedef _Tp value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - - - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - - template - struct rebind - { typedef allocator<_Tp1> other; }; - - - - - - using propagate_on_container_move_assignment = true_type; - - using is_always_equal - - = true_type; - - - - - __attribute__((__always_inline__)) - - allocator() noexcept { } - - __attribute__((__always_inline__)) - - allocator(const allocator& __a) noexcept - : __allocator_base<_Tp>(__a) { } - - - - allocator& operator=(const allocator&) = default; - - - template - __attribute__((__always_inline__)) - - allocator(const allocator<_Tp1>&) noexcept { } - - __attribute__((__always_inline__)) - - - - ~allocator() noexcept { } -# 214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - friend __attribute__((__always_inline__)) - bool - operator==(const allocator&, const allocator&) noexcept - { return true; } - - - friend __attribute__((__always_inline__)) - bool - operator!=(const allocator&, const allocator&) noexcept - { return false; } - - - - }; - - - - - - - template - __attribute__((__always_inline__)) - inline bool - operator==(const allocator<_T1>&, const allocator<_T2>&) - noexcept - { return true; } - - - template - __attribute__((__always_inline__)) - inline bool - operator!=(const allocator<_T1>&, const allocator<_T2>&) - noexcept - { return false; } - - - - - - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - - - - - - - extern template class allocator; - extern template class allocator; - - - - - - -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 1 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 1 3 -# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - inline void - destroy_at(_Tp* __location) - { - if constexpr (201703L > 201703L && is_array_v<_Tp>) - { - for (auto& __x : *__location) - std::destroy_at(std::__addressof(__x)); - } - else - __location->~_Tp(); - } -# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - template - - inline void - _Construct(_Tp* __p, _Args&&... __args) - { -# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); - } -# 132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - template - inline void - _Construct_novalue(_T1* __p) - { ::new((void*)__p) _T1; } - - template - void - _Destroy(_ForwardIterator __first, _ForwardIterator __last); - - - - - template - constexpr inline void - _Destroy(_Tp* __pointer) - { - - - - __pointer->~_Tp(); - - } - - template - struct _Destroy_aux - { - template - static void - __destroy(_ForwardIterator __first, _ForwardIterator __last) - { - for (; __first != __last; ++__first) - std::_Destroy(std::__addressof(*__first)); - } - }; - - template<> - struct _Destroy_aux - { - template - static void - __destroy(_ForwardIterator, _ForwardIterator) { } - }; - - - - - - - template - inline void - _Destroy(_ForwardIterator __first, _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _Value_type; - - - static_assert(is_destructible<_Value_type>::value, - "value type is destructible"); - - - - - - std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: - __destroy(__first, __last); - } - - template - struct _Destroy_n_aux - { - template - static _ForwardIterator - __destroy_n(_ForwardIterator __first, _Size __count) - { - for (; __count > 0; (void)++__first, --__count) - std::_Destroy(std::__addressof(*__first)); - return __first; - } - }; - - template<> - struct _Destroy_n_aux - { - template - static _ForwardIterator - __destroy_n(_ForwardIterator __first, _Size __count) - { - std::advance(__first, __count); - return __first; - } - }; - - - - - - - template - inline _ForwardIterator - _Destroy_n(_ForwardIterator __first, _Size __count) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _Value_type; - - - static_assert(is_destructible<_Value_type>::value, - "value type is destructible"); - - - - - - return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: - __destroy_n(__first, __count); - } - - - template - inline void - destroy(_ForwardIterator __first, _ForwardIterator __last) - { - std::_Destroy(__first, __last); - } - - template - inline _ForwardIterator - destroy_n(_ForwardIterator __first, _Size __count) - { - return std::_Destroy_n(__first, __count); - } - - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 2 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - namespace __detail - { - template - inline void - __return_temporary_buffer(_Tp* __p, - size_t __len __attribute__((__unused__))) - { - - - - ::operator delete(__p); - - } - } -# 101 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 - template - [[__deprecated__]] - pair<_Tp*, ptrdiff_t> - get_temporary_buffer(ptrdiff_t __len) noexcept - { - const ptrdiff_t __max = - __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); - if (__len > __max) - __len = __max; - - while (__len > 0) - { - _Tp* __tmp = static_cast<_Tp*>(::operator new(__len * sizeof(_Tp), - std::nothrow)); - if (__tmp != 0) - return std::pair<_Tp*, ptrdiff_t>(__tmp, __len); - __len = __len == 1 ? 0 : ((__len + 1) / 2); - } - return std::pair<_Tp*, ptrdiff_t>(static_cast<_Tp*>(0), 0); - } -# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 - template - inline void - return_temporary_buffer(_Tp* __p) - { ::operator delete(__p); } - - - - - - - template - class _Temporary_buffer - { - - - - public: - typedef _Tp value_type; - typedef value_type* pointer; - typedef pointer iterator; - typedef ptrdiff_t size_type; - - protected: - size_type _M_original_len; - size_type _M_len; - pointer _M_buffer; - - public: - - size_type - size() const - { return _M_len; } - - - size_type - requested_size() const - { return _M_original_len; } - - - iterator - begin() - { return _M_buffer; } - - - iterator - end() - { return _M_buffer + _M_len; } - - - - - - _Temporary_buffer(_ForwardIterator __seed, size_type __original_len); - - ~_Temporary_buffer() - { - std::_Destroy(_M_buffer, _M_buffer + _M_len); - std::__detail::__return_temporary_buffer(_M_buffer, _M_len); - } - - private: - - _Temporary_buffer(const _Temporary_buffer&); - - void - operator=(const _Temporary_buffer&); - }; - - - template - struct __uninitialized_construct_buf_dispatch - { - template - static void - __ucr(_Pointer __first, _Pointer __last, - _ForwardIterator __seed) - { - if (__first == __last) - return; - - _Pointer __cur = __first; - try - { - std::_Construct(std::__addressof(*__first), - std::move(*__seed)); - _Pointer __prev = __cur; - ++__cur; - for(; __cur != __last; ++__cur, ++__prev) - std::_Construct(std::__addressof(*__cur), - std::move(*__prev)); - *__seed = std::move(*__prev); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_construct_buf_dispatch - { - template - static void - __ucr(_Pointer, _Pointer, _ForwardIterator) { } - }; -# 247 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_tempbuf.h" 3 - template - inline void - __uninitialized_construct_buf(_Pointer __first, _Pointer __last, - _ForwardIterator __seed) - { - typedef typename std::iterator_traits<_Pointer>::value_type - _ValueType; - - std::__uninitialized_construct_buf_dispatch< - __has_trivial_constructor(_ValueType)>:: - __ucr(__first, __last, __seed); - } - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template - _Temporary_buffer<_ForwardIterator, _Tp>:: - _Temporary_buffer(_ForwardIterator __seed, size_type __original_len) - : _M_original_len(__original_len), _M_len(0), _M_buffer(0) - { - std::pair __p( - std::get_temporary_buffer(_M_original_len)); - - if (__p.first) - { - try - { - std::__uninitialized_construct_buf(__p.first, __p.first + __p.second, - __seed); - _M_buffer = __p.first; - _M_len = __p.second; - } - catch(...) - { - std::__detail::__return_temporary_buffer(__p.first, __p.second); - throw; - } - } - } -#pragma GCC diagnostic pop - - -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 1 3 -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 1 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - struct __allocator_traits_base - { - template - struct __rebind : __replace_first_arg<_Tp, _Up> - { - static_assert(is_same< - typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, - _Tp>::value, - "allocator_traits::rebind_alloc must be A"); - }; - - template - struct __rebind<_Tp, _Up, - __void_t::other>> - { - using type = typename _Tp::template rebind<_Up>::other; - - static_assert(is_same< - typename _Tp::template rebind::other, - _Tp>::value, - "allocator_traits::rebind_alloc must be A"); - }; - - protected: - template - using __pointer = typename _Tp::pointer; - template - using __c_pointer = typename _Tp::const_pointer; - template - using __v_pointer = typename _Tp::void_pointer; - template - using __cv_pointer = typename _Tp::const_void_pointer; - template - using __pocca = typename _Tp::propagate_on_container_copy_assignment; - template - using __pocma = typename _Tp::propagate_on_container_move_assignment; - template - using __pocs = typename _Tp::propagate_on_container_swap; - template - using __equal = __type_identity; - }; - - template - using __alloc_rebind - = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; -# 104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct allocator_traits : __allocator_traits_base - { - - typedef _Alloc allocator_type; - - typedef typename _Alloc::value_type value_type; - - - - - - - using pointer = __detected_or_t; - - private: - - template class _Func, typename _Tp, typename = void> - struct _Ptr - { - using type = typename pointer_traits::template rebind<_Tp>; - }; - - template class _Func, typename _Tp> - struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> - { - using type = _Func<_Alloc>; - }; - - - template - struct _Diff - { using type = typename pointer_traits<_PtrT>::difference_type; }; - - template - struct _Diff<_A2, _PtrT, __void_t> - { using type = typename _A2::difference_type; }; - - - template - struct _Size : make_unsigned<_DiffT> { }; - - template - struct _Size<_A2, _DiffT, __void_t> - { using type = typename _A2::size_type; }; - - public: - - - - - - - using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; - - - - - - - - using void_pointer = typename _Ptr<__v_pointer, void>::type; - - - - - - - - using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; - - - - - - - - using difference_type = typename _Diff<_Alloc, pointer>::type; - - - - - - - - using size_type = typename _Size<_Alloc, difference_type>::type; - - - - - - - - using propagate_on_container_copy_assignment - = __detected_or_t; - - - - - - - - using propagate_on_container_move_assignment - = __detected_or_t; - - - - - - - - using propagate_on_container_swap - = __detected_or_t; - - - - - - - - using is_always_equal - = typename __detected_or_t, __equal, _Alloc>::type; - - template - using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; - template - using rebind_traits = allocator_traits>; - - private: - template - static constexpr auto - _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) - -> decltype(__a.allocate(__n, __hint)) - { return __a.allocate(__n, __hint); } - - template - static constexpr pointer - _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) - { return __a.allocate(__n); } - - template - struct __construct_helper - { - template()->construct( - std::declval<_Tp*>(), std::declval<_Args>()...))> - static true_type __test(int); - - template - static false_type __test(...); - - using type = decltype(__test<_Alloc>(0)); - }; - - template - using __has_construct - = typename __construct_helper<_Tp, _Args...>::type; - - template - static constexpr _Require<__has_construct<_Tp, _Args...>> - _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) - noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) - { __a.construct(__p, std::forward<_Args>(__args)...); } - - template - static constexpr - _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, - is_constructible<_Tp, _Args...>>> - _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) - { - - ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); - - - - } - - template - static constexpr auto - _S_destroy(_Alloc2& __a, _Tp* __p, int) - noexcept(noexcept(__a.destroy(__p))) - -> decltype(__a.destroy(__p)) - { __a.destroy(__p); } - - template - static constexpr void - _S_destroy(_Alloc2&, _Tp* __p, ...) - noexcept(std::is_nothrow_destructible<_Tp>::value) - { std::_Destroy(__p); } - - template - static constexpr auto - _S_max_size(_Alloc2& __a, int) - -> decltype(__a.max_size()) - { return __a.max_size(); } - - template - static constexpr size_type - _S_max_size(_Alloc2&, ...) - { - - - return __gnu_cxx::__numeric_traits::__max - / sizeof(value_type); - } - - template - static constexpr auto - _S_select(_Alloc2& __a, int) - -> decltype(__a.select_on_container_copy_construction()) - { return __a.select_on_container_copy_construction(); } - - template - static constexpr _Alloc2 - _S_select(_Alloc2& __a, ...) - { return __a; } - - public: -# 331 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__]] static pointer - allocate(_Alloc& __a, size_type __n) - { return __a.allocate(__n); } -# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__]] static pointer - allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) - { return _S_allocate(__a, __n, __hint, 0); } -# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static void - deallocate(_Alloc& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 373 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - static auto - construct(_Alloc& __a, _Tp* __p, _Args&&... __args) - noexcept(noexcept(_S_construct(__a, __p, - std::forward<_Args>(__args)...))) - -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) - { _S_construct(__a, __p, std::forward<_Args>(__args)...); } -# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - static void - destroy(_Alloc& __a, _Tp* __p) - noexcept(noexcept(_S_destroy(__a, __p, 0))) - { _S_destroy(__a, __p, 0); } -# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static size_type - max_size(const _Alloc& __a) noexcept - { return _S_max_size(__a, 0); } -# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static _Alloc - select_on_container_copy_construction(const _Alloc& __rhs) - { return _S_select(__rhs, 0); } - }; -# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct allocator_traits> - { - - using allocator_type = allocator<_Tp>; - - - using value_type = _Tp; - - - using pointer = _Tp*; - - - using const_pointer = const _Tp*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - using propagate_on_container_copy_assignment = false_type; - - - using propagate_on_container_move_assignment = true_type; - - - using propagate_on_container_swap = false_type; - - - using is_always_equal = true_type; - - template - using rebind_alloc = allocator<_Up>; - - template - using rebind_traits = allocator_traits>; -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__,__gnu__::__always_inline__]] - static pointer - allocate(allocator_type& __a, size_type __n) - { return __a.allocate(__n); } -# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__,__gnu__::__always_inline__]] - static pointer - allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) - { - - return __a.allocate(__n, __hint); - - - - } -# 513 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__gnu__::__always_inline__]] - static void - deallocate(allocator_type& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, - _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { - - __a.construct(__p, std::forward<_Args>(__args)...); - - - - } -# 550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { - - __a.destroy(__p); - - - - } - - - - - - - [[__gnu__::__always_inline__]] - static size_type - max_size(const allocator_type& __a __attribute__((__unused__))) noexcept - { - - return __a.max_size(); - - - - } - - - - - - - [[__gnu__::__always_inline__]] - static allocator_type - select_on_container_copy_construction(const allocator_type& __rhs) - { return __rhs; } - }; - - - template<> - struct allocator_traits> - { - - using allocator_type = allocator; - - - using value_type = void; - - - using pointer = void*; - - - using const_pointer = const void*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - using propagate_on_container_copy_assignment = false_type; - - - using propagate_on_container_move_assignment = true_type; - - - using propagate_on_container_swap = false_type; - - - using is_always_equal = true_type; - - template - using rebind_alloc = allocator<_Up>; - - template - using rebind_traits = allocator_traits>; - - - static void* - allocate(allocator_type&, size_type, const void* = nullptr) = delete; - - - static void - deallocate(allocator_type&, void*, size_type) = delete; -# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - construct(allocator_type&, _Up* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { std::_Construct(__p, std::forward<_Args>(__args)...); } -# 669 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - destroy(allocator_type&, _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { std::_Destroy(__p); } - - - static size_type - max_size(const allocator_type&) = delete; - - - - - - - [[__gnu__::__always_inline__]] - static allocator_type - select_on_container_copy_construction(const allocator_type& __rhs) - { return __rhs; } - }; -# 707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_copy(_Alloc& __one, const _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocca = - typename __traits::propagate_on_container_copy_assignment::type; - - if constexpr (__pocca::value) - __one = __two; - - - - } - - template - [[__gnu__::__always_inline__]] - constexpr _Alloc - __alloc_on_copy(const _Alloc& __a) - { - typedef allocator_traits<_Alloc> __traits; - return __traits::select_on_container_copy_construction(__a); - } -# 744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_move(_Alloc& __one, _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocma - = typename __traits::propagate_on_container_move_assignment::type; - - if constexpr (__pocma::value) - __one = std::move(__two); - - - - } -# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_swap(_Alloc& __one, _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocs = typename __traits::propagate_on_container_swap::type; - - if constexpr (__pocs::value) - { - using std::swap; - swap(__one, __two); - } - - - - } - - template, - typename = void> - struct __is_alloc_insertable_impl - : false_type - { }; - - template - struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, - __void_t::construct( - std::declval<_Alloc&>(), std::declval<_ValueT*>(), - std::declval<_Tp>()))>> - : true_type - { }; - - - - - template - struct __is_copy_insertable - : __is_alloc_insertable_impl<_Alloc, - typename _Alloc::value_type const&>::type - { }; - - - - template - struct __is_copy_insertable> - : is_copy_constructible<_Tp> - { }; - - - - - - template - struct __is_move_insertable - : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type - { }; - - - - template - struct __is_move_insertable> - : is_move_constructible<_Tp> - { }; - - - - template - struct __is_allocator : false_type { }; - - template - struct __is_allocator<_Alloc, - __void_t().allocate(size_t{}))>> - : true_type { }; - - template - using _RequireAllocator - = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; - - template - using _RequireNotAllocator - = typename enable_if::value, _Alloc>::type; -# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct __alloc_swap - { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; - - template - struct __alloc_swap<_Alloc, false> - { - static void - _S_do_it(_Alloc& __one, _Alloc& __two) noexcept - { - - if (__one != __two) - swap(__one, __two); - } - }; - - - template, - is_nothrow_move_constructible>::value> - struct __shrink_to_fit_aux - { static bool _S_do_it(_Tp&) noexcept { return false; } }; - - template - struct __shrink_to_fit_aux<_Tp, true> - { - - static bool - _S_do_it(_Tp& __c) noexcept - { - - try - { - _Tp(__make_move_if_noexcept_iterator(__c.begin()), - __make_move_if_noexcept_iterator(__c.end()), - __c.get_allocator()).swap(__c); - return true; - } - catch(...) - { return false; } - - - - } - }; -# 925 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - - void - _Destroy(_ForwardIterator __first, _ForwardIterator __last, - _Allocator& __alloc) - { - for (; __first != __last; ++__first) - - - - allocator_traits<_Allocator>::destroy(__alloc, - std::__addressof(*__first)); - - } - - - template - __attribute__((__always_inline__)) - inline void - _Destroy(_ForwardIterator __first, _ForwardIterator __last, - allocator<_Tp>&) - { - std::_Destroy(__first, __last); - } - - - - -} -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 2 3 - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - - - -template - struct __alloc_traits - - : std::allocator_traits<_Alloc> - - { - typedef _Alloc allocator_type; - - typedef std::allocator_traits<_Alloc> _Base_type; - typedef typename _Base_type::value_type value_type; - typedef typename _Base_type::pointer pointer; - typedef typename _Base_type::const_pointer const_pointer; - typedef typename _Base_type::size_type size_type; - typedef typename _Base_type::difference_type difference_type; - - typedef value_type& reference; - typedef const value_type& const_reference; - using _Base_type::allocate; - using _Base_type::deallocate; - using _Base_type::construct; - using _Base_type::destroy; - using _Base_type::max_size; - - private: - template - using __is_custom_pointer - = std::__and_, - std::__not_>>; - - public: - - template - [[__gnu__::__always_inline__]] - static constexpr - std::__enable_if_t<__is_custom_pointer<_Ptr>::value> - construct(_Alloc& __a, _Ptr __p, _Args&&... __args) - noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), - std::forward<_Args>(__args)...))) - { - _Base_type::construct(__a, std::__to_address(__p), - std::forward<_Args>(__args)...); - } - - - template - [[__gnu__::__always_inline__]] - static constexpr - std::__enable_if_t<__is_custom_pointer<_Ptr>::value> - destroy(_Alloc& __a, _Ptr __p) - noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) - { _Base_type::destroy(__a, std::__to_address(__p)); } - - [[__gnu__::__always_inline__]] - static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) - { return _Base_type::select_on_container_copy_construction(__a); } - - [[__gnu__::__always_inline__]] - static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) - { std::__alloc_on_swap(__a, __b); } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_copy_assign() - { return _Base_type::propagate_on_container_copy_assignment::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_move_assign() - { return _Base_type::propagate_on_container_move_assignment::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_swap() - { return _Base_type::propagate_on_container_swap::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_always_equal() - { return _Base_type::is_always_equal::value; } - - __attribute__((__always_inline__)) - static constexpr bool _S_nothrow_move() - { return _S_propagate_on_move_assign() || _S_always_equal(); } - - template - struct rebind - { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; -# 180 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 - }; - - -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 2 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - constexpr bool - __check_constructible() - { - - - - - - static_assert(is_constructible<_ValueType, _Tp>::value, - "result type must be constructible from input type"); - - return true; - } -# 110 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - - _ForwardIterator - __do_uninit_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { - _ForwardIterator __cur = __result; - try - { - for (; __first != __last; ++__first, (void)++__cur) - std::_Construct(std::__addressof(*__cur), *__first); - return __cur; - } - catch(...) - { - std::_Destroy(__result, __cur); - throw; - } - } - - template - struct __uninitialized_copy - { - template - static _ForwardIterator - __uninit_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { return std::__do_uninit_copy(__first, __last, __result); } - }; - - template<> - struct __uninitialized_copy - { - template - static _ForwardIterator - __uninit_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { return std::copy(__first, __last, __result); } - }; -# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { - typedef typename iterator_traits<_InputIterator>::value_type - _ValueType1; - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType2; - - - - - const bool __can_memmove = __is_trivial(_ValueType1); - - - - - using _From = decltype(*__first); - - const bool __assignable - = __is_trivial(_ValueType2) && __is_assignable(_ValueType2&, _From) && std::__check_constructible<_ValueType2, _From>(); - - return std::__uninitialized_copy<__can_memmove && __assignable>:: - __uninit_copy(__first, __last, __result); - } - - - - template - void - __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { - _ForwardIterator __cur = __first; - try - { - for (; __cur != __last; ++__cur) - std::_Construct(std::__addressof(*__cur), __x); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - - template - struct __uninitialized_fill - { - template - static void - __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { std::__do_uninit_fill(__first, __last, __x); } - }; - - template<> - struct __uninitialized_fill - { - template - static void - __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { std::fill(__first, __last, __x); } - }; -# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline void - uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - - - const bool __can_fill - = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>(); - - std::__uninitialized_fill<__can_fill>:: - __uninit_fill(__first, __last, __x); - } - - - - template - - _ForwardIterator - __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) - { - _ForwardIterator __cur = __first; - try - { - for (; __n > 0; --__n, (void) ++__cur) - std::_Construct(std::__addressof(*__cur), __x); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - - template - struct __uninitialized_fill_n - { - template - static _ForwardIterator - __uninit_fill_n(_ForwardIterator __first, _Size __n, - const _Tp& __x) - { return std::__do_uninit_fill_n(__first, __n, __x); } - }; - - template<> - struct __uninitialized_fill_n - { - template - static _ForwardIterator - __uninit_fill_n(_ForwardIterator __first, _Size __n, - const _Tp& __x) - { return std::fill_n(__first, __n, __x); } - }; -# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - - - const bool __can_fill - = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>() - - - - && __is_integer<_Size>::__value; - - return __uninitialized_fill_n<__can_fill>:: - __uninit_fill_n(__first, __n, __x); - } -# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - - _ForwardIterator - __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - { - _ForwardIterator __cur = __result; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __first != __last; ++__first, (void)++__cur) - __traits::construct(__alloc, std::__addressof(*__cur), *__first); - return __cur; - } - catch(...) - { - std::_Destroy(__result, __cur, __alloc); - throw; - } - } - - - template - - inline _ForwardIterator - __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, allocator<_Tp>&) - { - - - - - return std::uninitialized_copy(__first, __last, __result); - } - - - template - - inline _ForwardIterator - __uninitialized_move_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - { - return std::__uninitialized_copy_a(std::make_move_iterator(__first), - std::make_move_iterator(__last), - __result, __alloc); - } - - template - - inline _ForwardIterator - __uninitialized_move_if_noexcept_a(_InputIterator __first, - _InputIterator __last, - _ForwardIterator __result, - _Allocator& __alloc) - { - return std::__uninitialized_copy_a - (std::__make_move_if_noexcept_iterator(__first), - std::__make_move_if_noexcept_iterator(__last), __result, __alloc); - } - - template - - void - __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x, _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __cur != __last; ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur), __x); - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - template - - inline void - __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x, allocator<_Tp2>&) - { - - - - - std::uninitialized_fill(__first, __last, __x); - } - - - template - - _ForwardIterator - __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, - const _Tp& __x, _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __n > 0; --__n, (void) ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur), __x); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - template - - inline _ForwardIterator - __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, - const _Tp& __x, allocator<_Tp2>&) - { - - - - - return std::uninitialized_fill_n(__first, __n, __x); - } -# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - __uninitialized_copy_move(_InputIterator1 __first1, - _InputIterator1 __last1, - _InputIterator2 __first2, - _InputIterator2 __last2, - _ForwardIterator __result, - _Allocator& __alloc) - { - _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, - __result, - __alloc); - try - { - return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); - } - catch(...) - { - std::_Destroy(__result, __mid, __alloc); - throw; - } - } - - - - - - template - inline _ForwardIterator - __uninitialized_move_copy(_InputIterator1 __first1, - _InputIterator1 __last1, - _InputIterator2 __first2, - _InputIterator2 __last2, - _ForwardIterator __result, - _Allocator& __alloc) - { - _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, - __result, - __alloc); - try - { - return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); - } - catch(...) - { - std::_Destroy(__result, __mid, __alloc); - throw; - } - } - - - - - template - inline _ForwardIterator - __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, - const _Tp& __x, _InputIterator __first, - _InputIterator __last, _Allocator& __alloc) - { - std::__uninitialized_fill_a(__result, __mid, __x, __alloc); - try - { - return std::__uninitialized_move_a(__first, __last, __mid, __alloc); - } - catch(...) - { - std::_Destroy(__result, __mid, __alloc); - throw; - } - } - - - - - template - inline void - __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, - _ForwardIterator __first2, - _ForwardIterator __last2, const _Tp& __x, - _Allocator& __alloc) - { - _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, - __first2, - __alloc); - try - { - std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); - } - catch(...) - { - std::_Destroy(__first2, __mid2, __alloc); - throw; - } - } -# 592 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - struct __uninitialized_default_1 - { - template - static void - __uninit_default(_ForwardIterator __first, _ForwardIterator __last) - { - _ForwardIterator __cur = __first; - try - { - for (; __cur != __last; ++__cur) - std::_Construct(std::__addressof(*__cur)); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_1 - { - template - static void - __uninit_default(_ForwardIterator __first, _ForwardIterator __last) - { - if (__first == __last) - return; - - typename iterator_traits<_ForwardIterator>::value_type* __val - = std::__addressof(*__first); - std::_Construct(__val); - if (++__first != __last) - std::fill(__first, __last, *__val); - } - }; - - template - struct __uninitialized_default_n_1 - { - template - - static _ForwardIterator - __uninit_default_n(_ForwardIterator __first, _Size __n) - { - _ForwardIterator __cur = __first; - try - { - for (; __n > 0; --__n, (void) ++__cur) - std::_Construct(std::__addressof(*__cur)); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_n_1 - { - template - - static _ForwardIterator - __uninit_default_n(_ForwardIterator __first, _Size __n) - { - if (__n > 0) - { - typename iterator_traits<_ForwardIterator>::value_type* __val - = std::__addressof(*__first); - std::_Construct(__val); - ++__first; - __first = std::fill_n(__first, __n - 1, *__val); - } - return __first; - } - }; - - - - template - inline void - __uninitialized_default(_ForwardIterator __first, - _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - const bool __assignable = is_copy_assignable<_ValueType>::value; - - std::__uninitialized_default_1<__is_trivial(_ValueType) - && __assignable>:: - __uninit_default(__first, __last); - } - - - - template - - inline _ForwardIterator - __uninitialized_default_n(_ForwardIterator __first, _Size __n) - { - - - - - - - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - constexpr bool __can_fill - = __and_, is_copy_assignable<_ValueType>>::value; - - return __uninitialized_default_n_1<__is_trivial(_ValueType) - && __can_fill>:: - __uninit_default_n(__first, __n); - } - - - - - - template - void - __uninitialized_default_a(_ForwardIterator __first, - _ForwardIterator __last, - _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __cur != __last; ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur)); - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - template - inline void - __uninitialized_default_a(_ForwardIterator __first, - _ForwardIterator __last, - allocator<_Tp>&) - { std::__uninitialized_default(__first, __last); } - - - - - - template - _ForwardIterator - __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, - _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __n > 0; --__n, (void) ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur)); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - - - template - - inline _ForwardIterator - __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, - allocator<_Tp>&) - { return std::__uninitialized_default_n(__first, __n); } - - - template - struct __uninitialized_default_novalue_1 - { - template - static void - __uninit_default_novalue(_ForwardIterator __first, - _ForwardIterator __last) - { - _ForwardIterator __cur = __first; - try - { - for (; __cur != __last; ++__cur) - std::_Construct_novalue(std::__addressof(*__cur)); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_novalue_1 - { - template - static void - __uninit_default_novalue(_ForwardIterator __first, - _ForwardIterator __last) - { - } - }; - - template - struct __uninitialized_default_novalue_n_1 - { - template - static _ForwardIterator - __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) - { - _ForwardIterator __cur = __first; - try - { - for (; __n > 0; --__n, (void) ++__cur) - std::_Construct_novalue(std::__addressof(*__cur)); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_novalue_n_1 - { - template - static _ForwardIterator - __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) - { return std::next(__first, __n); } - }; - - - - template - inline void - __uninitialized_default_novalue(_ForwardIterator __first, - _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - std::__uninitialized_default_novalue_1< - is_trivially_default_constructible<_ValueType>::value>:: - __uninit_default_novalue(__first, __last); - } - - - - template - inline _ForwardIterator - __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - return __uninitialized_default_novalue_n_1< - is_trivially_default_constructible<_ValueType>::value>:: - __uninit_default_novalue_n(__first, __n); - } - - template - _ForwardIterator - __uninitialized_copy_n(_InputIterator __first, _Size __n, - _ForwardIterator __result, input_iterator_tag) - { - _ForwardIterator __cur = __result; - try - { - for (; __n > 0; --__n, (void) ++__first, ++__cur) - std::_Construct(std::__addressof(*__cur), *__first); - return __cur; - } - catch(...) - { - std::_Destroy(__result, __cur); - throw; - } - } - - template - inline _ForwardIterator - __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, - _ForwardIterator __result, - random_access_iterator_tag) - { return std::uninitialized_copy(__first, __first + __n, __result); } - - template - pair<_InputIterator, _ForwardIterator> - __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, - _ForwardIterator __result, input_iterator_tag) - { - _ForwardIterator __cur = __result; - try - { - for (; __n > 0; --__n, (void) ++__first, ++__cur) - std::_Construct(std::__addressof(*__cur), *__first); - return {__first, __cur}; - } - catch(...) - { - std::_Destroy(__result, __cur); - throw; - } - } - - template - inline pair<_RandomAccessIterator, _ForwardIterator> - __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, - _ForwardIterator __result, - random_access_iterator_tag) - { - auto __second_res = uninitialized_copy(__first, __first + __n, __result); - auto __first_res = std::next(__first, __n); - return {__first_res, __second_res}; - } -# 947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_copy_n(_InputIterator __first, _Size __n, - _ForwardIterator __result) - { return std::__uninitialized_copy_n(__first, __n, __result, - std::__iterator_category(__first)); } - - - template - inline pair<_InputIterator, _ForwardIterator> - __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, - _ForwardIterator __result) - { - return - std::__uninitialized_copy_n_pair(__first, __n, __result, - std::__iterator_category(__first)); - } -# 976 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline void - uninitialized_default_construct(_ForwardIterator __first, - _ForwardIterator __last) - { - __uninitialized_default_novalue(__first, __last); - } -# 991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) - { - return __uninitialized_default_novalue_n(__first, __count); - } - - - - - - - - template - inline void - uninitialized_value_construct(_ForwardIterator __first, - _ForwardIterator __last) - { - return __uninitialized_default(__first, __last); - } -# 1019 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) - { - return __uninitialized_default_n(__first, __count); - } -# 1034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_move(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { - return std::uninitialized_copy - (std::make_move_iterator(__first), - std::make_move_iterator(__last), __result); - } -# 1052 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline pair<_InputIterator, _ForwardIterator> - uninitialized_move_n(_InputIterator __first, _Size __count, - _ForwardIterator __result) - { - auto __res = std::__uninitialized_copy_n_pair - (std::make_move_iterator(__first), - __count, __result); - return {__res.first.base(), __res.second}; - } - - - - - - template - - inline void - __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig, - _Allocator& __alloc) - noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, - __dest, std::move(*__orig))) - && noexcept(std::allocator_traits<_Allocator>::destroy( - __alloc, std::__addressof(*__orig)))) - { - typedef std::allocator_traits<_Allocator> __traits; - __traits::construct(__alloc, __dest, std::move(*__orig)); - __traits::destroy(__alloc, std::__addressof(*__orig)); - } - - - - template - struct __is_bitwise_relocatable - : is_trivial<_Tp> { }; - - template - - inline _ForwardIterator - __relocate_a_1(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), - std::addressof(*__first), - __alloc))) - { - typedef typename iterator_traits<_InputIterator>::value_type - _ValueType; - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType2; - static_assert(std::is_same<_ValueType, _ValueType2>::value, - "relocation is only possible for values of the same type"); - _ForwardIterator __cur = __result; - for (; __first != __last; ++__first, (void)++__cur) - std::__relocate_object_a(std::__addressof(*__cur), - std::__addressof(*__first), __alloc); - return __cur; - } - - - template - - inline __enable_if_t::value, _Tp*> - __relocate_a_1(_Tp* __first, _Tp* __last, - _Tp* __result, - [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept - { - ptrdiff_t __count = __last - __first; - if (__count > 0) - { -# 1132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - __builtin_memmove(__result, __first, __count * sizeof(_Tp)); - } - return __result + __count; - } - - - template - - inline _ForwardIterator - __relocate_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result), __alloc))) - { - return std::__relocate_a_1(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result), __alloc); - } - - - - - - - -} -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_raw_storage_iter.h" 1 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_raw_storage_iter.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - - - - template - class [[__deprecated__]] raw_storage_iterator - : public iterator - { - protected: - _OutputIterator _M_iter; - - public: - explicit - raw_storage_iterator(_OutputIterator __x) - : _M_iter(__x) {} - - raw_storage_iterator& - operator*() { return *this; } - - raw_storage_iterator& - operator=(const _Tp& __element) - { - std::_Construct(std::__addressof(*_M_iter), __element); - return *this; - } - - - - - raw_storage_iterator& - operator=(_Tp&& __element) - { - std::_Construct(std::__addressof(*_M_iter), std::move(__element)); - return *this; - } - - - raw_storage_iterator& - operator++() - { - ++_M_iter; - return *this; - } - - raw_storage_iterator - operator++(int) - { - raw_storage_iterator __tmp = *this; - ++_M_iter; - return __tmp; - } - - - - _OutputIterator base() const { return _M_iter; } - }; -#pragma GCC diagnostic pop - - -} -# 71 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 -# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 -# 52 "/usr/lib/clang/16/include/stdint.h" 3 -# 1 "/usr/include/stdint.h" 1 3 4 -# 26 "/usr/include/stdint.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/stdint.h" 2 3 4 -# 1 "/usr/include/bits/types.h" 1 3 4 -# 27 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 28 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 29 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned char __u_char; -typedef unsigned short int __u_short; -typedef unsigned int __u_int; -typedef unsigned long int __u_long; - - -typedef signed char __int8_t; -typedef unsigned char __uint8_t; -typedef signed short int __int16_t; -typedef unsigned short int __uint16_t; -typedef signed int __int32_t; -typedef unsigned int __uint32_t; - -typedef signed long int __int64_t; -typedef unsigned long int __uint64_t; - - - - - - -typedef __int8_t __int_least8_t; -typedef __uint8_t __uint_least8_t; -typedef __int16_t __int_least16_t; -typedef __uint16_t __uint_least16_t; -typedef __int32_t __int_least32_t; -typedef __uint32_t __uint_least32_t; -typedef __int64_t __int_least64_t; -typedef __uint64_t __uint_least64_t; - - - -typedef long int __quad_t; -typedef unsigned long int __u_quad_t; - - - - - - - -typedef long int __intmax_t; -typedef unsigned long int __uintmax_t; -# 141 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/typesizes.h" 1 3 4 -# 142 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/time64.h" 1 3 4 -# 143 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned long int __dev_t; -typedef unsigned int __uid_t; -typedef unsigned int __gid_t; -typedef unsigned long int __ino_t; -typedef unsigned long int __ino64_t; -typedef unsigned int __mode_t; -typedef unsigned long int __nlink_t; -typedef long int __off_t; -typedef long int __off64_t; -typedef int __pid_t; -typedef struct { int __val[2]; } __fsid_t; -typedef long int __clock_t; -typedef unsigned long int __rlim_t; -typedef unsigned long int __rlim64_t; -typedef unsigned int __id_t; -typedef long int __time_t; -typedef unsigned int __useconds_t; -typedef long int __suseconds_t; -typedef long int __suseconds64_t; - -typedef int __daddr_t; -typedef int __key_t; - - -typedef int __clockid_t; - - -typedef void * __timer_t; - - -typedef long int __blksize_t; - - - - -typedef long int __blkcnt_t; -typedef long int __blkcnt64_t; - - -typedef unsigned long int __fsblkcnt_t; -typedef unsigned long int __fsblkcnt64_t; - - -typedef unsigned long int __fsfilcnt_t; -typedef unsigned long int __fsfilcnt64_t; - - -typedef long int __fsword_t; - -typedef long int __ssize_t; - - -typedef long int __syscall_slong_t; - -typedef unsigned long int __syscall_ulong_t; - - - -typedef __off64_t __loff_t; -typedef char *__caddr_t; - - -typedef long int __intptr_t; - - -typedef unsigned int __socklen_t; - - - - -typedef int __sig_atomic_t; -# 28 "/usr/include/stdint.h" 2 3 4 -# 1 "/usr/include/bits/wchar.h" 1 3 4 -# 29 "/usr/include/stdint.h" 2 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 30 "/usr/include/stdint.h" 2 3 4 - - - - -# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-intn.h" 3 4 -typedef __int8_t int8_t; -typedef __int16_t int16_t; -typedef __int32_t int32_t; -typedef __int64_t int64_t; -# 35 "/usr/include/stdint.h" 2 3 4 - - -# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-uintn.h" 3 4 -typedef __uint8_t uint8_t; -typedef __uint16_t uint16_t; -typedef __uint32_t uint32_t; -typedef __uint64_t uint64_t; -# 38 "/usr/include/stdint.h" 2 3 4 - - - - - -typedef __int_least8_t int_least8_t; -typedef __int_least16_t int_least16_t; -typedef __int_least32_t int_least32_t; -typedef __int_least64_t int_least64_t; - - -typedef __uint_least8_t uint_least8_t; -typedef __uint_least16_t uint_least16_t; -typedef __uint_least32_t uint_least32_t; -typedef __uint_least64_t uint_least64_t; - - - - - -typedef signed char int_fast8_t; - -typedef long int int_fast16_t; -typedef long int int_fast32_t; -typedef long int int_fast64_t; -# 71 "/usr/include/stdint.h" 3 4 -typedef unsigned char uint_fast8_t; - -typedef unsigned long int uint_fast16_t; -typedef unsigned long int uint_fast32_t; -typedef unsigned long int uint_fast64_t; -# 87 "/usr/include/stdint.h" 3 4 -typedef long int intptr_t; - - -typedef unsigned long int uintptr_t; -# 101 "/usr/include/stdint.h" 3 4 -typedef __intmax_t intmax_t; -typedef __uintmax_t uintmax_t; -# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 -inline void* -align(size_t __align, size_t __size, void*& __ptr, size_t& __space) noexcept -{ - if (__space < __size) - return nullptr; - const auto __intptr = reinterpret_cast(__ptr); - const auto __aligned = (__intptr - 1u + __align) & -__align; - const auto __diff = __aligned - __intptr; - if (__diff > (__space - __size)) - return nullptr; - else - { - __space -= __diff; - return __ptr = reinterpret_cast(__aligned); - } -} -# 109 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/align.h" 3 -} -# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - struct __erased_type { }; - - - - - template - using __is_erased_or_convertible - = __or_, is_same<_Tp, __erased_type>>; - - - struct allocator_arg_t { explicit allocator_arg_t() = default; }; - - inline constexpr allocator_arg_t allocator_arg = - allocator_arg_t(); - - template> - struct __uses_allocator_helper - : false_type { }; - - template - struct __uses_allocator_helper<_Tp, _Alloc, - __void_t> - : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type - { }; - - - template - struct uses_allocator - : __uses_allocator_helper<_Tp, _Alloc>::type - { }; - - struct __uses_alloc_base { }; - - struct __uses_alloc0 : __uses_alloc_base - { - struct _Sink { void operator=(const void*) { } } _M_a; - }; - - template - struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; - - template - struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; - - template - struct __uses_alloc; - - template - struct __uses_alloc - : __conditional_t< - is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, - __uses_alloc1<_Alloc>, - __uses_alloc2<_Alloc>> - { - - - static_assert(__or_< - is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, - is_constructible<_Tp, _Args..., const _Alloc&>>::value, - "construction with an allocator must be possible" - " if uses_allocator is true"); - }; - - template - struct __uses_alloc - : __uses_alloc0 { }; - - template - using __uses_alloc_t = - __uses_alloc::value, _Tp, _Alloc, _Args...>; - - template - - inline __uses_alloc_t<_Tp, _Alloc, _Args...> - __use_alloc(const _Alloc& __a) - { - __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; - __ret._M_a = std::__addressof(__a); - return __ret; - } - - template - void - __use_alloc(const _Alloc&&) = delete; - - - template - inline constexpr bool uses_allocator_v = - uses_allocator<_Tp, _Alloc>::value; - - - template class _Predicate, - typename _Tp, typename _Alloc, typename... _Args> - struct __is_uses_allocator_predicate - : __conditional_t::value, - __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, - _Predicate<_Tp, _Args..., _Alloc>>, - _Predicate<_Tp, _Args...>> { }; - - template - struct __is_uses_allocator_constructible - : __is_uses_allocator_predicate - { }; - - - template - inline constexpr bool __is_uses_allocator_constructible_v = - __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; - - - template - struct __is_nothrow_uses_allocator_constructible - : __is_uses_allocator_predicate - { }; - - - - template - inline constexpr bool - __is_nothrow_uses_allocator_constructible_v = - __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; - - - template - void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr, - _Args&&... __args) - { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } - - template - void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr, - _Args&&... __args) - { - ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a, - std::forward<_Args>(__args)...); - } - - template - void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr, - _Args&&... __args) - { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); } - - template - void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr, - _Args&&... __args) - { - std::__uses_allocator_construct_impl( - std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr, - std::forward<_Args>(__args)...); - } - - - -} -# 76 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - - - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 - - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 - template::type> - constexpr _Up&& - __invfwd(typename remove_reference<_Tp>::type& __t) noexcept - { return static_cast<_Up&&>(__t); } - - template - constexpr _Res - __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) - { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } - - template - constexpr _Res - __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, - _Args&&... __args) - { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } - - template - constexpr _Res - __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, - _Args&&... __args) - { - return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); - } - - template - constexpr _Res - __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) - { return __invfwd<_Tp>(__t).*__f; } - - template - constexpr _Res - __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) - { return (*std::forward<_Tp>(__t)).*__f; } - - - template - constexpr typename __invoke_result<_Callable, _Args...>::type - __invoke(_Callable&& __fn, _Args&&... __args) - noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) - { - using __result = __invoke_result<_Callable, _Args...>; - using __type = typename __result::type; - using __tag = typename __result::__invoke_type; - return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - } - - - - template - constexpr enable_if_t, _Res> - __invoke_r(_Callable&& __fn, _Args&&... __args) - noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) - { - using __result = __invoke_result<_Callable, _Args...>; - using __type = typename __result::type; - using __tag = typename __result::__invoke_type; - if constexpr (is_void_v<_Res>) - std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - else - return std::__invoke_impl<__type>(__tag{}, - std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - } -# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - class tuple; - - template - struct __is_empty_non_tuple : is_empty<_Tp> { }; - - - template - struct __is_empty_non_tuple> : false_type { }; - - - template - using __empty_not_final - = __conditional_t<__is_final(_Tp), false_type, - __is_empty_non_tuple<_Tp>>; - - template::value> - struct _Head_base; - - - template - struct _Head_base<_Idx, _Head, true> - { - constexpr _Head_base() - : _M_head_impl() { } - - constexpr _Head_base(const _Head& __h) - : _M_head_impl(__h) { } - - constexpr _Head_base(const _Head_base&) = default; - constexpr _Head_base(_Head_base&&) = default; - - template - constexpr _Head_base(_UHead&& __h) - : _M_head_impl(std::forward<_UHead>(__h)) { } - - - _Head_base(allocator_arg_t, __uses_alloc0) - : _M_head_impl() { } - - template - - _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) - : _M_head_impl(allocator_arg, *__a._M_a) { } - - template - - _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) - : _M_head_impl(*__a._M_a) { } - - template - - _Head_base(__uses_alloc0, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead)) { } - - template - - _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) - { } - - template - - _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } - - static constexpr _Head& - _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } - - static constexpr const _Head& - _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } - - [[__no_unique_address__]] _Head _M_head_impl; - }; -# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - struct _Head_base<_Idx, _Head, false> - { - constexpr _Head_base() - : _M_head_impl() { } - - constexpr _Head_base(const _Head& __h) - : _M_head_impl(__h) { } - - constexpr _Head_base(const _Head_base&) = default; - constexpr _Head_base(_Head_base&&) = default; - - template - constexpr _Head_base(_UHead&& __h) - : _M_head_impl(std::forward<_UHead>(__h)) { } - - - _Head_base(allocator_arg_t, __uses_alloc0) - : _M_head_impl() { } - - template - - _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) - : _M_head_impl(allocator_arg, *__a._M_a) { } - - template - - _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) - : _M_head_impl(*__a._M_a) { } - - template - - _Head_base(__uses_alloc0, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead)) { } - - template - - _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) - { } - - template - - _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } - - static constexpr _Head& - _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } - - static constexpr const _Head& - _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } - - _Head _M_head_impl; - }; -# 250 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - struct _Tuple_impl; - - - - - - - template - struct _Tuple_impl<_Idx, _Head, _Tail...> - : public _Tuple_impl<_Idx + 1, _Tail...>, - private _Head_base<_Idx, _Head> - { - template friend struct _Tuple_impl; - - typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; - typedef _Head_base<_Idx, _Head> _Base; - - static constexpr _Head& - _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - static constexpr const _Head& - _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - static constexpr _Inherited& - _M_tail(_Tuple_impl& __t) noexcept { return __t; } - - static constexpr const _Inherited& - _M_tail(const _Tuple_impl& __t) noexcept { return __t; } - - constexpr _Tuple_impl() - : _Inherited(), _Base() { } - - explicit constexpr - _Tuple_impl(const _Head& __head, const _Tail&... __tail) - : _Inherited(__tail...), _Base(__head) - { } - - template> - explicit constexpr - _Tuple_impl(_UHead&& __head, _UTail&&... __tail) - : _Inherited(std::forward<_UTail>(__tail)...), - _Base(std::forward<_UHead>(__head)) - { } - - constexpr _Tuple_impl(const _Tuple_impl&) = default; - - - - _Tuple_impl& operator=(const _Tuple_impl&) = delete; - - _Tuple_impl(_Tuple_impl&&) = default; - - template - constexpr - _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) - : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), - _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) - { } - - template - constexpr - _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) - : _Inherited(std::move - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), - _Base(std::forward<_UHead> - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) - { } -# 338 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) - : _Inherited(__tag, __a), - _Base(__tag, __use_alloc<_Head>(__a)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Head& __head, const _Tail&... __tail) - : _Inherited(__tag, __a, __tail...), - _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) - { } - - template> - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _UHead&& __head, _UTail&&... __tail) - : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), - _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead>(__head)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl& __in) - : _Inherited(__tag, __a, _M_tail(__in)), - _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl&& __in) - : _Inherited(__tag, __a, std::move(_M_tail(__in))), - _Base(__use_alloc<_Head, _Alloc, _Head>(__a), - std::forward<_Head>(_M_head(__in))) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl<_Idx, _UHead, _UTails...>& __in) - : _Inherited(__tag, __a, - _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), - _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), - _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) - : _Inherited(__tag, __a, std::move - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), - _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead> - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) - { } -# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - void - _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) - { - _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); - _M_tail(*this)._M_assign( - _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); - } - - template - - void - _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) - { - _M_head(*this) = std::forward<_UHead> - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); - _M_tail(*this)._M_assign( - std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); - } -# 466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - protected: - - void - _M_swap(_Tuple_impl& __in) - { - using std::swap; - swap(_M_head(*this), _M_head(__in)); - _Inherited::_M_swap(_M_tail(__in)); - } -# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - template - struct _Tuple_impl<_Idx, _Head> - : private _Head_base<_Idx, _Head> - { - template friend struct _Tuple_impl; - - typedef _Head_base<_Idx, _Head> _Base; - - static constexpr _Head& - _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - static constexpr const _Head& - _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - constexpr - _Tuple_impl() - : _Base() { } - - explicit constexpr - _Tuple_impl(const _Head& __head) - : _Base(__head) - { } - - template - explicit constexpr - _Tuple_impl(_UHead&& __head) - : _Base(std::forward<_UHead>(__head)) - { } - - constexpr _Tuple_impl(const _Tuple_impl&) = default; - - - - _Tuple_impl& operator=(const _Tuple_impl&) = delete; - - - - - constexpr - _Tuple_impl(_Tuple_impl&& __in) - noexcept(is_nothrow_move_constructible<_Head>::value) - : _Base(static_cast<_Base&&>(__in)) - { } - - - template - constexpr - _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) - : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) - { } - - template - constexpr - _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) - : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) - { } -# 559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) - : _Base(__tag, __use_alloc<_Head>(__a)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Head& __head) - : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _UHead&& __head) - : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead>(__head)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl& __in) - : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl&& __in) - : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), - std::forward<_Head>(_M_head(__in))) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl<_Idx, _UHead>& __in) - : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), - _Tuple_impl<_Idx, _UHead>::_M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl<_Idx, _UHead>&& __in) - : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) - { } -# 629 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - void - _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) - { - _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); - } - - template - - void - _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) - { - _M_head(*this) - = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); - } -# 663 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - protected: - - void - _M_swap(_Tuple_impl& __in) - { - using std::swap; - swap(_M_head(*this), _M_head(__in)); - } -# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - - template - struct _TupleConstraints - { - template - using __constructible = __and_...>; - - template - using __convertible = __and_...>; - - - - - template - static constexpr bool __is_implicitly_constructible() - { - return __and_<__constructible<_UTypes...>, - __convertible<_UTypes...> - >::value; - } - - - - - template - static constexpr bool __is_explicitly_constructible() - { - return __and_<__constructible<_UTypes...>, - __not_<__convertible<_UTypes...>> - >::value; - } - - static constexpr bool __is_implicitly_default_constructible() - { - return __and_... - >::value; - } - - static constexpr bool __is_explicitly_default_constructible() - { - return __and_..., - __not_<__and_< - std::__is_implicitly_default_constructible<_Types>...> - >>::value; - } - }; - - - - template - struct _TupleConstraints - { - template - static constexpr bool __is_implicitly_constructible() - { return false; } - - template - static constexpr bool __is_explicitly_constructible() - { return false; } - }; - - - template - class tuple : public _Tuple_impl<0, _Elements...> - { - typedef _Tuple_impl<0, _Elements...> _Inherited; - - template - using _TCC = _TupleConstraints<_Cond, _Elements...>; - - - template - using _ImplicitDefaultCtor = __enable_if_t< - _TCC<_Dummy>::__is_implicitly_default_constructible(), - bool>; - - - template - using _ExplicitDefaultCtor = __enable_if_t< - _TCC<_Dummy>::__is_explicitly_default_constructible(), - bool>; - - - template - using _ImplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), - bool>; - - - template - using _ExplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), - bool>; - - template - static constexpr - __enable_if_t - __assignable() - { return __and_...>::value; } - - - template - static constexpr bool __nothrow_assignable() - { - return - __and_...>::value; - } - - - template - static constexpr bool __nothrow_constructible() - { - return - __and_...>::value; - } - - - template - static constexpr bool __valid_args() - { - return sizeof...(_Elements) == 1 - && !is_same>::value; - } - - - template - static constexpr bool __valid_args() - { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } -# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template> - struct _UseOtherCtor - : false_type - { }; - - - template - struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> - : __or_, is_constructible<_Tp, _Tuple>>::type - { }; - - - template - struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> - : true_type - { }; - - - - - template - static constexpr bool __use_other_ctor() - { return _UseOtherCtor<_Tuple>::value; } -# 856 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - public: - template::value> = true> - constexpr - tuple() - noexcept(__and_...>::value) - : _Inherited() { } - - template::value> = false> - explicit constexpr - tuple() - noexcept(__and_...>::value) - : _Inherited() { } - - template= 1), - _ImplicitCtor<_NotEmpty, const _Elements&...> = true> - constexpr - tuple(const _Elements&... __elements) - noexcept(__nothrow_constructible()) - : _Inherited(__elements...) { } - - template= 1), - _ExplicitCtor<_NotEmpty, const _Elements&...> = false> - explicit constexpr - tuple(const _Elements&... __elements) - noexcept(__nothrow_constructible()) - : _Inherited(__elements...) { } - - template(), - _ImplicitCtor<_Valid, _UElements...> = true> - constexpr - tuple(_UElements&&... __elements) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(std::forward<_UElements>(__elements)...) { } - - template(), - _ExplicitCtor<_Valid, _UElements...> = false> - explicit constexpr - tuple(_UElements&&... __elements) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(std::forward<_UElements>(__elements)...) { } - - constexpr tuple(const tuple&) = default; - - constexpr tuple(tuple&&) = default; - - template&>(), - _ImplicitCtor<_Valid, const _UElements&...> = true> - constexpr - tuple(const tuple<_UElements...>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) - { } - - template&>(), - _ExplicitCtor<_Valid, const _UElements&...> = false> - explicit constexpr - tuple(const tuple<_UElements...>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) - { } - - template&&>(), - _ImplicitCtor<_Valid, _UElements...> = true> - constexpr - tuple(tuple<_UElements...>&& __in) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } - - template&&>(), - _ExplicitCtor<_Valid, _UElements...> = false> - explicit constexpr - tuple(tuple<_UElements...>&& __in) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } -# 968 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template::value> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a) - : _Inherited(__tag, __a) { } - - template= 1), - _ImplicitCtor<_NotEmpty, const _Elements&...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _Elements&... __elements) - : _Inherited(__tag, __a, __elements...) { } - - template= 1), - _ExplicitCtor<_NotEmpty, const _Elements&...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _Elements&... __elements) - : _Inherited(__tag, __a, __elements...) { } - - template(), - _ImplicitCtor<_Valid, _UElements...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - _UElements&&... __elements) - : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) - { } - - template(), - _ExplicitCtor<_Valid, _UElements...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - _UElements&&... __elements) - : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) - { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) - : _Inherited(__tag, __a, static_cast(__in)) { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) - : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } - - template&>(), - _ImplicitCtor<_Valid, const _UElements&...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_UElements...>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template&>(), - _ExplicitCtor<_Valid, const _UElements&...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_UElements...>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template&&>(), - _ImplicitCtor<_Valid, _UElements...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - tuple<_UElements...>&& __in) - : _Inherited(__tag, __a, - static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) - { } - - template&&>(), - _ExplicitCtor<_Valid, _UElements...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - tuple<_UElements...>&& __in) - : _Inherited(__tag, __a, - static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) - { } -# 1093 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - tuple& - operator=(__conditional_t<__assignable(), - const tuple&, - const __nonesuch&> __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - - tuple& - operator=(__conditional_t<__assignable<_Elements...>(), - tuple&&, - __nonesuch&&> __in) - noexcept(__nothrow_assignable<_Elements...>()) - { - this->_M_assign(std::move(__in)); - return *this; - } - - template - - __enable_if_t<__assignable(), tuple&> - operator=(const tuple<_UElements...>& __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - template - - __enable_if_t<__assignable<_UElements...>(), tuple&> - operator=(tuple<_UElements...>&& __in) - noexcept(__nothrow_assignable<_UElements...>()) - { - this->_M_assign(std::move(__in)); - return *this; - } -# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - void - swap(tuple& __in) - noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) - { _Inherited::_M_swap(__in); } -# 1192 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - template - tuple(_UTypes...) -> tuple<_UTypes...>; - template - tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; - template - tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; - template - tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; - template - tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; - - - - template<> - class tuple<> - { - public: - - void swap(tuple&) noexcept { } - - - - - - tuple() = default; - - template - - tuple(allocator_arg_t, const _Alloc&) noexcept { } - template - - tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } - }; - - - - template - class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> - { - typedef _Tuple_impl<0, _T1, _T2> _Inherited; - - - template - using _ImplicitDefaultCtor = __enable_if_t< - _TupleConstraints<_Dummy, _U1, _U2>:: - __is_implicitly_default_constructible(), - bool>; - - - template - using _ExplicitDefaultCtor = __enable_if_t< - _TupleConstraints<_Dummy, _U1, _U2>:: - __is_explicitly_default_constructible(), - bool>; - - template - using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; - - - template - using _ImplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), - bool>; - - - template - using _ExplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), - bool>; - - template - static constexpr bool __assignable() - { - return __and_, - is_assignable<_T2&, _U2>>::value; - } - - template - static constexpr bool __nothrow_assignable() - { - return __and_, - is_nothrow_assignable<_T2&, _U2>>::value; - } - - template - static constexpr bool __nothrow_constructible() - { - return __and_, - is_nothrow_constructible<_T2, _U2>>::value; - } - - static constexpr bool __nothrow_default_constructible() - { - return __and_, - is_nothrow_default_constructible<_T2>>::value; - } - - template - static constexpr bool __is_alloc_arg() - { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } -# 1306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - public: - template = true> - constexpr - tuple() - noexcept(__nothrow_default_constructible()) - : _Inherited() { } - - template = false> - explicit constexpr - tuple() - noexcept(__nothrow_default_constructible()) - : _Inherited() { } - - template = true> - constexpr - tuple(const _T1& __a1, const _T2& __a2) - noexcept(__nothrow_constructible()) - : _Inherited(__a1, __a2) { } - - template = false> - explicit constexpr - tuple(const _T1& __a1, const _T2& __a2) - noexcept(__nothrow_constructible()) - : _Inherited(__a1, __a2) { } - - template(), _U1, _U2> = true> - constexpr - tuple(_U1&& __a1, _U2&& __a2) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } - - template(), _U1, _U2> = false> - explicit constexpr - tuple(_U1&& __a1, _U2&& __a2) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } - - constexpr tuple(const tuple&) = default; - - constexpr tuple(tuple&&) = default; - - template = true> - constexpr - tuple(const tuple<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) { } - - template = false> - explicit constexpr - tuple(const tuple<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) { } - - template = true> - constexpr - tuple(tuple<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } - - template = false> - explicit constexpr - tuple(tuple<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } -# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template = true> - constexpr - tuple(const pair<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(__in.first, __in.second) { } - - template = false> - explicit constexpr - tuple(const pair<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(__in.first, __in.second) { } - - template = true> - constexpr - tuple(pair<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } - - template = false> - explicit constexpr - tuple(pair<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } -# 1450 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template::value, _T1, _T2> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a) - : _Inherited(__tag, __a) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _T1& __a1, const _T2& __a2) - : _Inherited(__tag, __a, __a1, __a2) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _T1& __a1, const _T2& __a2) - : _Inherited(__tag, __a, __a1, __a2) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) - : _Inherited(__tag, __a, std::forward<_U1>(__a1), - std::forward<_U2>(__a2)) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - _U1&& __a1, _U2&& __a2) - : _Inherited(__tag, __a, std::forward<_U1>(__a1), - std::forward<_U2>(__a2)) { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) - : _Inherited(__tag, __a, static_cast(__in)) { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) - : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_U1, _U2>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_U1, _U2>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) - : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) - { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) - : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) - { } -# 1553 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const pair<_U1, _U2>& __in) - : _Inherited(__tag, __a, __in.first, __in.second) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const pair<_U1, _U2>& __in) - : _Inherited(__tag, __a, __in.first, __in.second) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) - : _Inherited(__tag, __a, std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) - : _Inherited(__tag, __a, std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } -# 1604 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - tuple& - operator=(__conditional_t<__assignable(), - const tuple&, - const __nonesuch&> __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - - tuple& - operator=(__conditional_t<__assignable<_T1, _T2>(), - tuple&&, - __nonesuch&&> __in) - noexcept(__nothrow_assignable<_T1, _T2>()) - { - this->_M_assign(std::move(__in)); - return *this; - } - - template - - __enable_if_t<__assignable(), tuple&> - operator=(const tuple<_U1, _U2>& __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - template - - __enable_if_t<__assignable<_U1, _U2>(), tuple&> - operator=(tuple<_U1, _U2>&& __in) - noexcept(__nothrow_assignable<_U1, _U2>()) - { - this->_M_assign(std::move(__in)); - return *this; - } -# 1683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - __enable_if_t<__assignable(), tuple&> - operator=(const pair<_U1, _U2>& __in) - noexcept(__nothrow_assignable()) - { - this->_M_head(*this) = __in.first; - this->_M_tail(*this)._M_head(*this) = __in.second; - return *this; - } - - template - - __enable_if_t<__assignable<_U1, _U2>(), tuple&> - operator=(pair<_U1, _U2>&& __in) - noexcept(__nothrow_assignable<_U1, _U2>()) - { - this->_M_head(*this) = std::forward<_U1>(__in.first); - this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); - return *this; - } -# 1730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - void - swap(tuple& __in) - noexcept(__and_<__is_nothrow_swappable<_T1>, - __is_nothrow_swappable<_T2>>::value) - { _Inherited::_M_swap(__in); } -# 1744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - - template - struct tuple_size> - : public integral_constant { }; - - - template - inline constexpr size_t tuple_size_v> - = sizeof...(_Types); - - template - inline constexpr size_t tuple_size_v> - = sizeof...(_Types); - - - - template - struct tuple_element<__i, tuple<_Types...>> - { - static_assert(__i < sizeof...(_Types), "tuple index must be in range"); - - using type = typename _Nth_type<__i, _Types...>::type; - }; - - template - constexpr _Head& - __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept - { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } - - template - constexpr const _Head& - __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept - { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } - - - template - __enable_if_t<(__i >= sizeof...(_Types))> - __get_helper(const tuple<_Types...>&) = delete; - - - template - constexpr __tuple_element_t<__i, tuple<_Elements...>>& - get(tuple<_Elements...>& __t) noexcept - { return std::__get_helper<__i>(__t); } - - - template - constexpr const __tuple_element_t<__i, tuple<_Elements...>>& - get(const tuple<_Elements...>& __t) noexcept - { return std::__get_helper<__i>(__t); } - - - template - constexpr __tuple_element_t<__i, tuple<_Elements...>>&& - get(tuple<_Elements...>&& __t) noexcept - { - typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; - return std::forward<__element_type>(std::__get_helper<__i>(__t)); - } - - - template - constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& - get(const tuple<_Elements...>&& __t) noexcept - { - typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; - return std::forward(std::__get_helper<__i>(__t)); - } - - - - template - constexpr __enable_if_t<(__i >= sizeof...(_Elements))> - get(const tuple<_Elements...>&) = delete; - - - - - - - - template - constexpr _Tp& - get(tuple<_Types...>& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::__get_helper<__idx>(__t); - } - - - template - constexpr _Tp&& - get(tuple<_Types...>&& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::forward<_Tp>(std::__get_helper<__idx>(__t)); - } - - - template - constexpr const _Tp& - get(const tuple<_Types...>& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::__get_helper<__idx>(__t); - } - - - - template - constexpr const _Tp&& - get(const tuple<_Types...>&& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::forward(std::__get_helper<__idx>(__t)); - } - - - - template - struct __tuple_compare - { - static constexpr bool - __eq(const _Tp& __t, const _Up& __u) - { - return bool(std::get<__i>(__t) == std::get<__i>(__u)) - && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); - } - - static constexpr bool - __less(const _Tp& __t, const _Up& __u) - { - return bool(std::get<__i>(__t) < std::get<__i>(__u)) - || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) - && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); - } - }; - - template - struct __tuple_compare<_Tp, _Up, __size, __size> - { - static constexpr bool - __eq(const _Tp&, const _Up&) { return true; } - - static constexpr bool - __less(const _Tp&, const _Up&) { return false; } - }; - - template - constexpr bool - operator==(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { - static_assert(sizeof...(_TElements) == sizeof...(_UElements), - "tuple objects can only be compared if they have equal sizes."); - using __compare = __tuple_compare, - tuple<_UElements...>, - 0, sizeof...(_TElements)>; - return __compare::__eq(__t, __u); - } -# 1945 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - constexpr bool - operator<(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { - static_assert(sizeof...(_TElements) == sizeof...(_UElements), - "tuple objects can only be compared if they have equal sizes."); - using __compare = __tuple_compare, - tuple<_UElements...>, - 0, sizeof...(_TElements)>; - return __compare::__less(__t, __u); - } - - template - constexpr bool - operator!=(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return !(__t == __u); } - - template - constexpr bool - operator>(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return __u < __t; } - - template - constexpr bool - operator<=(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return !(__u < __t); } - - template - constexpr bool - operator>=(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return !(__t < __u); } - - - - - template - constexpr tuple::__type...> - make_tuple(_Elements&&... __args) - { - typedef tuple::__type...> - __result_type; - return __result_type(std::forward<_Elements>(__args)...); - } - - - - - template - constexpr tuple<_Elements&&...> - forward_as_tuple(_Elements&&... __args) noexcept - { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } - - - - - template struct array; - - template - constexpr _Tp& - get(array<_Tp, _Nm>&) noexcept; - - template - constexpr _Tp&& - get(array<_Tp, _Nm>&&) noexcept; - - template - constexpr const _Tp& - get(const array<_Tp, _Nm>&) noexcept; - - template - constexpr const _Tp&& - get(const array<_Tp, _Nm>&&) noexcept; - - - template - struct __make_tuple_impl; - - template - struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> - : __make_tuple_impl<_Idx + 1, - tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, - _Tuple, _Nm> - { }; - - template - struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> - { - typedef tuple<_Tp...> __type; - }; - - template - struct __do_make_tuple - : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value> - { }; - - - template - struct __make_tuple - : public __do_make_tuple<__remove_cvref_t<_Tuple>> - { }; - - - template - struct __combine_tuples; - - template<> - struct __combine_tuples<> - { - typedef tuple<> __type; - }; - - template - struct __combine_tuples> - { - typedef tuple<_Ts...> __type; - }; - - template - struct __combine_tuples, tuple<_T2s...>, _Rem...> - { - typedef typename __combine_tuples, - _Rem...>::__type __type; - }; - - - template - struct __tuple_cat_result - { - typedef typename __combine_tuples - ::__type...>::__type __type; - }; - - - - template - struct __make_1st_indices; - - template<> - struct __make_1st_indices<> - { - typedef _Index_tuple<> __type; - }; - - template - struct __make_1st_indices<_Tp, _Tpls...> - { - typedef typename _Build_index_tuple::type>::value>::__type __type; - }; - - - - - template - struct __tuple_concater; - - template - struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...> - { - template - static constexpr _Ret - _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) - { - typedef typename __make_1st_indices<_Tpls...>::__type __idx; - typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; - return __next::_S_do(std::forward<_Tpls>(__tps)..., - std::forward<_Us>(__us)..., - std::get<_Is>(std::forward<_Tp>(__tp))...); - } - }; - - template - struct __tuple_concater<_Ret, _Index_tuple<>> - { - template - static constexpr _Ret - _S_do(_Us&&... __us) - { - return _Ret(std::forward<_Us>(__us)...); - } - }; - - template - struct __is_tuple_like_impl> : true_type - { }; - - - - template...>::value>::type> - constexpr auto - tuple_cat(_Tpls&&... __tpls) - -> typename __tuple_cat_result<_Tpls...>::__type - { - typedef typename __tuple_cat_result<_Tpls...>::__type __ret; - typedef typename __make_1st_indices<_Tpls...>::__type __idx; - typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; - return __concater::_S_do(std::forward<_Tpls>(__tpls)...); - } - - - - - template - constexpr tuple<_Elements&...> - tie(_Elements&... __args) noexcept - { return tuple<_Elements&...>(__args...); } - - - template - - inline - - - typename enable_if<__and_<__is_swappable<_Elements>...>::value - >::type - - - - swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } -# 2184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - typename enable_if...>::value>::type - swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; - - - - - - - struct _Swallow_assign - { - template - constexpr const _Swallow_assign& - operator=(const _Tp&) const - { return *this; } - }; -# 2219 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - inline constexpr _Swallow_assign ignore{}; - - - template - struct uses_allocator, _Alloc> : true_type { }; -# 2234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - template - - inline - pair<_T1, _T2>:: - pair(piecewise_construct_t, - tuple<_Args1...> __first, tuple<_Args2...> __second) - : pair(__first, __second, - typename _Build_index_tuple::__type(), - typename _Build_index_tuple::__type()) - { } - - template - template - inline - pair<_T1, _T2>:: - pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, - _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) - : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), - second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) - { } - - - - - - - - template class _Trait, typename _Tp, typename _Tuple> - inline constexpr bool __unpack_std_tuple = false; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> - = _Trait<_Tp, _Up...>::value; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> - = _Trait<_Tp, _Up&...>::value; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> - = _Trait<_Tp, const _Up...>::value; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> - = _Trait<_Tp, const _Up&...>::value; - - - - template - constexpr decltype(auto) - __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) - { - return std::__invoke(std::forward<_Fn>(__f), - std::get<_Idx>(std::forward<_Tuple>(__t))...); - } - - template - constexpr decltype(auto) - apply(_Fn&& __f, _Tuple&& __t) - noexcept(__unpack_std_tuple) - { - using _Indices - = make_index_sequence>>; - return std::__apply_impl(std::forward<_Fn>(__f), - std::forward<_Tuple>(__t), - _Indices{}); - } - - - - template - constexpr _Tp - __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) - { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } - - template - constexpr _Tp - make_from_tuple(_Tuple&& __t) - noexcept(__unpack_std_tuple) - { - constexpr size_t __n = tuple_size_v>; - - - - - - - - return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t), - make_index_sequence<__n>{}); - } -# 2345 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 -} -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct unary_function - { - - typedef _Arg argument_type; - - - typedef _Result result_type; - } __attribute__ ((__deprecated__)); - - - - - - template - struct binary_function - { - - typedef _Arg1 first_argument_type; - - - typedef _Arg2 second_argument_type; - - - typedef _Result result_type; - } __attribute__ ((__deprecated__)); -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - struct __is_transparent; - - template - struct plus; - - template - struct minus; - - template - struct multiplies; - - template - struct divides; - - template - struct modulus; - - template - struct negate; - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct plus : public binary_function<_Tp, _Tp, _Tp> - { - - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x + __y; } - }; - - - template - struct minus : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x - __y; } - }; - - - template - struct multiplies : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x * __y; } - }; - - - template - struct divides : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x / __y; } - }; - - - template - struct modulus : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x % __y; } - }; - - - template - struct negate : public unary_function<_Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x) const - { return -__x; } - }; -#pragma GCC diagnostic pop - - - - - - template<> - struct plus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct minus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct multiplies - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct divides - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct modulus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct negate - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(-std::forward<_Tp>(__t))) - -> decltype(-std::forward<_Tp>(__t)) - { return -std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; -# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct equal_to; - - template - struct not_equal_to; - - template - struct greater; - - template - struct less; - - template - struct greater_equal; - - template - struct less_equal; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct equal_to : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x == __y; } - }; - - - template - struct not_equal_to : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x != __y; } - }; - - - template - struct greater : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x > __y; } - }; - - - template - struct less : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x < __y; } - }; - - - template - struct greater_equal : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x >= __y; } - }; - - - template - struct less_equal : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x <= __y; } - }; - - - template - struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x > __y; - - return (long unsigned int)__x > (long unsigned int)__y; - } - }; - - - template - struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x < __y; - - return (long unsigned int)__x < (long unsigned int)__y; - } - }; - - - template - struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x >= __y; - - return (long unsigned int)__x >= (long unsigned int)__y; - } - }; - - - template - struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x <= __y; - - return (long unsigned int)__x <= (long unsigned int)__y; - } - }; -#pragma GCC diagnostic pop - - - - template<> - struct equal_to - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct not_equal_to - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct greater - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return greater>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return greater{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct less - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return less>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return less{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct greater_equal - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return greater_equal>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return greater_equal{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct less_equal - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return less_equal>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return less_equal{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; -# 781 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct logical_and; - - template - struct logical_or; - - template - struct logical_not; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct logical_and : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x && __y; } - }; - - - template - struct logical_or : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x || __y; } - }; - - - template - struct logical_not : public unary_function<_Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x) const - { return !__x; } - }; -#pragma GCC diagnostic pop - - - - template<> - struct logical_and - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct logical_or - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct logical_not - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(!std::forward<_Tp>(__t))) - -> decltype(!std::forward<_Tp>(__t)) - { return !std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; - - - - - template - struct bit_and; - - template - struct bit_or; - - template - struct bit_xor; - - template - struct bit_not; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - - template - struct bit_and : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x & __y; } - }; - - template - struct bit_or : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x | __y; } - }; - - template - struct bit_xor : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x ^ __y; } - }; - - template - struct bit_not : public unary_function<_Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x) const - { return ~__x; } - }; -#pragma GCC diagnostic pop - - - template <> - struct bit_and - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_or - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_xor - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_not - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(~std::forward<_Tp>(__t))) - -> decltype(~std::forward<_Tp>(__t)) - { return ~std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class [[__deprecated__]] unary_negate - : public unary_function - { - protected: - _Predicate _M_pred; - - public: - constexpr - explicit - unary_negate(const _Predicate& __x) : _M_pred(__x) { } - - constexpr - bool - operator()(const typename _Predicate::argument_type& __x) const - { return !_M_pred(__x); } - }; - - - template - __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) - constexpr - inline unary_negate<_Predicate> - not1(const _Predicate& __pred) - { return unary_negate<_Predicate>(__pred); } - - - template - class [[__deprecated__]] binary_negate - : public binary_function - { - protected: - _Predicate _M_pred; - - public: - constexpr - explicit - binary_negate(const _Predicate& __x) : _M_pred(__x) { } - - constexpr - bool - operator()(const typename _Predicate::first_argument_type& __x, - const typename _Predicate::second_argument_type& __y) const - { return !_M_pred(__x, __y); } - }; - - - template - __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) - constexpr - inline binary_negate<_Predicate> - not2(const _Predicate& __pred) - { return binary_negate<_Predicate>(__pred); } -# 1104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class pointer_to_unary_function : public unary_function<_Arg, _Result> - { - protected: - _Result (*_M_ptr)(_Arg); - - public: - pointer_to_unary_function() { } - - explicit - pointer_to_unary_function(_Result (*__x)(_Arg)) - : _M_ptr(__x) { } - - _Result - operator()(_Arg __x) const - { return _M_ptr(__x); } - } __attribute__ ((__deprecated__)); - - - template - __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) - inline pointer_to_unary_function<_Arg, _Result> - ptr_fun(_Result (*__x)(_Arg)) - { return pointer_to_unary_function<_Arg, _Result>(__x); } - - - template - class pointer_to_binary_function - : public binary_function<_Arg1, _Arg2, _Result> - { - protected: - _Result (*_M_ptr)(_Arg1, _Arg2); - - public: - pointer_to_binary_function() { } - - explicit - pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) - : _M_ptr(__x) { } - - _Result - operator()(_Arg1 __x, _Arg2 __y) const - { return _M_ptr(__x, __y); } - } __attribute__ ((__deprecated__)); - - - template - __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) - inline pointer_to_binary_function<_Arg1, _Arg2, _Result> - ptr_fun(_Result (*__x)(_Arg1, _Arg2)) - { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } - - - template - struct _Identity - : public unary_function<_Tp, _Tp> - { - _Tp& - operator()(_Tp& __x) const - { return __x; } - - const _Tp& - operator()(const _Tp& __x) const - { return __x; } - }; - - - template struct _Identity : _Identity<_Tp> { }; - - template - struct _Select1st - : public unary_function<_Pair, typename _Pair::first_type> - { - typename _Pair::first_type& - operator()(_Pair& __x) const - { return __x.first; } - - const typename _Pair::first_type& - operator()(const _Pair& __x) const - { return __x.first; } - - - template - typename _Pair2::first_type& - operator()(_Pair2& __x) const - { return __x.first; } - - template - const typename _Pair2::first_type& - operator()(const _Pair2& __x) const - { return __x.first; } - - }; - - template - struct _Select2nd - : public unary_function<_Pair, typename _Pair::second_type> - { - typename _Pair::second_type& - operator()(_Pair& __x) const - { return __x.second; } - - const typename _Pair::second_type& - operator()(const _Pair& __x) const - { return __x.second; } - }; -# 1231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class mem_fun_t : public unary_function<_Tp*, _Ret> - { - public: - explicit - mem_fun_t(_Ret (_Tp::*__pf)()) - : _M_f(__pf) { } - - _Ret - operator()(_Tp* __p) const - { return (__p->*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)(); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun_t : public unary_function - { - public: - explicit - const_mem_fun_t(_Ret (_Tp::*__pf)() const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp* __p) const - { return (__p->*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)() const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun_ref_t : public unary_function<_Tp, _Ret> - { - public: - explicit - mem_fun_ref_t(_Ret (_Tp::*__pf)()) - : _M_f(__pf) { } - - _Ret - operator()(_Tp& __r) const - { return (__r.*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)(); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> - { - public: - explicit - const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp& __r) const - { return (__r.*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)() const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> - { - public: - explicit - mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) - : _M_f(__pf) { } - - _Ret - operator()(_Tp* __p, _Arg __x) const - { return (__p->*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun1_t : public binary_function - { - public: - explicit - const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp* __p, _Arg __x) const - { return (__p->*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg) const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> - { - public: - explicit - mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) - : _M_f(__pf) { } - - _Ret - operator()(_Tp& __r, _Arg __x) const - { return (__r.*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> - { - public: - explicit - const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp& __r, _Arg __x) const - { return (__r.*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg) const; - } __attribute__ ((__deprecated__)); - - - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun_t<_Ret, _Tp> - mem_fun(_Ret (_Tp::*__f)()) - { return mem_fun_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun_t<_Ret, _Tp> - mem_fun(_Ret (_Tp::*__f)() const) - { return const_mem_fun_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun_ref_t<_Ret, _Tp> - mem_fun_ref(_Ret (_Tp::*__f)()) - { return mem_fun_ref_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun_ref_t<_Ret, _Tp> - mem_fun_ref(_Ret (_Tp::*__f)() const) - { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun1_t<_Ret, _Tp, _Arg> - mem_fun(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun1_t<_Ret, _Tp, _Arg> - mem_fun(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun1_ref_t<_Ret, _Tp, _Arg> - mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> - mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } -#pragma GCC diagnostic pop - - - - - template> - struct __has_is_transparent - { }; - - template - struct __has_is_transparent<_Func, _SfinaeType, - __void_t> - { typedef void type; }; - - template - using __has_is_transparent_t - = typename __has_is_transparent<_Func, _SfinaeType>::type; - - - -} - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 1 3 -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 - template - class binder1st - : public unary_function - { - protected: - _Operation op; - typename _Operation::first_argument_type value; - - public: - binder1st(const _Operation& __x, - const typename _Operation::first_argument_type& __y) - : op(__x), value(__y) { } - - typename _Operation::result_type - operator()(const typename _Operation::second_argument_type& __x) const - { return op(value, __x); } - - - - typename _Operation::result_type - operator()(typename _Operation::second_argument_type& __x) const - { return op(value, __x); } - } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); - - - template - __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) - inline binder1st<_Operation> - bind1st(const _Operation& __fn, const _Tp& __x) - { - typedef typename _Operation::first_argument_type _Arg1_type; - return binder1st<_Operation>(__fn, _Arg1_type(__x)); - } - - - template - class binder2nd - : public unary_function - { - protected: - _Operation op; - typename _Operation::second_argument_type value; - - public: - binder2nd(const _Operation& __x, - const typename _Operation::second_argument_type& __y) - : op(__x), value(__y) { } - - typename _Operation::result_type - operator()(const typename _Operation::first_argument_type& __x) const - { return op(__x, value); } - - - - typename _Operation::result_type - operator()(typename _Operation::first_argument_type& __x) const - { return op(__x, value); } - } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); - - - template - __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) - inline binder2nd<_Operation> - bind2nd(const _Operation& __fn, const _Tp& __x) - { - typedef typename _Operation::second_argument_type _Arg2_type; - return binder2nd<_Operation>(__fn, _Arg2_type(__x)); - } - - - -} - -#pragma GCC diagnostic pop -# 1439 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 2 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hash_bytes.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template - struct __hash_base - { - typedef _Result result_type [[__deprecated__]]; - typedef _Arg argument_type [[__deprecated__]]; - }; - - - template - struct hash; - - template - struct __poison_hash - { - static constexpr bool __enable_hash_call = false; - private: - - __poison_hash(__poison_hash&&); - ~__poison_hash(); - }; - - template - struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> - { - static constexpr bool __enable_hash_call = true; - }; - - - template::value> - struct __hash_enum - { - private: - - __hash_enum(__hash_enum&&); - ~__hash_enum(); - }; - - - template - struct __hash_enum<_Tp, true> : public __hash_base - { - size_t - operator()(_Tp __val) const noexcept - { - using __type = typename underlying_type<_Tp>::type; - return hash<__type>{}(static_cast<__type>(__val)); - } - }; - - - - template - struct hash : __hash_enum<_Tp> - { }; - - - template - struct hash<_Tp*> : public __hash_base - { - size_t - operator()(_Tp* __p) const noexcept - { return reinterpret_cast(__p); } - }; -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; - - - - - - - - template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; -# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - struct _Hash_impl - { - static size_t - hash(const void* __ptr, size_t __clength, - size_t __seed = static_cast(0xc70f6907UL)) - { return _Hash_bytes(__ptr, __clength, __seed); } - - template - static size_t - hash(const _Tp& __val) - { return hash(&__val, sizeof(__val)); } - - template - static size_t - __hash_combine(const _Tp& __val, size_t __hash) - { return hash(&__val, sizeof(__val), __hash); } - }; - - - struct _Fnv_hash_impl - { - static size_t - hash(const void* __ptr, size_t __clength, - size_t __seed = static_cast(2166136261UL)) - { return _Fnv_hash_bytes(__ptr, __clength, __seed); } - - template - static size_t - hash(const _Tp& __val) - { return hash(&__val, sizeof(__val)); } - - template - static size_t - __hash_combine(const _Tp& __val, size_t __hash) - { return hash(&__val, sizeof(__val), __hash); } - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(float __val) const noexcept - { - - return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; - } - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(double __val) const noexcept - { - - return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; - } - }; - - - template<> - struct hash - : public __hash_base - { - __attribute__ ((__pure__)) size_t - operator()(long double __val) const noexcept; - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(nullptr_t) const noexcept - { return 0; } - }; -# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template - struct __is_fast_hash : public std::true_type - { }; - - template<> - struct __is_fast_hash> : public std::false_type - { }; - - -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 2 3 -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template class auto_ptr; -#pragma GCC diagnostic pop - - - - - - - - template - struct default_delete - { - - constexpr default_delete() noexcept = default; - - - - - - - template>> - - default_delete(const default_delete<_Up>&) noexcept { } - - - - void - operator()(_Tp* __ptr) const - { - static_assert(!is_void<_Tp>::value, - "can't delete pointer to incomplete type"); - static_assert(sizeof(_Tp)>0, - "can't delete pointer to incomplete type"); - delete __ptr; - } - }; -# 111 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - struct default_delete<_Tp[]> - { - public: - - constexpr default_delete() noexcept = default; -# 127 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template>> - - default_delete(const default_delete<_Up[]>&) noexcept { } - - - template - - typename enable_if::value>::type - operator()(_Up* __ptr) const - { - static_assert(sizeof(_Tp)>0, - "can't delete pointer to incomplete type"); - delete [] __ptr; - } - }; - - - - - template - class __uniq_ptr_impl - { - template - struct _Ptr - { - using type = _Up*; - }; - - template - struct - _Ptr<_Up, _Ep, __void_t::type::pointer>> - { - using type = typename remove_reference<_Ep>::type::pointer; - }; - - public: - using _DeleterConstraint = enable_if< - __and_<__not_>, - is_default_constructible<_Dp>>::value>; - - using pointer = typename _Ptr<_Tp, _Dp>::type; - - static_assert( !is_rvalue_reference<_Dp>::value, - "unique_ptr's deleter type must be a function object type" - " or an lvalue reference type" ); - - __uniq_ptr_impl() = default; - - __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; } - - template - - __uniq_ptr_impl(pointer __p, _Del&& __d) - : _M_t(__p, std::forward<_Del>(__d)) { } - - - __uniq_ptr_impl(__uniq_ptr_impl&& __u) noexcept - : _M_t(std::move(__u._M_t)) - { __u._M_ptr() = nullptr; } - - - __uniq_ptr_impl& operator=(__uniq_ptr_impl&& __u) noexcept - { - reset(__u.release()); - _M_deleter() = std::forward<_Dp>(__u._M_deleter()); - return *this; - } - - - pointer& _M_ptr() noexcept { return std::get<0>(_M_t); } - - pointer _M_ptr() const noexcept { return std::get<0>(_M_t); } - - _Dp& _M_deleter() noexcept { return std::get<1>(_M_t); } - - const _Dp& _M_deleter() const noexcept { return std::get<1>(_M_t); } - - - void reset(pointer __p) noexcept - { - const pointer __old_p = _M_ptr(); - _M_ptr() = __p; - if (__old_p) - _M_deleter()(__old_p); - } - - - pointer release() noexcept - { - pointer __p = _M_ptr(); - _M_ptr() = nullptr; - return __p; - } - - - void - swap(__uniq_ptr_impl& __rhs) noexcept - { - using std::swap; - swap(this->_M_ptr(), __rhs._M_ptr()); - swap(this->_M_deleter(), __rhs._M_deleter()); - } - - private: - tuple _M_t; - }; - - - template ::value, - bool = is_move_assignable<_Dp>::value> - struct __uniq_ptr_data : __uniq_ptr_impl<_Tp, _Dp> - { - using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; - __uniq_ptr_data(__uniq_ptr_data&&) = default; - __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; - }; - - template - struct __uniq_ptr_data<_Tp, _Dp, true, false> : __uniq_ptr_impl<_Tp, _Dp> - { - using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; - __uniq_ptr_data(__uniq_ptr_data&&) = default; - __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; - }; - - template - struct __uniq_ptr_data<_Tp, _Dp, false, true> : __uniq_ptr_impl<_Tp, _Dp> - { - using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; - __uniq_ptr_data(__uniq_ptr_data&&) = delete; - __uniq_ptr_data& operator=(__uniq_ptr_data&&) = default; - }; - - template - struct __uniq_ptr_data<_Tp, _Dp, false, false> : __uniq_ptr_impl<_Tp, _Dp> - { - using __uniq_ptr_impl<_Tp, _Dp>::__uniq_ptr_impl; - __uniq_ptr_data(__uniq_ptr_data&&) = delete; - __uniq_ptr_data& operator=(__uniq_ptr_data&&) = delete; - }; - - - - - - - - template > - class unique_ptr - { - template - using _DeleterConstraint = - typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; - - __uniq_ptr_data<_Tp, _Dp> _M_t; - - public: - using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; - using element_type = _Tp; - using deleter_type = _Dp; - - private: - - - template - using __safe_conversion_up = __and_< - is_convertible::pointer, pointer>, - __not_> - >; - - public: - - - - template> - constexpr unique_ptr() noexcept - : _M_t() - { } - - - - - - - - template> - - explicit - unique_ptr(pointer __p) noexcept - : _M_t(__p) - { } -# 328 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template>> - - unique_ptr(pointer __p, const deleter_type& __d) noexcept - : _M_t(__p, __d) { } -# 341 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template>> - - unique_ptr(pointer __p, - __enable_if_t::value, - _Del&&> __d) noexcept - : _M_t(__p, std::move(__d)) - { } - - template::type> - - unique_ptr(pointer, - __enable_if_t::value, - _DelUnref&&>) = delete; - - - template> - constexpr unique_ptr(nullptr_t) noexcept - : _M_t() - { } - - - - - unique_ptr(unique_ptr&&) = default; - - - - - - - - template, - __conditional_t::value, - is_same<_Ep, _Dp>, - is_convertible<_Ep, _Dp>>>> - - unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept - : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) - { } - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template, is_same<_Dp, default_delete<_Tp>>>> - unique_ptr(auto_ptr<_Up>&& __u) noexcept; -#pragma GCC diagnostic pop - - - - - - - ~unique_ptr() noexcept - { - static_assert(__is_invocable::value, - "unique_ptr's deleter must be invocable with a pointer"); - auto& __ptr = _M_t._M_ptr(); - if (__ptr != nullptr) - get_deleter()(std::move(__ptr)); - __ptr = pointer(); - } - - - - - - - - unique_ptr& operator=(unique_ptr&&) = default; -# 423 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - - typename enable_if< __and_< - __safe_conversion_up<_Up, _Ep>, - is_assignable - >::value, - unique_ptr&>::type - operator=(unique_ptr<_Up, _Ep>&& __u) noexcept - { - reset(__u.release()); - get_deleter() = std::forward<_Ep>(__u.get_deleter()); - return *this; - } - - - - unique_ptr& - operator=(nullptr_t) noexcept - { - reset(); - return *this; - } - - - - - - typename add_lvalue_reference::type - operator*() const noexcept(noexcept(*std::declval())) - { - do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) __builtin_unreachable(); } while (false); - return *get(); - } - - - - pointer - operator->() const noexcept - { - ; - return get(); - } - - - - pointer - get() const noexcept - { return _M_t._M_ptr(); } - - - - deleter_type& - get_deleter() noexcept - { return _M_t._M_deleter(); } - - - - const deleter_type& - get_deleter() const noexcept - { return _M_t._M_deleter(); } - - - - explicit operator bool() const noexcept - { return get() == pointer() ? false : true; } - - - - - - pointer - release() noexcept - { return _M_t.release(); } -# 504 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - void - reset(pointer __p = pointer()) noexcept - { - static_assert(__is_invocable::value, - "unique_ptr's deleter must be invocable with a pointer"); - _M_t.reset(std::move(__p)); - } - - - - void - swap(unique_ptr& __u) noexcept - { - static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); - _M_t.swap(__u._M_t); - } - - - unique_ptr(const unique_ptr&) = delete; - unique_ptr& operator=(const unique_ptr&) = delete; - }; -# 534 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - class unique_ptr<_Tp[], _Dp> - { - template - using _DeleterConstraint = - typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type; - - __uniq_ptr_data<_Tp, _Dp> _M_t; - - - template - using __is_derived_Tp - = __and_< is_base_of<_Tp, _Up>, - __not_, __remove_cv_t<_Up>>> >; - - public: - using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer; - using element_type = _Tp; - using deleter_type = _Dp; - - - - template, - typename _UP_pointer = typename _UPtr::pointer, - typename _UP_element_type = typename _UPtr::element_type> - using __safe_conversion_up = __and_< - is_array<_Up>, - is_same, - is_same<_UP_pointer, _UP_element_type*>, - is_convertible<_UP_element_type(*)[], element_type(*)[]> - >; - - - template - using __safe_conversion_raw = __and_< - __or_<__or_, - is_same<_Up, nullptr_t>>, - __and_, - is_same, - is_convertible< - typename remove_pointer<_Up>::type(*)[], - element_type(*)[]> - > - > - >; - - - - - template> - constexpr unique_ptr() noexcept - : _M_t() - { } -# 596 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template, - typename = typename enable_if< - __safe_conversion_raw<_Up>::value, bool>::type> - - explicit - unique_ptr(_Up __p) noexcept - : _M_t(__p) - { } -# 615 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template, - is_copy_constructible<_Del>>> - - unique_ptr(_Up __p, const deleter_type& __d) noexcept - : _M_t(__p, __d) { } -# 630 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template, - is_move_constructible<_Del>>> - - unique_ptr(_Up __p, - __enable_if_t::value, - _Del&&> __d) noexcept - : _M_t(std::move(__p), std::move(__d)) - { } - - template::type, - typename = _Require<__safe_conversion_raw<_Up>>> - unique_ptr(_Up, - __enable_if_t::value, - _DelUnref&&>) = delete; - - - unique_ptr(unique_ptr&&) = default; - - - template> - constexpr unique_ptr(nullptr_t) noexcept - : _M_t() - { } - - template, - __conditional_t::value, - is_same<_Ep, _Dp>, - is_convertible<_Ep, _Dp>>>> - - unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept - : _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter())) - { } - - - - - - ~unique_ptr() - { - auto& __ptr = _M_t._M_ptr(); - if (__ptr != nullptr) - get_deleter()(__ptr); - __ptr = pointer(); - } - - - - - - - - unique_ptr& - operator=(unique_ptr&&) = default; -# 694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - - typename - enable_if<__and_<__safe_conversion_up<_Up, _Ep>, - is_assignable - >::value, - unique_ptr&>::type - operator=(unique_ptr<_Up, _Ep>&& __u) noexcept - { - reset(__u.release()); - get_deleter() = std::forward<_Ep>(__u.get_deleter()); - return *this; - } - - - - unique_ptr& - operator=(nullptr_t) noexcept - { - reset(); - return *this; - } - - - - - - typename std::add_lvalue_reference::type - operator[](size_t __i) const - { - do { if (std::__is_constant_evaluated() && !bool(get() != pointer())) __builtin_unreachable(); } while (false); - return get()[__i]; - } - - - - pointer - get() const noexcept - { return _M_t._M_ptr(); } - - - - deleter_type& - get_deleter() noexcept - { return _M_t._M_deleter(); } - - - - const deleter_type& - get_deleter() const noexcept - { return _M_t._M_deleter(); } - - - - explicit operator bool() const noexcept - { return get() == pointer() ? false : true; } - - - - - - pointer - release() noexcept - { return _M_t.release(); } - - - - - - - - template , - __and_, - is_pointer<_Up>, - is_convertible< - typename remove_pointer<_Up>::type(*)[], - element_type(*)[] - > - > - > - >> - - void - reset(_Up __p) noexcept - { _M_t.reset(std::move(__p)); } - - - void reset(nullptr_t = nullptr) noexcept - { reset(pointer()); } - - - - void - swap(unique_ptr& __u) noexcept - { - static_assert(__is_swappable<_Dp>::value, "deleter must be swappable"); - _M_t.swap(__u._M_t); - } - - - unique_ptr(const unique_ptr&) = delete; - unique_ptr& operator=(const unique_ptr&) = delete; - }; - - - - - - template - inline - - - - typename enable_if<__is_swappable<_Dp>::value>::type - - - - swap(unique_ptr<_Tp, _Dp>& __x, - unique_ptr<_Tp, _Dp>& __y) noexcept - { __x.swap(__y); } - - - template - typename enable_if::value>::type - swap(unique_ptr<_Tp, _Dp>&, - unique_ptr<_Tp, _Dp>&) = delete; - - - - template - [[__nodiscard__]] - inline bool - operator==(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return __x.get() == __y.get(); } - - - template - [[__nodiscard__]] - inline bool - operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept - { return !__x; } - - - - template - [[__nodiscard__]] - inline bool - operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept - { return !__x; } - - - template - [[__nodiscard__]] - inline bool - operator!=(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return __x.get() != __y.get(); } - - - template - [[__nodiscard__]] - inline bool - operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept - { return (bool)__x; } - - - template - [[__nodiscard__]] - inline bool - operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept - { return (bool)__x; } - - - - template - [[__nodiscard__]] - inline bool - operator<(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { - typedef typename - std::common_type::pointer, - typename unique_ptr<_Up, _Ep>::pointer>::type _CT; - return std::less<_CT>()(__x.get(), __y.get()); - } - - - template - [[__nodiscard__]] - inline bool - operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) - { - return std::less::pointer>()(__x.get(), - nullptr); - } - - - template - [[__nodiscard__]] - inline bool - operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) - { - return std::less::pointer>()(nullptr, - __x.get()); - } - - - template - [[__nodiscard__]] - inline bool - operator<=(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return !(__y < __x); } - - - template - [[__nodiscard__]] - inline bool - operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) - { return !(nullptr < __x); } - - - template - [[__nodiscard__]] - inline bool - operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) - { return !(__x < nullptr); } - - - template - [[__nodiscard__]] - inline bool - operator>(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return (__y < __x); } - - - template - [[__nodiscard__]] - inline bool - operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) - { - return std::less::pointer>()(nullptr, - __x.get()); - } - - - template - [[__nodiscard__]] - inline bool - operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) - { - return std::less::pointer>()(__x.get(), - nullptr); - } - - - template - [[__nodiscard__]] - inline bool - operator>=(const unique_ptr<_Tp, _Dp>& __x, - const unique_ptr<_Up, _Ep>& __y) - { return !(__x < __y); } - - - template - [[__nodiscard__]] - inline bool - operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) - { return !(__x < nullptr); } - - - template - [[__nodiscard__]] inline bool - operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) - { return !(nullptr < __x); } -# 1006 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template::__enable_hash_call> - struct __uniq_ptr_hash - - : private __poison_hash<_Ptr> - - { - size_t - operator()(const _Up& __u) const - noexcept(noexcept(std::declval>()(std::declval<_Ptr>()))) - { return hash<_Ptr>()(__u.get()); } - }; - - template - struct __uniq_ptr_hash<_Up, _Ptr, false> - : private __poison_hash<_Ptr> - { }; - - - - template - struct hash> - : public __hash_base>, - public __uniq_ptr_hash> - { }; - - - - - -namespace __detail -{ - template - struct _MakeUniq - { typedef unique_ptr<_Tp> __single_object; }; - - template - struct _MakeUniq<_Tp[]> - { typedef unique_ptr<_Tp[]> __array; }; - - template - struct _MakeUniq<_Tp[_Bound]> - { struct __invalid_type { }; }; - - template - using __unique_ptr_t = typename _MakeUniq<_Tp>::__single_object; - template - using __unique_ptr_array_t = typename _MakeUniq<_Tp>::__array; - template - using __invalid_make_unique_t = typename _MakeUniq<_Tp>::__invalid_type; -} -# 1066 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - - inline __detail::__unique_ptr_t<_Tp> - make_unique(_Args&&... __args) - { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); } -# 1081 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - template - - inline __detail::__unique_ptr_array_t<_Tp> - make_unique(size_t __num) - { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); } - - - - - - - template - __detail::__invalid_make_unique_t<_Tp> - make_unique(_Args&&...) = delete; -# 1154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unique_ptr.h" 3 - namespace __detail::__variant - { - template struct _Never_valueless_alt; - - - - template - struct _Never_valueless_alt> - : std::true_type - { }; - } - - - -} -# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 1 3 -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 - template - struct char_traits; - - template<> struct char_traits; - - template<> struct char_traits; - - - - - - - template<> struct char_traits; - template<> struct char_traits; - - -namespace __cxx11 { - - template, - typename _Alloc = allocator<_CharT> > - class basic_string; - -} - - - typedef basic_string string; - - - typedef basic_string wstring; -# 89 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 - typedef basic_string u16string; - - - typedef basic_string u32string; - - - - - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 - - - - -# 1 "/usr/include/wchar.h" 1 3 4 -# 27 "/usr/include/wchar.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/include/bits/floatn.h" 1 3 4 -# 119 "/usr/include/bits/floatn.h" 3 4 -# 1 "/usr/include/bits/floatn-common.h" 1 3 4 -# 24 "/usr/include/bits/floatn-common.h" 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 25 "/usr/include/bits/floatn-common.h" 2 3 4 -# 214 "/usr/include/bits/floatn-common.h" 3 4 -typedef float _Float32; -# 251 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float64; -# 268 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float32x; -# 285 "/usr/include/bits/floatn-common.h" 3 4 -typedef long double _Float64x; -# 120 "/usr/include/bits/floatn.h" 2 3 4 -# 31 "/usr/include/wchar.h" 2 3 4 - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 -typedef long unsigned int size_t; -# 36 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 -# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 -typedef __builtin_va_list __gnuc_va_list; -# 39 "/usr/include/wchar.h" 2 3 4 - - - - -typedef __gnuc_va_list va_list; -# 52 "/usr/include/wchar.h" 3 4 -# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 -# 20 "/usr/include/bits/types/wint_t.h" 3 4 -typedef unsigned int wint_t; -# 53 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 - - - -# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 -# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 -typedef struct -{ - int __count; - union - { - unsigned int __wch; - char __wchb[4]; - } __value; -} __mbstate_t; -# 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4 - -typedef __mbstate_t mbstate_t; -# 54 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 - - - -struct _IO_FILE; -typedef struct _IO_FILE __FILE; -# 55 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/include/bits/types/FILE.h" 1 3 4 - - - -struct _IO_FILE; - - -typedef struct _IO_FILE FILE; -# 58 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 -# 22 "/usr/include/bits/types/locale_t.h" 3 4 -# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 -# 27 "/usr/include/bits/types/__locale_t.h" 3 4 -struct __locale_struct -{ - - struct __locale_data *__locales[13]; - - - const unsigned short int *__ctype_b; - const int *__ctype_tolower; - const int *__ctype_toupper; - - - const char *__names[13]; -}; - -typedef struct __locale_struct *__locale_t; -# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 - -typedef __locale_t locale_t; -# 61 "/usr/include/wchar.h" 2 3 4 -# 90 "/usr/include/wchar.h" 3 4 -extern "C" { - - - -struct tm; - - - -extern wchar_t *wcscpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern wchar_t *wcsncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern size_t wcslcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern size_t wcslcat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern wchar_t *wcscat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern wchar_t *wcsncat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - -extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - -extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, - size_t __n) noexcept (true); - - - -extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - -extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - - - -extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - - -extern size_t wcsxfrm (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - - - - - -extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - - - - -extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - -extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) - __attribute__ ((__malloc__)) ; -# 189 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); -# 199 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - -extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) - noexcept (true) __attribute__ ((__pure__)); - - -extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 226 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 237 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - -extern wchar_t *wcstok (wchar_t *__restrict __s, - const wchar_t *__restrict __delim, - wchar_t **__restrict __ptr) noexcept (true); - - -extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); -# 258 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) - noexcept (true) __attribute__ ((__pure__)); -# 278 "/usr/include/wchar.h" 3 4 -extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - - -extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - -extern wchar_t *wmemcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - -extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true); - - -extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); - - - - -extern wchar_t *wmempcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) - noexcept (true); - - - - - -extern wint_t btowc (int __c) noexcept (true); - - - -extern int wctob (wint_t __c) noexcept (true); - - - -extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); - - - -extern size_t mbrtowc (wchar_t *__restrict __pwc, - const char *__restrict __s, size_t __n, - mbstate_t *__restrict __p) noexcept (true); - - -extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, - mbstate_t *__restrict __ps) noexcept (true); - - -extern size_t __mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); -extern size_t mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - - -extern wint_t __btowc_alias (int __c) __asm ("btowc"); -extern __inline __attribute__ ((__gnu_inline__)) wint_t - btowc (int __c) noexcept (true) -{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' - ? (wint_t) __c : __btowc_alias (__c)); } - -extern int __wctob_alias (wint_t __c) __asm ("wctob"); -extern __inline __attribute__ ((__gnu_inline__)) int - wctob (wint_t __wc) noexcept (true) -{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' - ? (int) __wc : __wctob_alias (__wc)); } - -extern __inline __attribute__ ((__gnu_inline__)) size_t - mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) - -{ return (__ps != __null - ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } - - - - -extern size_t mbsrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - -extern size_t mbsnrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __nmc, - size_t __len, mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsnrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, - size_t __nwc, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - -extern int wcwidth (wchar_t __c) noexcept (true); - - - -extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); - - - - - -extern double wcstod (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern float wcstof (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -extern long double wcstold (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 422 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 437 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 455 "/usr/include/wchar.h" 3 4 -extern long int wcstol (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) noexcept (true); - - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - - -extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); -# 561 "/usr/include/wchar.h" 3 4 -extern long int wcstol_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base, - locale_t __loc) noexcept (true); - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true); - - - - - -extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); - - - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); - - - - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); - - - - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); -# 630 "/usr/include/wchar.h" 3 4 -extern double wcstod_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern float wcstof_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern long double wcstold_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 649 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 667 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 689 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcpcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) noexcept (true); - - - -extern wchar_t *wcpncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true); -# 718 "/usr/include/wchar.h" 3 4 -extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern int fwide (__FILE *__fp, int __mode) noexcept (true); - - - - - - -extern int fwprintf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wprintf (const wchar_t *__restrict __format, ...) - ; - -extern int swprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, ...) - noexcept (true) ; - - - - - -extern int vfwprintf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwprintf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - -extern int vswprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; - - - - - - -extern int fwscanf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wscanf (const wchar_t *__restrict __format, ...) - ; - -extern int swscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, ...) - noexcept (true) ; -# 795 "/usr/include/wchar.h" 3 4 -extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") - - - ; -extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") - - ; -extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") - - - ; -# 851 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwscanf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - -extern int vswscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; -# 875 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") - - - ; -extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") - - ; -extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") - - - ; -# 935 "/usr/include/wchar.h" 3 4 -extern wint_t fgetwc (__FILE *__stream); -extern wint_t getwc (__FILE *__stream); - - - - - -extern wint_t getwchar (void); - - - - - - -extern wint_t fputwc (wchar_t __wc, __FILE *__stream); -extern wint_t putwc (wchar_t __wc, __FILE *__stream); - - - - - -extern wint_t putwchar (wchar_t __wc); - - - - - - - -extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - -extern int fputws (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern wint_t ungetwc (wint_t __wc, __FILE *__stream); -# 990 "/usr/include/wchar.h" 3 4 -extern wint_t getwc_unlocked (__FILE *__stream); -extern wint_t getwchar_unlocked (void); - - - - - - - -extern wint_t fgetwc_unlocked (__FILE *__stream); - - - - - - - -extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); -# 1016 "/usr/include/wchar.h" 3 4 -extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); -extern wint_t putwchar_unlocked (wchar_t __wc); -# 1026 "/usr/include/wchar.h" 3 4 -extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - - - -extern int fputws_unlocked (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp) noexcept (true); - - - - -extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp, - locale_t __loc) noexcept (true); -# 1073 "/usr/include/wchar.h" 3 4 -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 2 3 -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -namespace std -{ - using ::mbstate_t; -} -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::wint_t; - - using ::btowc; - using ::fgetwc; - using ::fgetws; - using ::fputwc; - using ::fputws; - using ::fwide; - using ::fwprintf; - using ::fwscanf; - using ::getwc; - using ::getwchar; - using ::mbrlen; - using ::mbrtowc; - using ::mbsinit; - using ::mbsrtowcs; - using ::putwc; - using ::putwchar; - - using ::swprintf; - - using ::swscanf; - using ::ungetwc; - using ::vfwprintf; - - using ::vfwscanf; - - - using ::vswprintf; - - - using ::vswscanf; - - using ::vwprintf; - - using ::vwscanf; - - using ::wcrtomb; - using ::wcscat; - using ::wcscmp; - using ::wcscoll; - using ::wcscpy; - using ::wcscspn; - using ::wcsftime; - using ::wcslen; - using ::wcsncat; - using ::wcsncmp; - using ::wcsncpy; - using ::wcsrtombs; - using ::wcsspn; - using ::wcstod; - - using ::wcstof; - - using ::wcstok; - using ::wcstol; - using ::wcstoul; - using ::wcsxfrm; - using ::wctob; - using ::wmemcmp; - using ::wmemcpy; - using ::wmemmove; - using ::wmemset; - using ::wprintf; - using ::wscanf; - using ::wcschr; - using ::wcspbrk; - using ::wcsrchr; - using ::wcsstr; - using ::wmemchr; - - - inline wchar_t* - wcschr(wchar_t* __p, wchar_t __c) - { return wcschr(const_cast(__p), __c); } - - inline wchar_t* - wcspbrk(wchar_t* __s1, const wchar_t* __s2) - { return wcspbrk(const_cast(__s1), __s2); } - - inline wchar_t* - wcsrchr(wchar_t* __p, wchar_t __c) - { return wcsrchr(const_cast(__p), __c); } - - inline wchar_t* - wcsstr(wchar_t* __s1, const wchar_t* __s2) - { return wcsstr(const_cast(__s1), __s2); } - - inline wchar_t* - wmemchr(wchar_t* __p, wchar_t __c, size_t __n) - { return wmemchr(const_cast(__p), __c, __n); } - - - -} -} - - - - - - - -namespace __gnu_cxx -{ - - - - - - using ::wcstold; -# 260 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 - using ::wcstoll; - using ::wcstoull; - -} - -namespace std -{ - using ::__gnu_cxx::wcstold; - using ::__gnu_cxx::wcstoll; - using ::__gnu_cxx::wcstoull; -} -# 280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -namespace std -{ - - using std::wcstof; - - - using std::vfwscanf; - - - using std::vswscanf; - - - using std::vwscanf; - - - - using std::wcstold; - using std::wcstoll; - using std::wcstoull; - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - typedef long int streamoff; - - - - - - typedef ptrdiff_t streamsize; -# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - template - class fpos - { - private: - streamoff _M_off; - _StateT _M_state; - - public: - - - - - fpos() - : _M_off(0), _M_state() { } -# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - fpos(streamoff __off) - : _M_off(__off), _M_state() { } - - - fpos(const fpos&) = default; - fpos& operator=(const fpos&) = default; - ~fpos() = default; - - - - operator streamoff() const { return _M_off; } - - - void - state(_StateT __st) - { _M_state = __st; } - - - _StateT - state() const - { return _M_state; } - - - - - - fpos& - operator+=(streamoff __off) - { - _M_off += __off; - return *this; - } - - - - - - fpos& - operator-=(streamoff __off) - { - _M_off -= __off; - return *this; - } - - - - - - - - fpos - operator+(streamoff __off) const - { - fpos __pos(*this); - __pos += __off; - return __pos; - } - - - - - - - - fpos - operator-(streamoff __off) const - { - fpos __pos(*this); - __pos -= __off; - return __pos; - } - - - - - - - streamoff - operator-(const fpos& __other) const - { return _M_off - __other._M_off; } - }; - - - - - - - template - inline bool - operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) - { return streamoff(__lhs) == streamoff(__rhs); } - - template - inline bool - operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) - { return streamoff(__lhs) != streamoff(__rhs); } - - - - - - typedef fpos streampos; - - typedef fpos wstreampos; -# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - typedef fpos u16streampos; - - typedef fpos u32streampos; - - - -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 76 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 - class ios_base; - - template > - class basic_ios; - - template > - class basic_streambuf; - - template > - class basic_istream; - - template > - class basic_ostream; - - template > - class basic_iostream; - - -namespace __cxx11 { - - template, - typename _Alloc = allocator<_CharT> > - class basic_stringbuf; - - template, - typename _Alloc = allocator<_CharT> > - class basic_istringstream; - - template, - typename _Alloc = allocator<_CharT> > - class basic_ostringstream; - - template, - typename _Alloc = allocator<_CharT> > - class basic_stringstream; - -} - - template > - class basic_filebuf; - - template > - class basic_ifstream; - - template > - class basic_ofstream; - - template > - class basic_fstream; - - template > - class istreambuf_iterator; - - template > - class ostreambuf_iterator; - - - - typedef basic_ios ios; - - - typedef basic_streambuf streambuf; - - - typedef basic_istream istream; - - - typedef basic_ostream ostream; - - - typedef basic_iostream iostream; - - - typedef basic_stringbuf stringbuf; - - - typedef basic_istringstream istringstream; - - - typedef basic_ostringstream ostringstream; - - - typedef basic_stringstream stringstream; - - - typedef basic_filebuf filebuf; - - - typedef basic_ifstream ifstream; - - - typedef basic_ofstream ofstream; - - - typedef basic_fstream fstream; - - - - typedef basic_ios wios; - - - typedef basic_streambuf wstreambuf; - - - typedef basic_istream wistream; - - - typedef basic_ostream wostream; - - - typedef basic_iostream wiostream; - - - typedef basic_stringbuf wstringbuf; - - - typedef basic_istringstream wistringstream; - - - typedef basic_ostringstream wostringstream; - - - typedef basic_stringstream wstringstream; - - - typedef basic_filebuf wfilebuf; - - - typedef basic_ifstream wifstream; - - - typedef basic_ofstream wofstream; - - - typedef basic_fstream wfstream; -# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 -} -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 1 3 -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - - - - - - -#pragma GCC visibility push(default) - - - - - -extern "C++" { - -namespace __cxxabiv1 -{ - class __class_type_info; -} -# 84 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 -namespace std -{ - - - - - - - class type_info - { - public: - - - - - virtual ~type_info(); - - - - const char* name() const noexcept - { return __name[0] == '*' ? __name + 1 : __name; } - - - - bool before(const type_info& __arg) const noexcept; - - - bool operator==(const type_info& __arg) const noexcept; - - - 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&) = delete; - type_info(const type_info&) = delete; -# 167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - }; - - - inline bool - type_info::before(const type_info& __arg) const noexcept - { - - - - - if (__name[0] != '*' || __arg.__name[0] != '*') - return __builtin_strcmp (__name, __arg.__name) < 0; -# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - return __name < __arg.__name; - } - - - - inline bool - type_info::operator==(const type_info& __arg) const noexcept - { - if (std::__is_constant_evaluated()) - return this == &__arg; - - if (__name == __arg.__name) - return true; - - - - - - - return __name[0] != '*' && __builtin_strcmp (__name, __arg.name()) == 0; - - - - } -# 220 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - class bad_cast : public exception - { - public: - bad_cast() noexcept { } - - - - virtual ~bad_cast() noexcept; - - - virtual const char* what() const noexcept; - }; - - - - - - class bad_typeid : public exception - { - public: - bad_typeid () noexcept { } - - - - virtual ~bad_typeid() noexcept; - - - virtual const char* what() const noexcept; - }; -} - -} - -#pragma GCC visibility pop -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocated_ptr.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocated_ptr.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template - struct __allocated_ptr - { - using pointer = typename allocator_traits<_Alloc>::pointer; - using value_type = typename allocator_traits<_Alloc>::value_type; - - - __allocated_ptr(_Alloc& __a, pointer __ptr) noexcept - : _M_alloc(std::__addressof(__a)), _M_ptr(__ptr) - { } - - - template>> - __allocated_ptr(_Alloc& __a, _Ptr __ptr) - : _M_alloc(std::__addressof(__a)), - _M_ptr(pointer_traits::pointer_to(*__ptr)) - { } - - - __allocated_ptr(__allocated_ptr&& __gd) noexcept - : _M_alloc(__gd._M_alloc), _M_ptr(__gd._M_ptr) - { __gd._M_ptr = nullptr; } - - - ~__allocated_ptr() - { - if (_M_ptr != nullptr) - std::allocator_traits<_Alloc>::deallocate(*_M_alloc, _M_ptr, 1); - } - - - __allocated_ptr& - operator=(std::nullptr_t) noexcept - { - _M_ptr = nullptr; - return *this; - } - - - value_type* get() { return std::__to_address(_M_ptr); } - - private: - _Alloc* _M_alloc; - pointer _M_ptr; - }; - - - template - __allocated_ptr<_Alloc> - __allocate_guarded(_Alloc& __a) - { - return { __a, std::allocator_traits<_Alloc>::allocate(__a, 1) }; - } - - - -} -# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 - template - struct _Maybe_unary_or_binary_function { }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct _Maybe_unary_or_binary_function<_Res, _T1> - : std::unary_function<_T1, _Res> { }; - - - template - struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> - : std::binary_function<_T1, _T2, _Res> { }; - -#pragma GCC diagnostic pop - - template - struct _Mem_fn_traits; - - template - struct _Mem_fn_traits_base - { - using __result_type = _Res; - using __maybe_type - = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; - using __arity = integral_constant; - }; -# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; - - -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; - - - - - - - template> - struct _Maybe_get_result_type - { }; - - template - struct _Maybe_get_result_type<_Functor, - __void_t> - { typedef typename _Functor::result_type result_type; }; - - - - - - template - struct _Weak_result_type_impl - : _Maybe_get_result_type<_Functor> - { }; - - - template - struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct - _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)> - { typedef _Res result_type; }; - - - template::value> - struct _Weak_result_type_memfun - : _Weak_result_type_impl<_Functor> - { }; - - - template - struct _Weak_result_type_memfun<_MemFunPtr, true> - { - using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; - }; - - - template - struct _Weak_result_type_memfun<_Func _Class::*, false> - { }; - - - - - - template - struct _Weak_result_type - : _Weak_result_type_memfun::type> - { }; - - - - template> - struct _Refwrap_base_arg1 - { }; - - - template - struct _Refwrap_base_arg1<_Tp, - __void_t> - { - typedef typename _Tp::argument_type argument_type; - }; - - - template> - struct _Refwrap_base_arg2 - { }; - - - template - struct _Refwrap_base_arg2<_Tp, - __void_t> - { - typedef typename _Tp::first_argument_type first_argument_type; - typedef typename _Tp::second_argument_type second_argument_type; - }; - - - - - - - - template - struct _Reference_wrapper_base - : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> - { }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) volatile> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const volatile> - : unary_function<_T1, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> - : binary_function<_T1, _T2, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)> - : unary_function<_T1, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)> - : binary_function<_T1, _T2, _Res> - { }; - - template::value> - struct _Reference_wrapper_base_memfun - : _Reference_wrapper_base<_Tp> - { }; - - template - struct _Reference_wrapper_base_memfun<_MemFunPtr, true> - : _Mem_fn_traits<_MemFunPtr>::__maybe_type - { - using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; - }; -#pragma GCC diagnostic pop - - - - - - - - - template - class reference_wrapper - - - - : public _Reference_wrapper_base_memfun::type> - - { - _Tp* _M_data; - - - static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } - - static void _S_fun(_Tp&&) = delete; - - template> - using __not_same - = typename enable_if::value>::type; - - public: - typedef _Tp type; - - - - - template, typename - = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> - - reference_wrapper(_Up&& __uref) - noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) - : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) - { } - - reference_wrapper(const reference_wrapper&) = default; - - reference_wrapper& - operator=(const reference_wrapper&) = default; - - - operator _Tp&() const noexcept - { return this->get(); } - - - _Tp& - get() const noexcept - { return *_M_data; } - - template - - typename __invoke_result<_Tp&, _Args...>::type - operator()(_Args&&... __args) const - noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value) - { - - - - - return std::__invoke(get(), std::forward<_Args>(__args)...); - } - }; - - - template - reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; - - - - - - template - - inline reference_wrapper<_Tp> - ref(_Tp& __t) noexcept - { return reference_wrapper<_Tp>(__t); } - - - template - - inline reference_wrapper - cref(const _Tp& __t) noexcept - { return reference_wrapper(__t); } - - template - void ref(const _Tp&&) = delete; - - template - void cref(const _Tp&&) = delete; - - - template - - inline reference_wrapper<_Tp> - ref(reference_wrapper<_Tp> __t) noexcept - { return __t; } - - - template - - inline reference_wrapper - cref(reference_wrapper<_Tp> __t) noexcept - { return { __t.get() }; } - - - - -} -# 58 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/aligned_buffer.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/aligned_buffer.h" 3 - - - - - - - -namespace __gnu_cxx -{ - - - - - template - struct __aligned_membuf - { - - - - - - struct _Tp2 { _Tp _M_t; }; - - alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)]; - - __aligned_membuf() = default; - - - __aligned_membuf(std::nullptr_t) { } - - void* - _M_addr() noexcept - { return static_cast(&_M_storage); } - - const void* - _M_addr() const noexcept - { return static_cast(&_M_storage); } - - _Tp* - _M_ptr() noexcept - { return static_cast<_Tp*>(_M_addr()); } - - const _Tp* - _M_ptr() const noexcept - { return static_cast(_M_addr()); } - }; - - - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - - - - template - struct __aligned_buffer - : std::aligned_storage - { - typename - std::aligned_storage::type _M_storage; - - __aligned_buffer() = default; - - - __aligned_buffer(std::nullptr_t) { } - - void* - _M_addr() noexcept - { - return static_cast(&_M_storage); - } - - const void* - _M_addr() const noexcept - { - return static_cast(&_M_storage); - } - - _Tp* - _M_ptr() noexcept - { return static_cast<_Tp*>(_M_addr()); } - - const _Tp* - _M_ptr() const noexcept - { return static_cast(_M_addr()); } - }; -#pragma GCC diagnostic pop - - -} -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 1 3 -# 30 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 -#pragma GCC visibility push(default) -# 148 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -# 1 "/usr/include/pthread.h" 1 3 4 -# 22 "/usr/include/pthread.h" 3 4 -# 1 "/usr/include/sched.h" 1 3 4 -# 29 "/usr/include/sched.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 30 "/usr/include/sched.h" 2 3 4 - -# 1 "/usr/include/bits/types/time_t.h" 1 3 4 -# 10 "/usr/include/bits/types/time_t.h" 3 4 -typedef __time_t time_t; -# 32 "/usr/include/sched.h" 2 3 4 -# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 - - - - - -# 1 "/usr/include/bits/endian.h" 1 3 4 -# 35 "/usr/include/bits/endian.h" 3 4 -# 1 "/usr/include/bits/endianness.h" 1 3 4 -# 36 "/usr/include/bits/endian.h" 2 3 4 -# 7 "/usr/include/bits/types/struct_timespec.h" 2 3 4 - - - - -struct timespec -{ - - - - __time_t tv_sec; - - - - - __syscall_slong_t tv_nsec; -# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 -}; -# 33 "/usr/include/sched.h" 2 3 4 - - - - - -typedef __pid_t pid_t; - - - - -# 1 "/usr/include/bits/sched.h" 1 3 4 -# 80 "/usr/include/bits/sched.h" 3 4 -# 1 "/usr/include/bits/types/struct_sched_param.h" 1 3 4 -# 23 "/usr/include/bits/types/struct_sched_param.h" 3 4 -struct sched_param -{ - int sched_priority; -}; -# 81 "/usr/include/bits/sched.h" 2 3 4 - -extern "C" { - - - -extern int clone (int (*__fn) (void *__arg), void *__child_stack, - int __flags, void *__arg, ...) noexcept (true); - - -extern int unshare (int __flags) noexcept (true); - - -extern int sched_getcpu (void) noexcept (true); - - -extern int getcpu (unsigned int *, unsigned int *) noexcept (true); - - -extern int setns (int __fd, int __nstype) noexcept (true); - - -} -# 44 "/usr/include/sched.h" 2 3 4 -# 1 "/usr/include/bits/cpu-set.h" 1 3 4 -# 32 "/usr/include/bits/cpu-set.h" 3 4 -typedef unsigned long int __cpu_mask; - - - - - - -typedef struct -{ - __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; -} cpu_set_t; -# 115 "/usr/include/bits/cpu-set.h" 3 4 -extern "C" { - -extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) - noexcept (true); -extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) ; -extern void __sched_cpufree (cpu_set_t *__set) noexcept (true); - -} -# 45 "/usr/include/sched.h" 2 3 4 - - - - - - -extern "C" { - - -extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) - noexcept (true); - - -extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true); - - -extern int sched_setscheduler (__pid_t __pid, int __policy, - const struct sched_param *__param) noexcept (true); - - -extern int sched_getscheduler (__pid_t __pid) noexcept (true); - - -extern int sched_yield (void) noexcept (true); - - -extern int sched_get_priority_max (int __algorithm) noexcept (true); - - -extern int sched_get_priority_min (int __algorithm) noexcept (true); - - - -extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true); -# 130 "/usr/include/sched.h" 3 4 -extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, - const cpu_set_t *__cpuset) noexcept (true); - - -extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, - cpu_set_t *__cpuset) noexcept (true); - - -} -# 23 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/time.h" 1 3 4 -# 29 "/usr/include/time.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 30 "/usr/include/time.h" 2 3 4 - - - -# 1 "/usr/include/bits/time.h" 1 3 4 -# 73 "/usr/include/bits/time.h" 3 4 -# 1 "/usr/include/bits/timex.h" 1 3 4 -# 22 "/usr/include/bits/timex.h" 3 4 -# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 - - - - - - - -struct timeval -{ - - - - - __time_t tv_sec; - __suseconds_t tv_usec; - -}; -# 23 "/usr/include/bits/timex.h" 2 3 4 - - - -struct timex -{ -# 58 "/usr/include/bits/timex.h" 3 4 - unsigned int modes; - __syscall_slong_t offset; - __syscall_slong_t freq; - __syscall_slong_t maxerror; - __syscall_slong_t esterror; - int status; - __syscall_slong_t constant; - __syscall_slong_t precision; - __syscall_slong_t tolerance; - struct timeval time; - __syscall_slong_t tick; - __syscall_slong_t ppsfreq; - __syscall_slong_t jitter; - int shift; - __syscall_slong_t stabil; - __syscall_slong_t jitcnt; - __syscall_slong_t calcnt; - __syscall_slong_t errcnt; - __syscall_slong_t stbcnt; - - int tai; - - - int :32; int :32; int :32; int :32; - int :32; int :32; int :32; int :32; - int :32; int :32; int :32; - -}; -# 74 "/usr/include/bits/time.h" 2 3 4 - -extern "C" { - - -extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); -# 90 "/usr/include/bits/time.h" 3 4 -} -# 34 "/usr/include/time.h" 2 3 4 - - - -# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 - - - - - - -typedef __clock_t clock_t; -# 38 "/usr/include/time.h" 2 3 4 - -# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 - - - - - - -struct tm -{ - int tm_sec; - int tm_min; - int tm_hour; - int tm_mday; - int tm_mon; - int tm_year; - int tm_wday; - int tm_yday; - int tm_isdst; - - - long int tm_gmtoff; - const char *tm_zone; - - - - -}; -# 40 "/usr/include/time.h" 2 3 4 - - - - - - -# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 - - - - - - -typedef __clockid_t clockid_t; -# 47 "/usr/include/time.h" 2 3 4 -# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 - - - - - - -typedef __timer_t timer_t; -# 48 "/usr/include/time.h" 2 3 4 -# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 - - - - - - - -struct itimerspec - { - struct timespec it_interval; - struct timespec it_value; - }; -# 49 "/usr/include/time.h" 2 3 4 -struct sigevent; -# 68 "/usr/include/time.h" 3 4 -extern "C" { - - - -extern clock_t clock (void) noexcept (true); - - - -extern time_t time (time_t *__timer) noexcept (true); - - -extern double difftime (time_t __time1, time_t __time0) - noexcept (true) __attribute__ ((__const__)); - - -extern time_t mktime (struct tm *__tp) noexcept (true); -# 100 "/usr/include/time.h" 3 4 -extern size_t strftime (char *__restrict __s, size_t __maxsize, - const char *__restrict __format, - const struct tm *__restrict __tp) - noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); - - - - -extern char *strptime (const char *__restrict __s, - const char *__restrict __fmt, struct tm *__tp) - noexcept (true); - - - - - - -extern size_t strftime_l (char *__restrict __s, size_t __maxsize, - const char *__restrict __format, - const struct tm *__restrict __tp, - locale_t __loc) noexcept (true); - - - -extern char *strptime_l (const char *__restrict __s, - const char *__restrict __fmt, struct tm *__tp, - locale_t __loc) noexcept (true); - - - - - - -extern struct tm *gmtime (const time_t *__timer) noexcept (true); - - - -extern struct tm *localtime (const time_t *__timer) noexcept (true); -# 155 "/usr/include/time.h" 3 4 -extern struct tm *gmtime_r (const time_t *__restrict __timer, - struct tm *__restrict __tp) noexcept (true); - - - -extern struct tm *localtime_r (const time_t *__restrict __timer, - struct tm *__restrict __tp) noexcept (true); -# 180 "/usr/include/time.h" 3 4 -extern char *asctime (const struct tm *__tp) noexcept (true); - - - -extern char *ctime (const time_t *__timer) noexcept (true); -# 198 "/usr/include/time.h" 3 4 -extern char *asctime_r (const struct tm *__restrict __tp, - char *__restrict __buf) noexcept (true); - - - -extern char *ctime_r (const time_t *__restrict __timer, - char *__restrict __buf) noexcept (true); -# 218 "/usr/include/time.h" 3 4 -extern char *__tzname[2]; -extern int __daylight; -extern long int __timezone; - - - - -extern char *tzname[2]; - - - -extern void tzset (void) noexcept (true); - - - -extern int daylight; -extern long int timezone; -# 247 "/usr/include/time.h" 3 4 -extern time_t timegm (struct tm *__tp) noexcept (true); -# 264 "/usr/include/time.h" 3 4 -extern time_t timelocal (struct tm *__tp) noexcept (true); - - - - - - - -extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); -# 282 "/usr/include/time.h" 3 4 -extern int nanosleep (const struct timespec *__requested_time, - struct timespec *__remaining); - - -extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); - - -extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - -extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) - noexcept (true) __attribute__ ((__nonnull__ (2))); -# 324 "/usr/include/time.h" 3 4 -extern int clock_nanosleep (clockid_t __clock_id, int __flags, - const struct timespec *__req, - struct timespec *__rem); -# 339 "/usr/include/time.h" 3 4 -extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); - - - - -extern int timer_create (clockid_t __clock_id, - struct sigevent *__restrict __evp, - timer_t *__restrict __timerid) noexcept (true); - - -extern int timer_delete (timer_t __timerid) noexcept (true); - - - -extern int timer_settime (timer_t __timerid, int __flags, - const struct itimerspec *__restrict __value, - struct itimerspec *__restrict __ovalue) noexcept (true); - - -extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) - noexcept (true); -# 377 "/usr/include/time.h" 3 4 -extern int timer_getoverrun (timer_t __timerid) noexcept (true); - - - - - - -extern int timespec_get (struct timespec *__ts, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 400 "/usr/include/time.h" 3 4 -extern int timespec_getres (struct timespec *__ts, int __base) - noexcept (true); -# 426 "/usr/include/time.h" 3 4 -extern int getdate_err; -# 435 "/usr/include/time.h" 3 4 -extern struct tm *getdate (const char *__string); -# 449 "/usr/include/time.h" 3 4 -extern int getdate_r (const char *__restrict __string, - struct tm *__restrict __resbufp); - - -} -# 24 "/usr/include/pthread.h" 2 3 4 - - -# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 -# 23 "/usr/include/bits/pthreadtypes.h" 3 4 -# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 -# 44 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 -# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 -# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 - -# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 -# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 -typedef union -{ - __extension__ unsigned long long int __value64; - struct - { - unsigned int __low; - unsigned int __high; - } __value32; -} __atomic_wide_counter; -# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -typedef struct __pthread_internal_list -{ - struct __pthread_internal_list *__prev; - struct __pthread_internal_list *__next; -} __pthread_list_t; - -typedef struct __pthread_internal_slist -{ - struct __pthread_internal_slist *__next; -} __pthread_slist_t; -# 76 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 -# 22 "/usr/include/bits/struct_mutex.h" 3 4 -struct __pthread_mutex_s -{ - int __lock; - unsigned int __count; - int __owner; - - unsigned int __nusers; - - - - int __kind; - - short __spins; - short __elision; - __pthread_list_t __list; -# 53 "/usr/include/bits/struct_mutex.h" 3 4 -}; -# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 -# 89 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 -# 23 "/usr/include/bits/struct_rwlock.h" 3 4 -struct __pthread_rwlock_arch_t -{ - unsigned int __readers; - unsigned int __writers; - unsigned int __wrphase_futex; - unsigned int __writers_futex; - unsigned int __pad3; - unsigned int __pad4; - - int __cur_writer; - int __shared; - signed char __rwelision; - - - - - unsigned char __pad1[7]; - - - unsigned long int __pad2; - - - unsigned int __flags; -# 55 "/usr/include/bits/struct_rwlock.h" 3 4 -}; -# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -struct __pthread_cond_s -{ - __atomic_wide_counter __wseq; - __atomic_wide_counter __g1_start; - unsigned int __g_refs[2] ; - unsigned int __g_size[2]; - unsigned int __g1_orig_size; - unsigned int __wrefs; - unsigned int __g_signals[2]; -}; - -typedef unsigned int __tss_t; -typedef unsigned long int __thrd_t; - -typedef struct -{ - int __data ; -} __once_flag; -# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 - - - -typedef unsigned long int pthread_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_mutexattr_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_condattr_t; - - - -typedef unsigned int pthread_key_t; - - - -typedef int pthread_once_t; - - -union pthread_attr_t -{ - char __size[56]; - long int __align; -}; - -typedef union pthread_attr_t pthread_attr_t; - - - - -typedef union -{ - struct __pthread_mutex_s __data; - char __size[40]; - long int __align; -} pthread_mutex_t; - - -typedef union -{ - struct __pthread_cond_s __data; - char __size[48]; - __extension__ long long int __align; -} pthread_cond_t; - - - - - -typedef union -{ - struct __pthread_rwlock_arch_t __data; - char __size[56]; - long int __align; -} pthread_rwlock_t; - -typedef union -{ - char __size[8]; - long int __align; -} pthread_rwlockattr_t; - - - - - -typedef volatile int pthread_spinlock_t; - - - - -typedef union -{ - char __size[32]; - long int __align; -} pthread_barrier_t; - -typedef union -{ - char __size[4]; - int __align; -} pthread_barrierattr_t; -# 27 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/bits/setjmp.h" 1 3 4 -# 26 "/usr/include/bits/setjmp.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 27 "/usr/include/bits/setjmp.h" 2 3 4 - - - - -typedef long int __jmp_buf[8]; -# 28 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 29 "/usr/include/pthread.h" 2 3 4 - -# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 - - - - -typedef struct -{ - unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; -} __sigset_t; -# 31 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/bits/types/struct___jmp_buf_tag.h" 1 3 4 -# 26 "/usr/include/bits/types/struct___jmp_buf_tag.h" 3 4 -struct __jmp_buf_tag - { - - - - - __jmp_buf __jmpbuf; - int __mask_was_saved; - __sigset_t __saved_mask; - }; -# 32 "/usr/include/pthread.h" 2 3 4 - -# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 -# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 -extern "C" { -extern long int __sysconf (int __name) noexcept (true); -} -# 34 "/usr/include/pthread.h" 2 3 4 - - - -enum -{ - PTHREAD_CREATE_JOINABLE, - - PTHREAD_CREATE_DETACHED - -}; - - - -enum -{ - PTHREAD_MUTEX_TIMED_NP, - PTHREAD_MUTEX_RECURSIVE_NP, - PTHREAD_MUTEX_ERRORCHECK_NP, - PTHREAD_MUTEX_ADAPTIVE_NP - - , - PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, - PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, - PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, - PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL - - - - , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP - -}; - - - - -enum -{ - PTHREAD_MUTEX_STALLED, - PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, - PTHREAD_MUTEX_ROBUST, - PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST -}; - - - - - -enum -{ - PTHREAD_PRIO_NONE, - PTHREAD_PRIO_INHERIT, - PTHREAD_PRIO_PROTECT -}; -# 104 "/usr/include/pthread.h" 3 4 -enum -{ - PTHREAD_RWLOCK_PREFER_READER_NP, - PTHREAD_RWLOCK_PREFER_WRITER_NP, - PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, - PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP -}; -# 124 "/usr/include/pthread.h" 3 4 -enum -{ - PTHREAD_INHERIT_SCHED, - - PTHREAD_EXPLICIT_SCHED - -}; - - - -enum -{ - PTHREAD_SCOPE_SYSTEM, - - PTHREAD_SCOPE_PROCESS - -}; - - - -enum -{ - PTHREAD_PROCESS_PRIVATE, - - PTHREAD_PROCESS_SHARED - -}; -# 159 "/usr/include/pthread.h" 3 4 -struct _pthread_cleanup_buffer -{ - void (*__routine) (void *); - void *__arg; - int __canceltype; - struct _pthread_cleanup_buffer *__prev; -}; - - -enum -{ - PTHREAD_CANCEL_ENABLE, - - PTHREAD_CANCEL_DISABLE - -}; -enum -{ - PTHREAD_CANCEL_DEFERRED, - - PTHREAD_CANCEL_ASYNCHRONOUS - -}; -# 197 "/usr/include/pthread.h" 3 4 -extern "C" { - - - - -extern int pthread_create (pthread_t *__restrict __newthread, - const pthread_attr_t *__restrict __attr, - void *(*__start_routine) (void *), - void *__restrict __arg) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - - - -extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); - - - - - - - -extern int pthread_join (pthread_t __th, void **__thread_return); - - - - -extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) noexcept (true); -# 233 "/usr/include/pthread.h" 3 4 -extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, - const struct timespec *__abstime); -# 243 "/usr/include/pthread.h" 3 4 -extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return, - clockid_t __clockid, - const struct timespec *__abstime); -# 269 "/usr/include/pthread.h" 3 4 -extern int pthread_detach (pthread_t __th) noexcept (true); - - - -extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__)); - - -extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) - noexcept (true) __attribute__ ((__const__)); - - - - - - - -extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_destroy (pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, - int *__detachstate) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, - int __detachstate) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, - size_t *__guardsize) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setguardsize (pthread_attr_t *__attr, - size_t __guardsize) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, - struct sched_param *__restrict __param) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, - const struct sched_param *__restrict - __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict - __attr, int *__restrict __policy) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict - __attr, int *__restrict __inherit) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, - int __inherit) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, - int *__restrict __scope) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict - __attr, void **__restrict __stackaddr) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); - - - - - -extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, - void *__stackaddr) - noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); - - -extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict - __attr, size_t *__restrict __stacksize) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern int pthread_attr_setstacksize (pthread_attr_t *__attr, - size_t __stacksize) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, - void **__restrict __stackaddr, - size_t *__restrict __stacksize) - noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))); - - - - -extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, - size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, - size_t __cpusetsize, - const cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, - size_t __cpusetsize, - cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - -extern int pthread_getattr_default_np (pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr, - const __sigset_t *sigmask); - - - - -extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr, - __sigset_t *sigmask); - - - - - - - -extern int pthread_setattr_default_np (const pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - - - - -extern int pthread_setschedparam (pthread_t __target_thread, int __policy, - const struct sched_param *__param) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - -extern int pthread_getschedparam (pthread_t __target_thread, - int *__restrict __policy, - struct sched_param *__restrict __param) - noexcept (true) __attribute__ ((__nonnull__ (2, 3))); - - -extern int pthread_setschedprio (pthread_t __target_thread, int __prio) - noexcept (true); - - - - -extern int pthread_getname_np (pthread_t __target_thread, char *__buf, - size_t __buflen) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - -extern int pthread_setname_np (pthread_t __target_thread, const char *__name) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - - -extern int pthread_getconcurrency (void) noexcept (true); - - -extern int pthread_setconcurrency (int __level) noexcept (true); - - - -extern int pthread_yield (void) noexcept (true); - -extern int pthread_yield (void) noexcept (true) __asm__ ("" "sched_yield") - __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead"))); -# 489 "/usr/include/pthread.h" 3 4 -extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, - const cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - -extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, - cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 509 "/usr/include/pthread.h" 3 4 -extern int pthread_once (pthread_once_t *__once_control, - void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); -# 521 "/usr/include/pthread.h" 3 4 -extern int pthread_setcancelstate (int __state, int *__oldstate); - - - -extern int pthread_setcanceltype (int __type, int *__oldtype); - - -extern int pthread_cancel (pthread_t __th); - - - - -extern void pthread_testcancel (void); - - - - -struct __cancel_jmp_buf_tag -{ - __jmp_buf __cancel_jmp_buf; - int __mask_was_saved; -}; - -typedef struct -{ - struct __cancel_jmp_buf_tag __cancel_jmp_buf[1]; - void *__pad[4]; -} __pthread_unwind_buf_t __attribute__ ((__aligned__)); -# 557 "/usr/include/pthread.h" 3 4 -struct __pthread_cleanup_frame -{ - void (*__cancel_routine) (void *); - void *__cancel_arg; - int __do_it; - int __cancel_type; -}; - - - - -class __pthread_cleanup_class -{ - void (*__cancel_routine) (void *); - void *__cancel_arg; - int __do_it; - int __cancel_type; - - public: - __pthread_cleanup_class (void (*__fct) (void *), void *__arg) - : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } - ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } - void __setdoit (int __newval) { __do_it = __newval; } - void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, - &__cancel_type); } - void __restore () const { pthread_setcanceltype (__cancel_type, 0); } -}; -# 773 "/usr/include/pthread.h" 3 4 -extern int __sigsetjmp (struct __jmp_buf_tag __env[1], - int __savemask) noexcept (true); - - - - - - -extern int pthread_mutex_init (pthread_mutex_t *__mutex, - const pthread_mutexattr_t *__mutexattr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_lock (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -# 817 "/usr/include/pthread.h" 3 4 -extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex, - clockid_t __clockid, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 835 "/usr/include/pthread.h" 3 4 -extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutex_getprioceiling (const pthread_mutex_t * - __restrict __mutex, - int *__restrict __prioceiling) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, - int __prioceiling, - int *__restrict __old_ceiling) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - - -extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_consistent_np (pthread_mutex_t *) noexcept (true) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nonnull__ (1))) - - __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent"))); -# 874 "/usr/include/pthread.h" 3 4 -extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, - int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict - __attr, int *__restrict __kind) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __protocol) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, - int __protocol) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __prioceiling) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, - int __prioceiling) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, - int *__robustness) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) noexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nonnull__ (1))) - - - __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust"))); - - - - - - - -extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, - int __robustness) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) noexcept (true) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nonnull__ (1))) - - - __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust"))); -# 967 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, - const pthread_rwlockattr_t *__restrict - __attr) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -# 1004 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock, - clockid_t __clockid, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 1023 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -# 1051 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock, - clockid_t __clockid, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 1071 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, - int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * - __restrict __attr, - int *__restrict __pref) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, - int __pref) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - - -extern int pthread_cond_init (pthread_cond_t *__restrict __cond, - const pthread_condattr_t *__restrict __cond_attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_cond_destroy (pthread_cond_t *__cond) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_cond_signal (pthread_cond_t *__cond) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_cond_broadcast (pthread_cond_t *__cond) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex) - __attribute__ ((__nonnull__ (1, 2))); -# 1145 "/usr/include/pthread.h" 3 4 -extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex, - const struct timespec *__restrict __abstime) - __attribute__ ((__nonnull__ (1, 2, 3))); -# 1171 "/usr/include/pthread.h" 3 4 -extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex, - __clockid_t __clock_id, - const struct timespec *__restrict __abstime) - __attribute__ ((__nonnull__ (1, 2, 4))); -# 1194 "/usr/include/pthread.h" 3 4 -extern int pthread_condattr_init (pthread_condattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_condattr_destroy (pthread_condattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_condattr_getpshared (const pthread_condattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, - int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_condattr_getclock (const pthread_condattr_t * - __restrict __attr, - __clockid_t *__restrict __clock_id) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_condattr_setclock (pthread_condattr_t *__attr, - __clockid_t __clock_id) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 1230 "/usr/include/pthread.h" 3 4 -extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_destroy (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_lock (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_trylock (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_unlock (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, - const pthread_barrierattr_t *__restrict - __attr, unsigned int __count) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrier_wait (pthread_barrier_t *__barrier) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, - int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 1297 "/usr/include/pthread.h" 3 4 -extern int pthread_key_create (pthread_key_t *__key, - void (*__destr_function) (void *)) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_key_delete (pthread_key_t __key) noexcept (true); - - -extern void *pthread_getspecific (pthread_key_t __key) noexcept (true); - - -extern int pthread_setspecific (pthread_key_t __key, - const void *__pointer) - noexcept (true) ; - - - - -extern int pthread_getcpuclockid (pthread_t __thread_id, - __clockid_t *__clock_id) - noexcept (true) __attribute__ ((__nonnull__ (2))); -# 1332 "/usr/include/pthread.h" 3 4 -extern int pthread_atfork (void (*__prepare) (void), - void (*__parent) (void), - void (*__child) (void)) noexcept (true); - - - - -extern __inline __attribute__ ((__gnu_inline__)) int - pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true) -{ - return __thread1 == __thread2; -} - - -} -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -typedef pthread_t __gthread_t; -typedef pthread_key_t __gthread_key_t; -typedef pthread_once_t __gthread_once_t; -typedef pthread_mutex_t __gthread_mutex_t; -typedef pthread_mutex_t __gthread_recursive_mutex_t; -typedef pthread_cond_t __gthread_cond_t; -typedef struct timespec __gthread_time_t; -# 299 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_active_p (void) -{ - return 1; -} -# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), - void *__args) -{ - return pthread_create (__threadid, __null, __func, __args); -} - -static inline int -__gthread_join (__gthread_t __threadid, void **__value_ptr) -{ - return pthread_join (__threadid, __value_ptr); -} - -static inline int -__gthread_detach (__gthread_t __threadid) -{ - return pthread_detach (__threadid); -} - -static inline int -__gthread_equal (__gthread_t __t1, __gthread_t __t2) -{ - return pthread_equal (__t1, __t2); -} - -static inline __gthread_t -__gthread_self (void) -{ - return pthread_self (); -} - -static inline int -__gthread_yield (void) -{ - return sched_yield (); -} - -static inline int -__gthread_once (__gthread_once_t *__once, void (*__func) (void)) -{ - if (__gthread_active_p ()) - return pthread_once (__once, __func); - else - return -1; -} - -static inline int -__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) -{ - return pthread_key_create (__key, __dtor); -} - -static inline int -__gthread_key_delete (__gthread_key_t __key) -{ - return pthread_key_delete (__key); -} - -static inline void * -__gthread_getspecific (__gthread_key_t __key) -{ - return pthread_getspecific (__key); -} - -static inline int -__gthread_setspecific (__gthread_key_t __key, const void *__ptr) -{ - return pthread_setspecific (__key, __ptr); -} - -static inline void -__gthread_mutex_init_function (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - pthread_mutex_init (__mutex, __null); -} - -static inline int -__gthread_mutex_destroy (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_destroy (__mutex); - else - return 0; -} - -static inline int -__gthread_mutex_lock (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_lock (__mutex); - else - return 0; -} - -static inline int -__gthread_mutex_trylock (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_trylock (__mutex); - else - return 0; -} - - -static inline int -__gthread_mutex_timedlock (__gthread_mutex_t *__mutex, - const __gthread_time_t *__abs_timeout) -{ - if (__gthread_active_p ()) - return pthread_mutex_timedlock (__mutex, __abs_timeout); - else - return 0; -} - - -static inline int -__gthread_mutex_unlock (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_unlock (__mutex); - else - return 0; -} -# 808 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_lock (__mutex); -} - -static inline int -__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_trylock (__mutex); -} - - -static inline int -__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, - const __gthread_time_t *__abs_timeout) -{ - return __gthread_mutex_timedlock (__mutex, __abs_timeout); -} - - -static inline int -__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_unlock (__mutex); -} - -static inline int -__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_destroy (__mutex); -} -# 850 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_cond_broadcast (__gthread_cond_t *__cond) -{ - return pthread_cond_broadcast (__cond); -} - -static inline int -__gthread_cond_signal (__gthread_cond_t *__cond) -{ - return pthread_cond_signal (__cond); -} - -static inline int -__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) -{ - return pthread_cond_wait (__cond, __mutex); -} - -static inline int -__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, - const __gthread_time_t *__abs_timeout) -{ - return pthread_cond_timedwait (__cond, __mutex, __abs_timeout); -} - -static inline int -__gthread_cond_wait_recursive (__gthread_cond_t *__cond, - __gthread_recursive_mutex_t *__mutex) -{ - return __gthread_cond_wait (__cond, __mutex); -} - -static inline int -__gthread_cond_destroy (__gthread_cond_t* __cond) -{ - return pthread_cond_destroy (__cond); -} -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 2 3 - - -#pragma GCC visibility pop -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3 -# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 3 -typedef int _Atomic_word; -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 - -# 1 "/usr/include/sys/single_threaded.h" 1 3 4 -# 24 "/usr/include/sys/single_threaded.h" 3 4 -extern "C" { - - - - -extern char __libc_single_threaded; - -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - __attribute__((__always_inline__)) - inline bool - __is_single_threaded() noexcept - { - - - - return ::__libc_single_threaded; - - - - } - - - - - - - inline _Atomic_word - __attribute__((__always_inline__)) - __exchange_and_add(volatile _Atomic_word* __mem, int __val) - { return __atomic_fetch_add(__mem, __val, 4); } - - inline void - __attribute__((__always_inline__)) - __atomic_add(volatile _Atomic_word* __mem, int __val) - { __atomic_fetch_add(__mem, __val, 4); } -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 - inline _Atomic_word - __attribute__((__always_inline__)) - __exchange_and_add_single(_Atomic_word* __mem, int __val) - { - _Atomic_word __result = *__mem; - *__mem += __val; - return __result; - } - - inline void - __attribute__((__always_inline__)) - __atomic_add_single(_Atomic_word* __mem, int __val) - { *__mem += __val; } - - inline _Atomic_word - __attribute__ ((__always_inline__)) - __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) - { - if (__is_single_threaded()) - return __exchange_and_add_single(__mem, __val); - else - return __exchange_and_add(__mem, __val); - } - - inline void - __attribute__ ((__always_inline__)) - __atomic_add_dispatch(_Atomic_word* __mem, int __val) - { - if (__is_single_threaded()) - __atomic_add_single(__mem, __val); - else - __atomic_add(__mem, __val); - } - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - - - - -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - class bad_exception : public exception - { - public: - bad_exception() noexcept { } - - - - virtual ~bad_exception() noexcept; - - - virtual const char* - what() const noexcept; - }; - - - typedef void (*terminate_handler) (); - - - terminate_handler set_terminate(terminate_handler) noexcept; - - - - terminate_handler get_terminate() noexcept; - - - - - void terminate() noexcept __attribute__ ((__noreturn__)); - - - - typedef void (*__attribute__ ((__deprecated__)) unexpected_handler) (); - - - - - - __attribute__ ((__deprecated__)) - unexpected_handler set_unexpected(unexpected_handler) noexcept; - - - - - - - - __attribute__ ((__deprecated__)) - unexpected_handler get_unexpected() noexcept; - - - - - - - - __attribute__ ((__deprecated__)) - void unexpected() __attribute__ ((__noreturn__)); -# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - __attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "' instead"))) - bool uncaught_exception() noexcept __attribute__ ((__pure__)); - - - - - - - - int uncaught_exceptions() noexcept __attribute__ ((__pure__)); - - - -} - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - void __verbose_terminate_handler(); - - -} - -} - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 - -#pragma GCC visibility push(default) - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 -# 35 "/usr/lib/clang/16/include/stddef.h" 3 -typedef long int ptrdiff_t; -# 109 "/usr/lib/clang/16/include/stddef.h" 3 -# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 -# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 -typedef struct { - long long __clang_max_align_nonce1 - __attribute__((__aligned__(__alignof__(long long)))); - long double __clang_max_align_nonce2 - __attribute__((__aligned__(__alignof__(long double)))); -} max_align_t; -# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 2 3 -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 -namespace std -{ - class type_info; -} - -namespace __cxxabiv1 -{ - struct __cxa_refcounted_exception; - - extern "C" - { - - void* - __cxa_allocate_exception(size_t) noexcept; - - void - __cxa_free_exception(void*) noexcept; - - - __cxa_refcounted_exception* - __cxa_init_primary_exception(void *__object, std::type_info *__tinfo, - void ( *__dest) (void *)) - noexcept; - - } -} - - - -#pragma GCC visibility pop -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - class type_info; - - - - - - - namespace __exception_ptr - { - class exception_ptr; - } - - using __exception_ptr::exception_ptr; -# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - exception_ptr current_exception() noexcept; - - template - exception_ptr make_exception_ptr(_Ex) noexcept; - - - void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); - - namespace __exception_ptr - { - using std::rethrow_exception; -# 97 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - class exception_ptr - { - void* _M_exception_object; - - explicit exception_ptr(void* __e) noexcept; - - void _M_addref() noexcept; - void _M_release() noexcept; - - void *_M_get() const noexcept __attribute__ ((__pure__)); - - friend exception_ptr std::current_exception() noexcept; - friend void std::rethrow_exception(exception_ptr); - template - friend exception_ptr std::make_exception_ptr(_Ex) noexcept; - - public: - exception_ptr() noexcept; - - exception_ptr(const exception_ptr&) noexcept; - - - exception_ptr(nullptr_t) noexcept - : _M_exception_object(nullptr) - { } - - exception_ptr(exception_ptr&& __o) noexcept - : _M_exception_object(__o._M_exception_object) - { __o._M_exception_object = nullptr; } -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -# 162 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - explicit operator bool() const noexcept - { return _M_exception_object; } - - - - - - - - friend bool - operator==(const exception_ptr& __x, const exception_ptr& __y) - noexcept - { return __x._M_exception_object == __y._M_exception_object; } - - friend bool - operator!=(const exception_ptr& __x, const exception_ptr& __y) - noexcept - { return __x._M_exception_object != __y._M_exception_object; } - - - const class std::type_info* - __cxa_exception_type() const noexcept - __attribute__ ((__pure__)); - }; - - - inline - exception_ptr::exception_ptr() noexcept - : _M_exception_object(0) - { } - - - inline - exception_ptr::exception_ptr(const exception_ptr& __other) - noexcept - : _M_exception_object(__other._M_exception_object) - { - if (_M_exception_object) - _M_addref(); - } - - - inline - exception_ptr::~exception_ptr() noexcept - { - if (_M_exception_object) - _M_release(); - } - - - inline exception_ptr& - exception_ptr::operator=(const exception_ptr& __other) noexcept - { - exception_ptr(__other).swap(*this); - return *this; - } - - - inline void - exception_ptr::swap(exception_ptr &__other) noexcept - { - void *__tmp = _M_exception_object; - _M_exception_object = __other._M_exception_object; - __other._M_exception_object = __tmp; - } - - - inline void - swap(exception_ptr& __lhs, exception_ptr& __rhs) - { __lhs.swap(__rhs); } - - - template - - inline void - __dest_thunk(void* __x) - { static_cast<_Ex*>(__x)->~_Ex(); } - - - } - - using __exception_ptr::swap; - - - - template - exception_ptr - make_exception_ptr(_Ex __ex) noexcept - { - - using _Ex2 = typename decay<_Ex>::type; - void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); - (void) __cxxabiv1::__cxa_init_primary_exception( - __e, const_cast(&typeid(_Ex)), - __exception_ptr::__dest_thunk<_Ex2>); - try - { - ::new (__e) _Ex2(__ex); - return exception_ptr(__e); - } - catch(...) - { - __cxxabiv1::__cxa_free_exception(__e); - return current_exception(); - } -# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - } -# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 -} - -} -# 165 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - class nested_exception - { - exception_ptr _M_ptr; - - public: - - nested_exception() noexcept : _M_ptr(current_exception()) { } - - nested_exception(const nested_exception&) noexcept = 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)) - { } - }; -# 145 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - 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"); - - - if constexpr (is_class_v<_Up>) - if constexpr (!is_final_v<_Up>) - if constexpr (!is_base_of_v) - throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; - throw std::forward<_Tp>(__t); - - - - - - } -# 203 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - template - - - - inline void - rethrow_if_nested(const _Ex& __ex) - { - const _Ex* __ptr = __builtin_addressof(__ex); -# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - if constexpr (!is_polymorphic_v<_Ex>) - return; - else if constexpr (is_base_of_v - && !is_convertible_v<_Ex*, nested_exception*>) - return; - - - - - else if (auto __ne_ptr = dynamic_cast(__ptr)) - __ne_ptr->rethrow_nested(); - - } - - -} - -} -# 166 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 2 3 - - - - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - enum _Lock_policy { _S_single, _S_mutex, _S_atomic }; - - - - inline const _Lock_policy __default_lock_policy = - - - - _S_atomic; - - - - - - - class __concurrence_lock_error : public std::exception - { - public: - virtual char const* - what() const throw() - { return "__gnu_cxx::__concurrence_lock_error"; } - }; - - class __concurrence_unlock_error : public std::exception - { - public: - virtual char const* - what() const throw() - { return "__gnu_cxx::__concurrence_unlock_error"; } - }; - - class __concurrence_broadcast_error : public std::exception - { - public: - virtual char const* - what() const throw() - { return "__gnu_cxx::__concurrence_broadcast_error"; } - }; - - class __concurrence_wait_error : public std::exception - { - public: - virtual char const* - what() const throw() - { return "__gnu_cxx::__concurrence_wait_error"; } - }; - - - inline void - __throw_concurrence_lock_error() - { (throw (__concurrence_lock_error())); } - - inline void - __throw_concurrence_unlock_error() - { (throw (__concurrence_unlock_error())); } - - - inline void - __throw_concurrence_broadcast_error() - { (throw (__concurrence_broadcast_error())); } - - inline void - __throw_concurrence_wait_error() - { (throw (__concurrence_wait_error())); } - - - class __mutex - { - private: - - __gthread_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_TIMED_NP, 0, 0, { 0, 0 } } }; - - - - - __mutex(const __mutex&); - __mutex& operator=(const __mutex&); - - public: - __mutex() - { - - - - - } -# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 - void lock() - { - - if (__gthread_active_p()) - { - if (__gthread_mutex_lock(&_M_mutex) != 0) - __throw_concurrence_lock_error(); - } - - } - - void unlock() - { - - if (__gthread_active_p()) - { - if (__gthread_mutex_unlock(&_M_mutex) != 0) - __throw_concurrence_unlock_error(); - } - - } - - __gthread_mutex_t* gthread_mutex(void) - { return &_M_mutex; } - }; - - class __recursive_mutex - { - private: - - __gthread_recursive_mutex_t _M_mutex = { { 0, 0, 0, 0, PTHREAD_MUTEX_RECURSIVE_NP, 0, 0, { 0, 0 } } }; - - - - - __recursive_mutex(const __recursive_mutex&); - __recursive_mutex& operator=(const __recursive_mutex&); - - public: - __recursive_mutex() - { - - - - - } -# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 - void lock() - { - - if (__gthread_active_p()) - { - if (__gthread_recursive_mutex_lock(&_M_mutex) != 0) - __throw_concurrence_lock_error(); - } - - } - - void unlock() - { - - if (__gthread_active_p()) - { - if (__gthread_recursive_mutex_unlock(&_M_mutex) != 0) - __throw_concurrence_unlock_error(); - } - - } - - __gthread_recursive_mutex_t* gthread_recursive_mutex(void) - { return &_M_mutex; } - }; - - - - - class __scoped_lock - { - public: - typedef __mutex __mutex_type; - - private: - __mutex_type& _M_device; - - __scoped_lock(const __scoped_lock&); - __scoped_lock& operator=(const __scoped_lock&); - - public: - explicit __scoped_lock(__mutex_type& __name) : _M_device(__name) - { _M_device.lock(); } - - ~__scoped_lock() throw() - { _M_device.unlock(); } - }; - - - class __cond - { - private: - - __gthread_cond_t _M_cond = { { {0}, {0}, {0, 0}, {0, 0}, 0, 0, {0, 0} } }; - - - - - __cond(const __cond&); - __cond& operator=(const __cond&); - - public: - __cond() - { - - - - - } -# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/concurrence.h" 3 - void broadcast() - { - - if (__gthread_active_p()) - { - if (__gthread_cond_broadcast(&_M_cond) != 0) - __throw_concurrence_broadcast_error(); - } - - } - - void wait(__mutex *mutex) - { - - { - if (__gthread_cond_wait(&_M_cond, mutex->gthread_mutex()) != 0) - __throw_concurrence_wait_error(); - } - - } - - void wait_recursive(__recursive_mutex *mutex) - { - - { - if (__gthread_cond_wait_recursive(&_M_cond, - mutex->gthread_recursive_mutex()) - != 0) - __throw_concurrence_wait_error(); - } - - } - }; - - - -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 2 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template class auto_ptr; -#pragma GCC diagnostic pop - - - - - - - class bad_weak_ptr : public std::exception - { - public: - virtual char const* what() const noexcept; - - virtual ~bad_weak_ptr() noexcept; - }; - - - inline void - __throw_bad_weak_ptr() - { (throw (bad_weak_ptr())); } - - using __gnu_cxx::_Lock_policy; - using __gnu_cxx::__default_lock_policy; - using __gnu_cxx::_S_single; - using __gnu_cxx::_S_mutex; - using __gnu_cxx::_S_atomic; - - - template<_Lock_policy _Lp> - class _Mutex_base - { - protected: - - enum { _S_need_barriers = 0 }; - }; - - template<> - class _Mutex_base<_S_mutex> - : public __gnu_cxx::__mutex - { - protected: - - - - enum { _S_need_barriers = 1 }; - }; - - template<_Lock_policy _Lp = __default_lock_policy> - class _Sp_counted_base - : public _Mutex_base<_Lp> - { - public: - _Sp_counted_base() noexcept - : _M_use_count(1), _M_weak_count(1) { } - - virtual - ~_Sp_counted_base() noexcept - { } - - - - virtual void - _M_dispose() noexcept = 0; - - - virtual void - _M_destroy() noexcept - { delete this; } - - virtual void* - _M_get_deleter(const std::type_info&) noexcept = 0; - - - void - _M_add_ref_copy() - { __gnu_cxx::__atomic_add_dispatch(&_M_use_count, 1); } - - - void - _M_add_ref_lock() - { - if (!_M_add_ref_lock_nothrow()) - __throw_bad_weak_ptr(); - } - - - bool - _M_add_ref_lock_nothrow() noexcept; - - - void - _M_release() noexcept; - - - void - _M_release_last_use() noexcept - { - ; - _M_dispose(); - - - - - if (_Mutex_base<_Lp>::_S_need_barriers) - { - __atomic_thread_fence (4); - } - - - ; - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, - -1) == 1) - { - ; - _M_destroy(); - } - } - - - __attribute__((__noinline__)) - void - _M_release_last_use_cold() noexcept - { _M_release_last_use(); } - - - void - _M_weak_add_ref() noexcept - { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count, 1); } - - - void - _M_weak_release() noexcept - { - - ; - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1) - { - ; - if (_Mutex_base<_Lp>::_S_need_barriers) - { - - - __atomic_thread_fence (4); - } - _M_destroy(); - } - } - - long - _M_get_use_count() const noexcept - { - - - return __atomic_load_n(&_M_use_count, 0); - } - - private: - _Sp_counted_base(_Sp_counted_base const&) = delete; - _Sp_counted_base& operator=(_Sp_counted_base const&) = delete; - - _Atomic_word _M_use_count; - _Atomic_word _M_weak_count; - }; - - template<> - inline bool - _Sp_counted_base<_S_single>:: - _M_add_ref_lock_nothrow() noexcept - { - if (_M_use_count == 0) - return false; - ++_M_use_count; - return true; - } - - template<> - inline bool - _Sp_counted_base<_S_mutex>:: - _M_add_ref_lock_nothrow() noexcept - { - __gnu_cxx::__scoped_lock sentry(*this); - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1) == 0) - { - _M_use_count = 0; - return false; - } - return true; - } - - template<> - inline bool - _Sp_counted_base<_S_atomic>:: - _M_add_ref_lock_nothrow() noexcept - { - - _Atomic_word __count = _M_get_use_count(); - do - { - if (__count == 0) - return false; - - - } - while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1, - true, 4, - 0)); - return true; - } - - template<> - inline void - _Sp_counted_base<_S_single>::_M_add_ref_copy() - { ++_M_use_count; } - - template<> - inline void - _Sp_counted_base<_S_single>::_M_release() noexcept - { - if (--_M_use_count == 0) - { - _M_dispose(); - if (--_M_weak_count == 0) - _M_destroy(); - } - } - - template<> - inline void - _Sp_counted_base<_S_mutex>::_M_release() noexcept - { - - ; - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) - { - _M_release_last_use(); - } - } - - template<> - inline void - _Sp_counted_base<_S_atomic>::_M_release() noexcept - { - ; - - constexpr bool __lock_free - = __atomic_always_lock_free(sizeof(long long), 0) - && __atomic_always_lock_free(sizeof(_Atomic_word), 0); - constexpr bool __double_word - = sizeof(long long) == 2 * sizeof(_Atomic_word); - - - constexpr bool __aligned = __alignof(long long) <= alignof(void*); - if constexpr (__lock_free && __double_word && __aligned) - { - constexpr int __wordbits = 8 * sizeof(_Atomic_word); - constexpr int __shiftbits = __double_word ? __wordbits : 0; - constexpr long long __unique_ref = 1LL + (1LL << __shiftbits); - auto __both_counts = reinterpret_cast(&_M_use_count); - - ; - if (__atomic_load_n(__both_counts, 2) == __unique_ref) - { - - - - - _M_weak_count = _M_use_count = 0; - ; - ; - _M_dispose(); - _M_destroy(); - return; - } - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) - [[__unlikely__]] - { - _M_release_last_use_cold(); - return; - } - } - else - - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1) - { - _M_release_last_use(); - } - } - - template<> - inline void - _Sp_counted_base<_S_single>::_M_weak_add_ref() noexcept - { ++_M_weak_count; } - - template<> - inline void - _Sp_counted_base<_S_single>::_M_weak_release() noexcept - { - if (--_M_weak_count == 0) - _M_destroy(); - } - - template<> - inline long - _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept - { return _M_use_count; } - - - - template - class __shared_ptr; - - template - class __weak_ptr; - - template - class __enable_shared_from_this; - - template - class shared_ptr; - - template - class weak_ptr; - - template - struct owner_less; - - template - class enable_shared_from_this; - - template<_Lock_policy _Lp = __default_lock_policy> - class __weak_count; - - template<_Lock_policy _Lp = __default_lock_policy> - class __shared_count; - - - - - - - - template - class _Sp_counted_ptr final : public _Sp_counted_base<_Lp> - { - public: - explicit - _Sp_counted_ptr(_Ptr __p) noexcept - : _M_ptr(__p) { } - - virtual void - _M_dispose() noexcept - { delete _M_ptr; } - - virtual void - _M_destroy() noexcept - { delete this; } - - virtual void* - _M_get_deleter(const std::type_info&) noexcept - { return nullptr; } - - _Sp_counted_ptr(const _Sp_counted_ptr&) = delete; - _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; - - private: - _Ptr _M_ptr; - }; - - template<> - inline void - _Sp_counted_ptr::_M_dispose() noexcept { } - - template<> - inline void - _Sp_counted_ptr::_M_dispose() noexcept { } - - template<> - inline void - _Sp_counted_ptr::_M_dispose() noexcept { } - - - - - - - template - struct _Sp_ebo_helper; - - - template - struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp - { - explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { } - explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { } - - static _Tp& - _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); } - }; - - - template - struct _Sp_ebo_helper<_Nm, _Tp, false> - { - explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { } - explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { } - - static _Tp& - _S_get(_Sp_ebo_helper& __eboh) - { return __eboh._M_tp; } - - private: - _Tp _M_tp; - }; - - - template - class _Sp_counted_deleter final : public _Sp_counted_base<_Lp> - { - class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc> - { - typedef _Sp_ebo_helper<0, _Deleter> _Del_base; - typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base; - - public: - _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept - : _Del_base(std::move(__d)), _Alloc_base(__a), _M_ptr(__p) - { } - - _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); } - _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); } - - _Ptr _M_ptr; - }; - - public: - using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>; - - - _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept - : _M_impl(__p, std::move(__d), _Alloc()) { } - - - _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept - : _M_impl(__p, std::move(__d), __a) { } - - ~_Sp_counted_deleter() noexcept { } - - virtual void - _M_dispose() noexcept - { _M_impl._M_del()(_M_impl._M_ptr); } - - virtual void - _M_destroy() noexcept - { - __allocator_type __a(_M_impl._M_alloc()); - __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; - this->~_Sp_counted_deleter(); - } - - virtual void* - _M_get_deleter(const type_info& __ti [[__gnu__::__unused__]]) noexcept - { - - - - return __ti == typeid(_Deleter) - ? std::__addressof(_M_impl._M_del()) - : nullptr; - - - - } - - private: - _Impl _M_impl; - }; - - - - struct _Sp_make_shared_tag - { - private: - template - friend class _Sp_counted_ptr_inplace; - - static const type_info& - _S_ti() noexcept __attribute__ ((__visibility__ ("default"))) - { - alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { }; - return reinterpret_cast(__tag); - } - - static bool _S_eq(const type_info&) noexcept; - }; - - template - struct _Sp_alloc_shared_tag - { - const _Alloc& _M_a; - }; - - template - class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp> - { - class _Impl : _Sp_ebo_helper<0, _Alloc> - { - typedef _Sp_ebo_helper<0, _Alloc> _A_base; - - public: - explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { } - - _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); } - - __gnu_cxx::__aligned_buffer<_Tp> _M_storage; - }; - - public: - using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>; - - - template - _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args) - : _M_impl(__a) - { - - - allocator_traits<_Alloc>::construct(__a, _M_ptr(), - std::forward<_Args>(__args)...); - } - - ~_Sp_counted_ptr_inplace() noexcept { } - - virtual void - _M_dispose() noexcept - { - allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr()); - } - - - virtual void - _M_destroy() noexcept - { - __allocator_type __a(_M_impl._M_alloc()); - __allocated_ptr<__allocator_type> __guard_ptr{ __a, this }; - this->~_Sp_counted_ptr_inplace(); - } - - private: - friend class __shared_count<_Lp>; - - - - virtual void* - _M_get_deleter(const std::type_info& __ti) noexcept override - { - auto __ptr = const_cast::type*>(_M_ptr()); - - - - - if (&__ti == &_Sp_make_shared_tag::_S_ti() - || - - __ti == typeid(_Sp_make_shared_tag) - - - - ) - return __ptr; - return nullptr; - } - - _Tp* _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); } - - _Impl _M_impl; - }; -# 886 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - struct __sp_array_delete - { - template - void operator()(_Yp* __p) const { delete[] __p; } - }; - - template<_Lock_policy _Lp> - class __shared_count - { - - template - struct __not_alloc_shared_tag { using type = void; }; - - template - struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { }; - - - - - - - public: - constexpr __shared_count() noexcept : _M_pi(0) - { } - - template - explicit - __shared_count(_Ptr __p) : _M_pi(0) - { - try - { - _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); - } - catch(...) - { - delete __p; - throw; - } - } - - template - __shared_count(_Ptr __p, false_type) - : __shared_count(__p) - { } - - template - __shared_count(_Ptr __p, true_type) - : __shared_count(__p, __sp_array_delete{}, allocator()) - { } - - template::type> - __shared_count(_Ptr __p, _Deleter __d) - : __shared_count(__p, std::move(__d), allocator()) - { } - - template::type> - __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0) - { - typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; - try - { - typename _Sp_cd_type::__allocator_type __a2(__a); - auto __guard = std::__allocate_guarded(__a2); - _Sp_cd_type* __mem = __guard.get(); - ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a)); - _M_pi = __mem; - __guard = nullptr; - } - catch(...) - { - __d(__p); - throw; - } - } - - template - __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a, - _Args&&... __args) - { - typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type; - typename _Sp_cp_type::__allocator_type __a2(__a._M_a); - auto __guard = std::__allocate_guarded(__a2); - _Sp_cp_type* __mem = __guard.get(); - auto __pi = ::new (__mem) - _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...); - __guard = nullptr; - _M_pi = __pi; - __p = __pi->_M_ptr(); - } -# 1024 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template - explicit - __shared_count(std::auto_ptr<_Tp>&& __r); -#pragma GCC diagnostic pop - - - - template - explicit - __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0) - { - - - if (__r.get() == nullptr) - return; - - using _Ptr = typename unique_ptr<_Tp, _Del>::pointer; - using _Del2 = __conditional_t::value, - reference_wrapper::type>, - _Del>; - using _Sp_cd_type - = _Sp_counted_deleter<_Ptr, _Del2, allocator, _Lp>; - using _Alloc = allocator<_Sp_cd_type>; - using _Alloc_traits = allocator_traits<_Alloc>; - _Alloc __a; - _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1); - - - - _Alloc_traits::construct(__a, __mem, __r.release(), - std::forward<_Del>(__r.get_deleter())); - _M_pi = __mem; - } - - - explicit __shared_count(const __weak_count<_Lp>& __r); - - - explicit - __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept; - - ~__shared_count() noexcept - { - if (_M_pi != nullptr) - _M_pi->_M_release(); - } - - __shared_count(const __shared_count& __r) noexcept - : _M_pi(__r._M_pi) - { - if (_M_pi != nullptr) - _M_pi->_M_add_ref_copy(); - } - - __shared_count& - operator=(const __shared_count& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - if (__tmp != _M_pi) - { - if (__tmp != nullptr) - __tmp->_M_add_ref_copy(); - if (_M_pi != nullptr) - _M_pi->_M_release(); - _M_pi = __tmp; - } - return *this; - } - - void - _M_swap(__shared_count& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - __r._M_pi = _M_pi; - _M_pi = __tmp; - } - - long - _M_get_use_count() const noexcept - { return _M_pi ? _M_pi->_M_get_use_count() : 0; } - - bool - _M_unique() const noexcept - { return this->_M_get_use_count() == 1; } - - void* - _M_get_deleter(const std::type_info& __ti) const noexcept - { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; } - - bool - _M_less(const __shared_count& __rhs) const noexcept - { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } - - bool - _M_less(const __weak_count<_Lp>& __rhs) const noexcept - { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } - - - friend inline bool - operator==(const __shared_count& __a, const __shared_count& __b) noexcept - { return __a._M_pi == __b._M_pi; } - - private: - friend class __weak_count<_Lp>; - - - - - _Sp_counted_base<_Lp>* _M_pi; - }; - - - template<_Lock_policy _Lp> - class __weak_count - { - public: - constexpr __weak_count() noexcept : _M_pi(nullptr) - { } - - __weak_count(const __shared_count<_Lp>& __r) noexcept - : _M_pi(__r._M_pi) - { - if (_M_pi != nullptr) - _M_pi->_M_weak_add_ref(); - } - - __weak_count(const __weak_count& __r) noexcept - : _M_pi(__r._M_pi) - { - if (_M_pi != nullptr) - _M_pi->_M_weak_add_ref(); - } - - __weak_count(__weak_count&& __r) noexcept - : _M_pi(__r._M_pi) - { __r._M_pi = nullptr; } - - ~__weak_count() noexcept - { - if (_M_pi != nullptr) - _M_pi->_M_weak_release(); - } - - __weak_count& - operator=(const __shared_count<_Lp>& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - if (__tmp != nullptr) - __tmp->_M_weak_add_ref(); - if (_M_pi != nullptr) - _M_pi->_M_weak_release(); - _M_pi = __tmp; - return *this; - } - - __weak_count& - operator=(const __weak_count& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - if (__tmp != nullptr) - __tmp->_M_weak_add_ref(); - if (_M_pi != nullptr) - _M_pi->_M_weak_release(); - _M_pi = __tmp; - return *this; - } - - __weak_count& - operator=(__weak_count&& __r) noexcept - { - if (_M_pi != nullptr) - _M_pi->_M_weak_release(); - _M_pi = __r._M_pi; - __r._M_pi = nullptr; - return *this; - } - - void - _M_swap(__weak_count& __r) noexcept - { - _Sp_counted_base<_Lp>* __tmp = __r._M_pi; - __r._M_pi = _M_pi; - _M_pi = __tmp; - } - - long - _M_get_use_count() const noexcept - { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; } - - bool - _M_less(const __weak_count& __rhs) const noexcept - { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } - - bool - _M_less(const __shared_count<_Lp>& __rhs) const noexcept - { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } - - - friend inline bool - operator==(const __weak_count& __a, const __weak_count& __b) noexcept - { return __a._M_pi == __b._M_pi; } - - private: - friend class __shared_count<_Lp>; - - - - - _Sp_counted_base<_Lp>* _M_pi; - }; - - - template<_Lock_policy _Lp> - inline - __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r) - : _M_pi(__r._M_pi) - { - if (_M_pi == nullptr || !_M_pi->_M_add_ref_lock_nothrow()) - __throw_bad_weak_ptr(); - } - - - template<_Lock_policy _Lp> - inline - __shared_count<_Lp>:: - __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept - : _M_pi(__r._M_pi) - { - if (_M_pi && !_M_pi->_M_add_ref_lock_nothrow()) - _M_pi = nullptr; - } - - - - - - template - struct __sp_compatible_with - : false_type - { }; - - template - struct __sp_compatible_with<_Yp*, _Tp*> - : is_convertible<_Yp*, _Tp*>::type - { }; - - template - struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]> - : true_type - { }; - - template - struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]> - : true_type - { }; - - template - struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]> - : true_type - { }; - - template - struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]> - : true_type - { }; - - - template - struct __sp_is_constructible_arrN - : false_type - { }; - - template - struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>> - : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type - { }; - - - template - struct __sp_is_constructible_arr - : false_type - { }; - - template - struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>> - : is_convertible<_Yp(*)[], _Up(*)[]>::type - { }; - - - template - struct __sp_is_constructible; - - - template - struct __sp_is_constructible<_Up[_Nm], _Yp> - : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type - { }; - - - template - struct __sp_is_constructible<_Up[], _Yp> - : __sp_is_constructible_arr<_Up, _Yp>::type - { }; - - - template - struct __sp_is_constructible - : is_convertible<_Yp*, _Tp*>::type - { }; - - - - template::value, bool = is_void<_Tp>::value> - class __shared_ptr_access - { - public: - using element_type = _Tp; - - element_type& - operator*() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(_M_get() != nullptr)) __builtin_unreachable(); } while (false); - return *_M_get(); - } - - element_type* - operator->() const noexcept - { - ; - return _M_get(); - } - - private: - element_type* - _M_get() const noexcept - { return static_cast*>(this)->get(); } - }; - - - template - class __shared_ptr_access<_Tp, _Lp, false, true> - { - public: - using element_type = _Tp; - - element_type* - operator->() const noexcept - { - auto __ptr = static_cast*>(this)->get(); - ; - return __ptr; - } - }; - - - template - class __shared_ptr_access<_Tp, _Lp, true, false> - { - public: - using element_type = typename remove_extent<_Tp>::type; -# 1407 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - element_type& - operator[](ptrdiff_t __i) const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(_M_get() != nullptr)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(!extent<_Tp>::value || __i < extent<_Tp>::value)) __builtin_unreachable(); } while (false); - return _M_get()[__i]; - } - - private: - element_type* - _M_get() const noexcept - { return static_cast*>(this)->get(); } - }; - - template - class __shared_ptr - : public __shared_ptr_access<_Tp, _Lp> - { - public: - using element_type = typename remove_extent<_Tp>::type; - - private: - - template - using _SafeConv - = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type; - - - template - using _Compatible = typename - enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; - - - template - using _Assignable = _Compatible<_Yp, __shared_ptr&>; - - - template::pointer> - using _UniqCompatible = __enable_if_t<__and_< - __sp_compatible_with<_Yp*, _Tp*>, - is_convertible<_Ptr, element_type*>, - is_move_constructible<_Del> - >::value, _Res>; - - - template - using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>; - - public: - - - using weak_type = __weak_ptr<_Tp, _Lp>; - - - constexpr __shared_ptr() noexcept - : _M_ptr(0), _M_refcount() - { } - - template> - explicit - __shared_ptr(_Yp* __p) - : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type()) - { - static_assert( !is_void<_Yp>::value, "incomplete type" ); - static_assert( sizeof(_Yp) > 0, "incomplete type" ); - _M_enable_shared_from_this_with(__p); - } - - template> - __shared_ptr(_Yp* __p, _Deleter __d) - : _M_ptr(__p), _M_refcount(__p, std::move(__d)) - { - static_assert(__is_invocable<_Deleter&, _Yp*&>::value, - "deleter expression d(p) is well-formed"); - _M_enable_shared_from_this_with(__p); - } - - template> - __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) - : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a)) - { - static_assert(__is_invocable<_Deleter&, _Yp*&>::value, - "deleter expression d(p) is well-formed"); - _M_enable_shared_from_this_with(__p); - } - - template - __shared_ptr(nullptr_t __p, _Deleter __d) - : _M_ptr(0), _M_refcount(__p, std::move(__d)) - { } - - template - __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) - : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a)) - { } - - - template - __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r, - element_type* __p) noexcept - : _M_ptr(__p), _M_refcount(__r._M_refcount) - { } - - - template - __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r, - element_type* __p) noexcept - : _M_ptr(__p), _M_refcount() - { - _M_refcount._M_swap(__r._M_refcount); - __r._M_ptr = nullptr; - } - - __shared_ptr(const __shared_ptr&) noexcept = default; - __shared_ptr& operator=(const __shared_ptr&) noexcept = default; - ~__shared_ptr() = default; - - template> - __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) - { } - - __shared_ptr(__shared_ptr&& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount() - { - _M_refcount._M_swap(__r._M_refcount); - __r._M_ptr = nullptr; - } - - template> - __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount() - { - _M_refcount._M_swap(__r._M_refcount); - __r._M_ptr = nullptr; - } - - template> - explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r) - : _M_refcount(__r._M_refcount) - { - - - _M_ptr = __r._M_ptr; - } - - - template> - __shared_ptr(unique_ptr<_Yp, _Del>&& __r) - : _M_ptr(__r.get()), _M_refcount() - { - auto __raw = __to_address(__r.get()); - _M_refcount = __shared_count<_Lp>(std::move(__r)); - _M_enable_shared_from_this_with(__raw); - } -# 1585 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template> - __shared_ptr(auto_ptr<_Yp>&& __r); -#pragma GCC diagnostic pop - - - constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { } - - template - _Assignable<_Yp> - operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept - { - _M_ptr = __r._M_ptr; - _M_refcount = __r._M_refcount; - return *this; - } - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template - _Assignable<_Yp> - operator=(auto_ptr<_Yp>&& __r) - { - __shared_ptr(std::move(__r)).swap(*this); - return *this; - } -#pragma GCC diagnostic pop - - - __shared_ptr& - operator=(__shared_ptr&& __r) noexcept - { - __shared_ptr(std::move(__r)).swap(*this); - return *this; - } - - template - _Assignable<_Yp> - operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept - { - __shared_ptr(std::move(__r)).swap(*this); - return *this; - } - - template - _UniqAssignable<_Yp, _Del> - operator=(unique_ptr<_Yp, _Del>&& __r) - { - __shared_ptr(std::move(__r)).swap(*this); - return *this; - } - - void - reset() noexcept - { __shared_ptr().swap(*this); } - - template - _SafeConv<_Yp> - reset(_Yp* __p) - { - - do { if (std::__is_constant_evaluated() && !bool(__p == nullptr || __p != _M_ptr)) __builtin_unreachable(); } while (false); - __shared_ptr(__p).swap(*this); - } - - template - _SafeConv<_Yp> - reset(_Yp* __p, _Deleter __d) - { __shared_ptr(__p, std::move(__d)).swap(*this); } - - template - _SafeConv<_Yp> - reset(_Yp* __p, _Deleter __d, _Alloc __a) - { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); } - - - element_type* - get() const noexcept - { return _M_ptr; } - - - explicit operator bool() const noexcept - { return _M_ptr != nullptr; } - - - bool - unique() const noexcept - { return _M_refcount._M_unique(); } - - - long - use_count() const noexcept - { return _M_refcount._M_get_use_count(); } - - - void - swap(__shared_ptr<_Tp, _Lp>& __other) noexcept - { - std::swap(_M_ptr, __other._M_ptr); - _M_refcount._M_swap(__other._M_refcount); - } -# 1697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - template - bool - owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept - { return _M_refcount._M_less(__rhs._M_refcount); } - - template - bool - owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept - { return _M_refcount._M_less(__rhs._M_refcount); } - - - protected: - - template - __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) - : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...) - { _M_enable_shared_from_this_with(_M_ptr); } - - template - friend __shared_ptr<_Tp1, _Lp1> - __allocate_shared(const _Alloc& __a, _Args&&... __args); -# 1731 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexcept - : _M_refcount(__r._M_refcount, std::nothrow) - { - _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr; - } - - friend class __weak_ptr<_Tp, _Lp>; - - private: - - template - using __esft_base_t = decltype(__enable_shared_from_this_base( - std::declval&>(), - std::declval<_Yp*>())); - - - template - struct __has_esft_base - : false_type { }; - - template - struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>> - : __not_> { }; - - template::type> - typename enable_if<__has_esft_base<_Yp2>::value>::type - _M_enable_shared_from_this_with(_Yp* __p) noexcept - { - if (auto __base = __enable_shared_from_this_base(_M_refcount, __p)) - __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount); - } - - template::type> - typename enable_if::value>::type - _M_enable_shared_from_this_with(_Yp*) noexcept - { } - - void* - _M_get_deleter(const std::type_info& __ti) const noexcept - { return _M_refcount._M_get_deleter(__ti); } - - template friend class __shared_ptr; - template friend class __weak_ptr; - - template - friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept; - - template - friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept; - - - - - - element_type* _M_ptr; - __shared_count<_Lp> _M_refcount; - }; - - - - template - inline bool - operator==(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return __a.get() == __b.get(); } - - template - inline bool - operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return !__a; } -# 1817 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - template - inline bool - operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return !__a; } - - template - inline bool - operator!=(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return __a.get() != __b.get(); } - - template - inline bool - operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return (bool)__a; } - - template - inline bool - operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return (bool)__a; } - - template - inline bool - operator<(const __shared_ptr<_Tp, _Lp>& __a, - const __shared_ptr<_Up, _Lp>& __b) noexcept - { - using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; - using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type; - using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; - return less<_Vp>()(__a.get(), __b.get()); - } - - template - inline bool - operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { - using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; - return less<_Tp_elt*>()(__a.get(), nullptr); - } - - template - inline bool - operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { - using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type; - return less<_Tp_elt*>()(nullptr, __a.get()); - } - - template - inline bool - operator<=(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return !(__b < __a); } - - template - inline bool - operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return !(nullptr < __a); } - - template - inline bool - operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return !(__a < nullptr); } - - template - inline bool - operator>(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return (__b < __a); } - - template - inline bool - operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return nullptr < __a; } - - template - inline bool - operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return __a < nullptr; } - - template - inline bool - operator>=(const __shared_ptr<_Tp1, _Lp>& __a, - const __shared_ptr<_Tp2, _Lp>& __b) noexcept - { return !(__a < __b); } - - template - inline bool - operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept - { return !(__a < nullptr); } - - template - inline bool - operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept - { return !(nullptr < __a); } - - - - template - inline void - swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept - { __a.swap(__b); } -# 1927 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - template - inline __shared_ptr<_Tp, _Lp> - static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - using _Sp = __shared_ptr<_Tp, _Lp>; - return _Sp(__r, static_cast(__r.get())); - } - - - - - - - template - inline __shared_ptr<_Tp, _Lp> - const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - using _Sp = __shared_ptr<_Tp, _Lp>; - return _Sp(__r, const_cast(__r.get())); - } - - - - - - - template - inline __shared_ptr<_Tp, _Lp> - dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - using _Sp = __shared_ptr<_Tp, _Lp>; - if (auto* __p = dynamic_cast(__r.get())) - return _Sp(__r, __p); - return _Sp(); - } - - - template - inline __shared_ptr<_Tp, _Lp> - reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept - { - using _Sp = __shared_ptr<_Tp, _Lp>; - return _Sp(__r, reinterpret_cast(__r.get())); - } - - - template - class __weak_ptr - { - template - using _Compatible = typename - enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type; - - - template - using _Assignable = _Compatible<_Yp, __weak_ptr&>; - - public: - using element_type = typename remove_extent<_Tp>::type; - - constexpr __weak_ptr() noexcept - : _M_ptr(nullptr), _M_refcount() - { } - - __weak_ptr(const __weak_ptr&) noexcept = default; - - ~__weak_ptr() = default; -# 2009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_base.h" 3 - template> - __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept - : _M_refcount(__r._M_refcount) - { _M_ptr = __r.lock().get(); } - - template> - __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) - { } - - __weak_ptr(__weak_ptr&& __r) noexcept - : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount)) - { __r._M_ptr = nullptr; } - - template> - __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept - : _M_ptr(__r.lock().get()), _M_refcount(std::move(__r._M_refcount)) - { __r._M_ptr = nullptr; } - - __weak_ptr& - operator=(const __weak_ptr& __r) noexcept = default; - - template - _Assignable<_Yp> - operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept - { - _M_ptr = __r.lock().get(); - _M_refcount = __r._M_refcount; - return *this; - } - - template - _Assignable<_Yp> - operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept - { - _M_ptr = __r._M_ptr; - _M_refcount = __r._M_refcount; - return *this; - } - - __weak_ptr& - operator=(__weak_ptr&& __r) noexcept - { - __weak_ptr(std::move(__r)).swap(*this); - return *this; - } - - template - _Assignable<_Yp> - operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept - { - _M_ptr = __r.lock().get(); - _M_refcount = std::move(__r._M_refcount); - __r._M_ptr = nullptr; - return *this; - } - - __shared_ptr<_Tp, _Lp> - lock() const noexcept - { return __shared_ptr(*this, std::nothrow); } - - long - use_count() const noexcept - { return _M_refcount._M_get_use_count(); } - - bool - expired() const noexcept - { return _M_refcount._M_get_use_count() == 0; } - - template - bool - owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept - { return _M_refcount._M_less(__rhs._M_refcount); } - - template - bool - owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept - { return _M_refcount._M_less(__rhs._M_refcount); } - - void - reset() noexcept - { __weak_ptr().swap(*this); } - - void - swap(__weak_ptr& __s) noexcept - { - std::swap(_M_ptr, __s._M_ptr); - _M_refcount._M_swap(__s._M_refcount); - } - - private: - - void - _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept - { - if (use_count() == 0) - { - _M_ptr = __ptr; - _M_refcount = __refcount; - } - } - - template friend class __shared_ptr; - template friend class __weak_ptr; - friend class __enable_shared_from_this<_Tp, _Lp>; - friend class enable_shared_from_this<_Tp>; - - - - - element_type* _M_ptr; - __weak_count<_Lp> _M_refcount; - }; - - - template - inline void - swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept - { __a.swap(__b); } - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template - struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> - { - bool - operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept - { return __lhs.owner_before(__rhs); } - - bool - operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept - { return __lhs.owner_before(__rhs); } - - bool - operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept - { return __lhs.owner_before(__rhs); } - }; -#pragma GCC diagnostic pop - - template<> - struct _Sp_owner_less - { - template - auto - operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept - -> decltype(__lhs.owner_before(__rhs)) - { return __lhs.owner_before(__rhs); } - - using is_transparent = void; - }; - - template - struct owner_less<__shared_ptr<_Tp, _Lp>> - : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>> - { }; - - template - struct owner_less<__weak_ptr<_Tp, _Lp>> - : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>> - { }; - - - template - class __enable_shared_from_this - { - protected: - constexpr __enable_shared_from_this() noexcept { } - - __enable_shared_from_this(const __enable_shared_from_this&) noexcept { } - - __enable_shared_from_this& - operator=(const __enable_shared_from_this&) noexcept - { return *this; } - - ~__enable_shared_from_this() { } - - public: - __shared_ptr<_Tp, _Lp> - shared_from_this() - { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } - - __shared_ptr - shared_from_this() const - { return __shared_ptr(this->_M_weak_this); } - - - __weak_ptr<_Tp, _Lp> - weak_from_this() noexcept - { return this->_M_weak_this; } - - __weak_ptr - weak_from_this() const noexcept - { return this->_M_weak_this; } - - - private: - template - void - _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept - { _M_weak_this._M_assign(__p, __n); } - - friend const __enable_shared_from_this* - __enable_shared_from_this_base(const __shared_count<_Lp>&, - const __enable_shared_from_this* __p) - { return __p; } - - template - friend class __shared_ptr; - - mutable __weak_ptr<_Tp, _Lp> _M_weak_this; - }; - - template - inline __shared_ptr<_Tp, _Lp> - __allocate_shared(const _Alloc& __a, _Args&&... __args) - { - static_assert(!is_array<_Tp>::value, "make_shared not supported"); - - return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a}, - std::forward<_Args>(__args)...); - } - - template - inline __shared_ptr<_Tp, _Lp> - __make_shared(_Args&&... __args) - { - typedef typename std::remove_const<_Tp>::type _Tp_nc; - return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(), - std::forward<_Args>(__args)...); - } - - - template - struct hash<__shared_ptr<_Tp, _Lp>> - : public __hash_base> - { - size_t - operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept - { - return hash::element_type*>()( - __s.get()); - } - }; - - -} -# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - inline std::basic_ostream<_Ch, _Tr>& - operator<<(std::basic_ostream<_Ch, _Tr>& __os, - const __shared_ptr<_Tp, _Lp>& __p) - { - __os << __p.get(); - return __os; - } - - template - inline _Del* - get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept - { - - return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); - - - - } - - - - - - template - inline _Del* - get_deleter(const shared_ptr<_Tp>& __p) noexcept - { - - return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); - - - - } -# 111 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - using _NonArray = __enable_if_t::value, _Tp>; -# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - class shared_ptr : public __shared_ptr<_Tp> - { - template - using _Constructible = typename enable_if< - is_constructible<__shared_ptr<_Tp>, _Args...>::value - >::type; - - template - using _Assignable = typename enable_if< - is_assignable<__shared_ptr<_Tp>&, _Arg>::value, shared_ptr& - >::type; - - public: - - - using element_type = typename __shared_ptr<_Tp>::element_type; - - - - - - using weak_type = weak_ptr<_Tp>; - - - - - - constexpr shared_ptr() noexcept : __shared_ptr<_Tp>() { } - - shared_ptr(const shared_ptr&) noexcept = default; - - - - - - - - template> - explicit - shared_ptr(_Yp* __p) : __shared_ptr<_Tp>(__p) { } -# 229 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template> - shared_ptr(_Yp* __p, _Deleter __d) - : __shared_ptr<_Tp>(__p, std::move(__d)) { } -# 247 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - shared_ptr(nullptr_t __p, _Deleter __d) - : __shared_ptr<_Tp>(__p, std::move(__d)) { } -# 266 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template> - shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a) - : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } -# 286 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a) - : __shared_ptr<_Tp>(__p, std::move(__d), std::move(__a)) { } -# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) noexcept - : __shared_ptr<_Tp>(__r, __p) { } -# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template&>> - shared_ptr(const shared_ptr<_Yp>& __r) noexcept - : __shared_ptr<_Tp>(__r) { } - - - - - - - shared_ptr(shared_ptr&& __r) noexcept - : __shared_ptr<_Tp>(std::move(__r)) { } - - - - - - - template>> - shared_ptr(shared_ptr<_Yp>&& __r) noexcept - : __shared_ptr<_Tp>(std::move(__r)) { } -# 379 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template&>> - explicit shared_ptr(const weak_ptr<_Yp>& __r) - : __shared_ptr<_Tp>(__r) { } - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template>> - shared_ptr(auto_ptr<_Yp>&& __r); -#pragma GCC diagnostic pop - - - - - template>> - shared_ptr(unique_ptr<_Yp, _Del>&& __r) - : __shared_ptr<_Tp>(std::move(__r)) { } -# 412 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - constexpr shared_ptr(nullptr_t) noexcept : shared_ptr() { } - - shared_ptr& operator=(const shared_ptr&) noexcept = default; - - template - _Assignable&> - operator=(const shared_ptr<_Yp>& __r) noexcept - { - this->__shared_ptr<_Tp>::operator=(__r); - return *this; - } - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - template - _Assignable> - operator=(auto_ptr<_Yp>&& __r) - { - this->__shared_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } -#pragma GCC diagnostic pop - - - shared_ptr& - operator=(shared_ptr&& __r) noexcept - { - this->__shared_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } - - template - _Assignable> - operator=(shared_ptr<_Yp>&& __r) noexcept - { - this->__shared_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } - - template - _Assignable> - operator=(unique_ptr<_Yp, _Del>&& __r) - { - this->__shared_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } - - private: - - template - shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args) - : __shared_ptr<_Tp>(__tag, std::forward<_Args>(__args)...) - { } - - template - friend shared_ptr<_NonArray<_Yp>> - allocate_shared(const _Alloc&, _Args&&...); - - template - friend shared_ptr<_NonArray<_Yp>> - make_shared(_Args&&...); -# 535 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) noexcept - : __shared_ptr<_Tp>(__r, std::nothrow) { } - - friend class weak_ptr<_Tp>; - }; - - - template - shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; - template - shared_ptr(unique_ptr<_Tp, _Del>) -> shared_ptr<_Tp>; - - - - - - - - template - [[__nodiscard__]] inline bool - operator==(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return __a.get() == __b.get(); } - - - template - [[__nodiscard__]] inline bool - operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return !__a; } -# 580 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - [[__nodiscard__]] inline bool - operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return !__a; } - - - template - [[__nodiscard__]] inline bool - operator!=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return __a.get() != __b.get(); } - - - template - [[__nodiscard__]] inline bool - operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return (bool)__a; } - - - template - [[__nodiscard__]] inline bool - operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return (bool)__a; } - - - template - [[__nodiscard__]] inline bool - operator<(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { - using _Tp_elt = typename shared_ptr<_Tp>::element_type; - using _Up_elt = typename shared_ptr<_Up>::element_type; - using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type; - return less<_Vp>()(__a.get(), __b.get()); - } - - - template - [[__nodiscard__]] inline bool - operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { - using _Tp_elt = typename shared_ptr<_Tp>::element_type; - return less<_Tp_elt*>()(__a.get(), nullptr); - } - - - template - [[__nodiscard__]] inline bool - operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { - using _Tp_elt = typename shared_ptr<_Tp>::element_type; - return less<_Tp_elt*>()(nullptr, __a.get()); - } - - - template - [[__nodiscard__]] inline bool - operator<=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return !(__b < __a); } - - - template - [[__nodiscard__]] inline bool - operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return !(nullptr < __a); } - - - template - [[__nodiscard__]] inline bool - operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return !(__a < nullptr); } - - - template - [[__nodiscard__]] inline bool - operator>(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return (__b < __a); } - - - template - [[__nodiscard__]] inline bool - operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return nullptr < __a; } - - - template - [[__nodiscard__]] inline bool - operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return __a < nullptr; } - - - template - [[__nodiscard__]] inline bool - operator>=(const shared_ptr<_Tp>& __a, const shared_ptr<_Up>& __b) noexcept - { return !(__a < __b); } - - - template - [[__nodiscard__]] inline bool - operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept - { return !(__a < nullptr); } - - - template - [[__nodiscard__]] inline bool - operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept - { return !(nullptr < __a); } - - - - - - template - inline void - swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept - { __a.swap(__b); } - - - - - template - inline shared_ptr<_Tp> - static_pointer_cast(const shared_ptr<_Up>& __r) noexcept - { - using _Sp = shared_ptr<_Tp>; - return _Sp(__r, static_cast(__r.get())); - } - - - template - inline shared_ptr<_Tp> - const_pointer_cast(const shared_ptr<_Up>& __r) noexcept - { - using _Sp = shared_ptr<_Tp>; - return _Sp(__r, const_cast(__r.get())); - } - - - template - inline shared_ptr<_Tp> - dynamic_pointer_cast(const shared_ptr<_Up>& __r) noexcept - { - using _Sp = shared_ptr<_Tp>; - if (auto* __p = dynamic_cast(__r.get())) - return _Sp(__r, __p); - return _Sp(); - } - - - - - template - inline shared_ptr<_Tp> - reinterpret_pointer_cast(const shared_ptr<_Up>& __r) noexcept - { - using _Sp = shared_ptr<_Tp>; - return _Sp(__r, reinterpret_cast(__r.get())); - } -# 810 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - class weak_ptr : public __weak_ptr<_Tp> - { - template - using _Constructible = typename enable_if< - is_constructible<__weak_ptr<_Tp>, _Arg>::value - >::type; - - template - using _Assignable = typename enable_if< - is_assignable<__weak_ptr<_Tp>&, _Arg>::value, weak_ptr& - >::type; - - public: - constexpr weak_ptr() noexcept = default; - - template&>> - weak_ptr(const shared_ptr<_Yp>& __r) noexcept - : __weak_ptr<_Tp>(__r) { } - - weak_ptr(const weak_ptr&) noexcept = default; - - template&>> - weak_ptr(const weak_ptr<_Yp>& __r) noexcept - : __weak_ptr<_Tp>(__r) { } - - weak_ptr(weak_ptr&&) noexcept = default; - - template>> - weak_ptr(weak_ptr<_Yp>&& __r) noexcept - : __weak_ptr<_Tp>(std::move(__r)) { } - - weak_ptr& - operator=(const weak_ptr& __r) noexcept = default; - - template - _Assignable&> - operator=(const weak_ptr<_Yp>& __r) noexcept - { - this->__weak_ptr<_Tp>::operator=(__r); - return *this; - } - - template - _Assignable&> - operator=(const shared_ptr<_Yp>& __r) noexcept - { - this->__weak_ptr<_Tp>::operator=(__r); - return *this; - } - - weak_ptr& - operator=(weak_ptr&& __r) noexcept = default; - - template - _Assignable> - operator=(weak_ptr<_Yp>&& __r) noexcept - { - this->__weak_ptr<_Tp>::operator=(std::move(__r)); - return *this; - } - - shared_ptr<_Tp> - lock() const noexcept - { return shared_ptr<_Tp>(*this, std::nothrow); } - }; - - - template - weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; - - - - - - template - inline void - swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept - { __a.swap(__b); } - - - - template - struct owner_less; - - - template<> - struct owner_less : _Sp_owner_less - { }; - - - template - struct owner_less> - : public _Sp_owner_less, weak_ptr<_Tp>> - { }; - - - template - struct owner_less> - : public _Sp_owner_less, shared_ptr<_Tp>> - { }; - - - - - - - template - class enable_shared_from_this - { - protected: - constexpr enable_shared_from_this() noexcept { } - - enable_shared_from_this(const enable_shared_from_this&) noexcept { } - - enable_shared_from_this& - operator=(const enable_shared_from_this&) noexcept - { return *this; } - - ~enable_shared_from_this() { } - - public: - shared_ptr<_Tp> - shared_from_this() - { return shared_ptr<_Tp>(this->_M_weak_this); } - - shared_ptr - shared_from_this() const - { return shared_ptr(this->_M_weak_this); } - - - - - - - - weak_ptr<_Tp> - weak_from_this() noexcept - { return this->_M_weak_this; } - - weak_ptr - weak_from_this() const noexcept - { return this->_M_weak_this; } - - - - private: - template - void - _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept - { _M_weak_this._M_assign(__p, __n); } - - - friend const enable_shared_from_this* - __enable_shared_from_this_base(const __shared_count<>&, - const enable_shared_from_this* __p) - { return __p; } - - template - friend class __shared_ptr; - - mutable weak_ptr<_Tp> _M_weak_this; - }; -# 988 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - inline shared_ptr<_NonArray<_Tp>> - allocate_shared(const _Alloc& __a, _Args&&... __args) - { - return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, - std::forward<_Args>(__args)...); - } -# 1003 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - inline shared_ptr<_NonArray<_Tp>> - make_shared(_Args&&... __args) - { - using _Alloc = allocator; - _Alloc __a; - return shared_ptr<_Tp>(_Sp_alloc_shared_tag<_Alloc>{__a}, - std::forward<_Args>(__args)...); - } -# 1152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr.h" 3 - template - struct hash> - : public __hash_base> - { - size_t - operator()(const shared_ptr<_Tp>& __s) const noexcept - { - return std::hash::element_type*>()(__s.get()); - } - }; - - - - - - namespace __detail::__variant - { - template struct _Never_valueless_alt; - - - - template - struct _Never_valueless_alt> - : std::true_type - { }; - - - - template - struct _Never_valueless_alt> - : std::true_type - { }; - } - - - -} -# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_lockfree_defines.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_lockfree_defines.h" 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 2 3 -# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - typedef enum memory_order - { - memory_order_relaxed, - memory_order_consume, - memory_order_acquire, - memory_order_release, - memory_order_acq_rel, - memory_order_seq_cst - } memory_order; - - - - enum __memory_order_modifier - { - __memory_order_mask = 0x0ffff, - __memory_order_modifier_mask = 0xffff0000, - __memory_order_hle_acquire = 0x10000, - __memory_order_hle_release = 0x20000 - }; - - - constexpr memory_order - operator|(memory_order __m, __memory_order_modifier __mod) - { - return memory_order(int(__m) | int(__mod)); - } - - constexpr memory_order - operator&(memory_order __m, __memory_order_modifier __mod) - { - return memory_order(int(__m) & int(__mod)); - } - - - - - constexpr memory_order - __cmpexch_failure_order2(memory_order __m) noexcept - { - return __m == memory_order_acq_rel ? memory_order_acquire - : __m == memory_order_release ? memory_order_relaxed : __m; - } - - constexpr memory_order - __cmpexch_failure_order(memory_order __m) noexcept - { - return memory_order(__cmpexch_failure_order2(__m & __memory_order_mask) - | __memory_order_modifier(__m & __memory_order_modifier_mask)); - } - - constexpr bool - __is_valid_cmpexch_failure_order(memory_order __m) noexcept - { - return (__m & __memory_order_mask) != memory_order_release - && (__m & __memory_order_mask) != memory_order_acq_rel; - } - - - template - struct __atomic_base; - - - - inline __attribute__((__always_inline__)) void - atomic_thread_fence(memory_order __m) noexcept - { __atomic_thread_fence(int(__m)); } - - inline __attribute__((__always_inline__)) void - atomic_signal_fence(memory_order __m) noexcept - { __atomic_signal_fence(int(__m)); } - - - template - inline _Tp - kill_dependency(_Tp __y) noexcept - { - _Tp __ret(__y); - return __ret; - } -# 173 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - template - struct atomic; - - template - struct atomic<_Tp*>; - - - - typedef bool __atomic_flag_data_type; -# 198 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - extern "C" { - - struct __atomic_flag_base - { - __atomic_flag_data_type _M_i ; - }; - - } - - - - - - - struct atomic_flag : public __atomic_flag_base - { - atomic_flag() noexcept = default; - ~atomic_flag() noexcept = default; - atomic_flag(const atomic_flag&) = delete; - atomic_flag& operator=(const atomic_flag&) = delete; - atomic_flag& operator=(const atomic_flag&) volatile = delete; - - - constexpr atomic_flag(bool __i) noexcept - : __atomic_flag_base{ _S_init(__i) } - { } - - inline __attribute__((__always_inline__)) bool - test_and_set(memory_order __m = memory_order_seq_cst) noexcept - { - return __atomic_test_and_set (&_M_i, int(__m)); - } - - inline __attribute__((__always_inline__)) bool - test_and_set(memory_order __m = memory_order_seq_cst) volatile noexcept - { - return __atomic_test_and_set (&_M_i, int(__m)); - } -# 284 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - inline __attribute__((__always_inline__)) void - clear(memory_order __m = memory_order_seq_cst) noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - __atomic_clear (&_M_i, int(__m)); - } - - inline __attribute__((__always_inline__)) void - clear(memory_order __m = memory_order_seq_cst) volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - __atomic_clear (&_M_i, int(__m)); - } - - private: - static constexpr __atomic_flag_data_type - _S_init(bool __i) - { return __i ? 1 : 0; } - }; -# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - template - struct __atomic_base - { - using value_type = _ITp; - using difference_type = value_type; - - private: - typedef _ITp __int_type; - - static constexpr int _S_alignment = - sizeof(_ITp) > alignof(_ITp) ? sizeof(_ITp) : alignof(_ITp); - - alignas(_S_alignment) __int_type _M_i ; - - public: - __atomic_base() noexcept = default; - ~__atomic_base() noexcept = default; - __atomic_base(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) volatile = delete; - - - constexpr __atomic_base(__int_type __i) noexcept : _M_i (__i) { } - - operator __int_type() const noexcept - { return load(); } - - operator __int_type() const volatile noexcept - { return load(); } - - __int_type - operator=(__int_type __i) noexcept - { - store(__i); - return __i; - } - - __int_type - operator=(__int_type __i) volatile noexcept - { - store(__i); - return __i; - } - - __int_type - operator++(int) noexcept - { return fetch_add(1); } - - __int_type - operator++(int) volatile noexcept - { return fetch_add(1); } - - __int_type - operator--(int) noexcept - { return fetch_sub(1); } - - __int_type - operator--(int) volatile noexcept - { return fetch_sub(1); } - - __int_type - operator++() noexcept - { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } - - __int_type - operator++() volatile noexcept - { return __atomic_add_fetch(&_M_i, 1, int(memory_order_seq_cst)); } - - __int_type - operator--() noexcept - { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } - - __int_type - operator--() volatile noexcept - { return __atomic_sub_fetch(&_M_i, 1, int(memory_order_seq_cst)); } - - __int_type - operator+=(__int_type __i) noexcept - { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator+=(__int_type __i) volatile noexcept - { return __atomic_add_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator-=(__int_type __i) noexcept - { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator-=(__int_type __i) volatile noexcept - { return __atomic_sub_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator&=(__int_type __i) noexcept - { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator&=(__int_type __i) volatile noexcept - { return __atomic_and_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator|=(__int_type __i) noexcept - { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator|=(__int_type __i) volatile noexcept - { return __atomic_or_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator^=(__int_type __i) noexcept - { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - __int_type - operator^=(__int_type __i) volatile noexcept - { return __atomic_xor_fetch(&_M_i, __i, int(memory_order_seq_cst)); } - - bool - is_lock_free() const noexcept - { - - return __atomic_is_lock_free(sizeof(_M_i), - reinterpret_cast(-_S_alignment)); - } - - bool - is_lock_free() const volatile noexcept - { - - return __atomic_is_lock_free(sizeof(_M_i), - reinterpret_cast(-_S_alignment)); - } - - inline __attribute__((__always_inline__)) void - store(__int_type __i, memory_order __m = memory_order_seq_cst) noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - - __atomic_store_n(&_M_i, __i, int(__m)); - } - - inline __attribute__((__always_inline__)) void - store(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - - __atomic_store_n(&_M_i, __i, int(__m)); - } - - inline __attribute__((__always_inline__)) __int_type - load(memory_order __m = memory_order_seq_cst) const noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - return __atomic_load_n(&_M_i, int(__m)); - } - - inline __attribute__((__always_inline__)) __int_type - load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - return __atomic_load_n(&_M_i, int(__m)); - } - - inline __attribute__((__always_inline__)) __int_type - exchange(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { - return __atomic_exchange_n(&_M_i, __i, int(__m)); - } - - - inline __attribute__((__always_inline__)) __int_type - exchange(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return __atomic_exchange_n(&_M_i, __i, int(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m1, memory_order __m2) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 1, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) noexcept - { - return compare_exchange_weak(__i1, __i2, __m, - __cmpexch_failure_order(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return compare_exchange_weak(__i1, __i2, __m, - __cmpexch_failure_order(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m1, memory_order __m2) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_i, &__i1, __i2, 0, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) noexcept - { - return compare_exchange_strong(__i1, __i2, __m, - __cmpexch_failure_order(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__int_type& __i1, __int_type __i2, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return compare_exchange_strong(__i1, __i2, __m, - __cmpexch_failure_order(__m)); - } -# 632 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - inline __attribute__((__always_inline__)) __int_type - fetch_add(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_add(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_add(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_add(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_sub(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_sub(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_sub(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_and(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_and(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_and(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_and(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_or(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_or(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_or(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_or(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_xor(__int_type __i, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } - - inline __attribute__((__always_inline__)) __int_type - fetch_xor(__int_type __i, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_xor(&_M_i, __i, int(__m)); } - }; - - - - template - struct __atomic_base<_PTp*> - { - private: - typedef _PTp* __pointer_type; - - __pointer_type _M_p ; - - - constexpr ptrdiff_t - _M_type_size(ptrdiff_t __d) const { return __d * sizeof(_PTp); } - - constexpr ptrdiff_t - _M_type_size(ptrdiff_t __d) const volatile { return __d * sizeof(_PTp); } - - public: - __atomic_base() noexcept = default; - ~__atomic_base() noexcept = default; - __atomic_base(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) = delete; - __atomic_base& operator=(const __atomic_base&) volatile = delete; - - - constexpr __atomic_base(__pointer_type __p) noexcept : _M_p (__p) { } - - operator __pointer_type() const noexcept - { return load(); } - - operator __pointer_type() const volatile noexcept - { return load(); } - - __pointer_type - operator=(__pointer_type __p) noexcept - { - store(__p); - return __p; - } - - __pointer_type - operator=(__pointer_type __p) volatile noexcept - { - store(__p); - return __p; - } - - __pointer_type - operator++(int) noexcept - { return fetch_add(1); } - - __pointer_type - operator++(int) volatile noexcept - { return fetch_add(1); } - - __pointer_type - operator--(int) noexcept - { return fetch_sub(1); } - - __pointer_type - operator--(int) volatile noexcept - { return fetch_sub(1); } - - __pointer_type - operator++() noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator++() volatile noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator--() noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator--() volatile noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(1), - int(memory_order_seq_cst)); } - - __pointer_type - operator+=(ptrdiff_t __d) noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - __pointer_type - operator+=(ptrdiff_t __d) volatile noexcept - { return __atomic_add_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - __pointer_type - operator-=(ptrdiff_t __d) noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - __pointer_type - operator-=(ptrdiff_t __d) volatile noexcept - { return __atomic_sub_fetch(&_M_p, _M_type_size(__d), - int(memory_order_seq_cst)); } - - bool - is_lock_free() const noexcept - { - - return __atomic_is_lock_free(sizeof(_M_p), - reinterpret_cast(-__alignof(_M_p))); - } - - bool - is_lock_free() const volatile noexcept - { - - return __atomic_is_lock_free(sizeof(_M_p), - reinterpret_cast(-__alignof(_M_p))); - } - - inline __attribute__((__always_inline__)) void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - - __atomic_store_n(&_M_p, __p, int(__m)); - } - - inline __attribute__((__always_inline__)) void - store(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acquire)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_consume)) __builtin_unreachable(); } while (false); - - __atomic_store_n(&_M_p, __p, int(__m)); - } - - inline __attribute__((__always_inline__)) __pointer_type - load(memory_order __m = memory_order_seq_cst) const noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - return __atomic_load_n(&_M_p, int(__m)); - } - - inline __attribute__((__always_inline__)) __pointer_type - load(memory_order __m = memory_order_seq_cst) const volatile noexcept - { - memory_order __b __attribute__ ((__unused__)) - = __m & __memory_order_mask; - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_release)) __builtin_unreachable(); } while (false); - do { if (std::__is_constant_evaluated() && !bool(__b != memory_order_acq_rel)) __builtin_unreachable(); } while (false); - - return __atomic_load_n(&_M_p, int(__m)); - } - - inline __attribute__((__always_inline__)) __pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) noexcept - { - return __atomic_exchange_n(&_M_p, __p, int(__m)); - } - - - inline __attribute__((__always_inline__)) __pointer_type - exchange(__pointer_type __p, - memory_order __m = memory_order_seq_cst) volatile noexcept - { - return __atomic_exchange_n(&_M_p, __p, int(__m)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_weak(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 1, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, - int(__m1), int(__m2)); - } - - inline __attribute__((__always_inline__)) bool - compare_exchange_strong(__pointer_type& __p1, __pointer_type __p2, - memory_order __m1, - memory_order __m2) volatile noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__m2))) __builtin_unreachable(); } while (false); - - return __atomic_compare_exchange_n(&_M_p, &__p1, __p2, 0, - int(__m1), int(__m2)); - } -# 935 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 - inline __attribute__((__always_inline__)) __pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } - - inline __attribute__((__always_inline__)) __pointer_type - fetch_add(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_add(&_M_p, _M_type_size(__d), int(__m)); } - - inline __attribute__((__always_inline__)) __pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) noexcept - { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } - - inline __attribute__((__always_inline__)) __pointer_type - fetch_sub(ptrdiff_t __d, - memory_order __m = memory_order_seq_cst) volatile noexcept - { return __atomic_fetch_sub(&_M_p, _M_type_size(__d), int(__m)); } - }; - - namespace __atomic_impl - { - - - template - constexpr bool - __maybe_has_padding() - { - - return false; - - - - - - - } - - template - inline __attribute__((__always_inline__)) _Tp* - __clear_padding(_Tp& __val) noexcept - { - auto* __ptr = std::__addressof(__val); - - - - - return __ptr; - } - - - template - using _Val = typename remove_volatile<_Tp>::type; - - template - inline __attribute__((__always_inline__)) bool - __compare_exchange(_Tp& __val, _Val<_Tp>& __e, _Val<_Tp>& __i, - bool __is_weak, - memory_order __s, memory_order __f) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__is_valid_cmpexch_failure_order(__f))) __builtin_unreachable(); } while (false); - - using _Vp = _Val<_Tp>; - - if constexpr (__atomic_impl::__maybe_has_padding<_Vp>()) - { - - - alignas(_Vp) unsigned char __buf[sizeof(_Vp)]; - _Vp* __exp = ::new((void*)__buf) _Vp(__e); - __atomic_impl::__clear_padding(*__exp); - if (__atomic_compare_exchange(std::__addressof(__val), __exp, - __atomic_impl::__clear_padding(__i), - __is_weak, int(__s), int(__f))) - return true; - __builtin_memcpy(std::__addressof(__e), __exp, sizeof(_Vp)); - return false; - } - else - return __atomic_compare_exchange(std::__addressof(__val), - std::__addressof(__e), - std::__addressof(__i), - __is_weak, int(__s), int(__f)); - } - } -# 2021 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/atomic_base.h" 3 -} -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 2 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - struct _Sp_locker - { - _Sp_locker(const _Sp_locker&) = delete; - _Sp_locker& operator=(const _Sp_locker&) = delete; - - - explicit - _Sp_locker(const void*) noexcept; - _Sp_locker(const void*, const void*) noexcept; - ~_Sp_locker(); - - private: - unsigned char _M_key1; - unsigned char _M_key2; - - - - }; -# 100 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - inline bool - atomic_is_lock_free(const __shared_ptr<_Tp, _Lp>* __p) - { - - return __gthread_active_p() == 0; - - - - } - - template - inline bool - atomic_is_lock_free(const shared_ptr<_Tp>* __p) - { return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); } -# 127 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - inline shared_ptr<_Tp> - atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) - { - _Sp_locker __lock{__p}; - return *__p; - } - - template - inline shared_ptr<_Tp> - atomic_load(const shared_ptr<_Tp>* __p) - { return std::atomic_load_explicit(__p, memory_order_seq_cst); } - - template - inline __shared_ptr<_Tp, _Lp> - atomic_load_explicit(const __shared_ptr<_Tp, _Lp>* __p, memory_order) - { - _Sp_locker __lock{__p}; - return *__p; - } - - template - inline __shared_ptr<_Tp, _Lp> - atomic_load(const __shared_ptr<_Tp, _Lp>* __p) - { return std::atomic_load_explicit(__p, memory_order_seq_cst); } -# 163 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - inline void - atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, - memory_order) - { - _Sp_locker __lock{__p}; - __p->swap(__r); - } - - template - inline void - atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) - { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } - - template - inline void - atomic_store_explicit(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp> __r, - memory_order) - { - _Sp_locker __lock{__p}; - __p->swap(__r); - } - - template - inline void - atomic_store(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) - { std::atomic_store_explicit(__p, std::move(__r), memory_order_seq_cst); } -# 200 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - inline shared_ptr<_Tp> - atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, - memory_order) - { - _Sp_locker __lock{__p}; - __p->swap(__r); - return __r; - } - - template - inline shared_ptr<_Tp> - atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) - { - return std::atomic_exchange_explicit(__p, std::move(__r), - memory_order_seq_cst); - } - - template - inline __shared_ptr<_Tp, _Lp> - atomic_exchange_explicit(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp> __r, - memory_order) - { - _Sp_locker __lock{__p}; - __p->swap(__r); - return __r; - } - - template - inline __shared_ptr<_Tp, _Lp> - atomic_exchange(__shared_ptr<_Tp, _Lp>* __p, __shared_ptr<_Tp, _Lp> __r) - { - return std::atomic_exchange_explicit(__p, std::move(__r), - memory_order_seq_cst); - } -# 249 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 - template - bool - atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p, - shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w, - memory_order, - memory_order) - { - shared_ptr<_Tp> __x; - _Sp_locker __lock{__p, __v}; - owner_less> __less; - if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) - { - __x = std::move(*__p); - *__p = std::move(__w); - return true; - } - __x = std::move(*__v); - *__v = *__p; - return false; - } - - template - inline bool - atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w) - { - return std::atomic_compare_exchange_strong_explicit(__p, __v, - std::move(__w), memory_order_seq_cst, memory_order_seq_cst); - } - - template - inline bool - atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p, - shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w, - memory_order __success, - memory_order __failure) - { - return std::atomic_compare_exchange_strong_explicit(__p, __v, - std::move(__w), __success, __failure); - } - - template - inline bool - atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, - shared_ptr<_Tp> __w) - { - return std::atomic_compare_exchange_weak_explicit(__p, __v, - std::move(__w), memory_order_seq_cst, memory_order_seq_cst); - } - - template - bool - atomic_compare_exchange_strong_explicit(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp>* __v, - __shared_ptr<_Tp, _Lp> __w, - memory_order, - memory_order) - { - __shared_ptr<_Tp, _Lp> __x; - _Sp_locker __lock{__p, __v}; - owner_less<__shared_ptr<_Tp, _Lp>> __less; - if (*__p == *__v && !__less(*__p, *__v) && !__less(*__v, *__p)) - { - __x = std::move(*__p); - *__p = std::move(__w); - return true; - } - __x = std::move(*__v); - *__v = *__p; - return false; - } - - template - inline bool - atomic_compare_exchange_strong(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp>* __v, - __shared_ptr<_Tp, _Lp> __w) - { - return std::atomic_compare_exchange_strong_explicit(__p, __v, - std::move(__w), memory_order_seq_cst, memory_order_seq_cst); - } - - template - inline bool - atomic_compare_exchange_weak_explicit(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp>* __v, - __shared_ptr<_Tp, _Lp> __w, - memory_order __success, - memory_order __failure) - { - return std::atomic_compare_exchange_strong_explicit(__p, __v, - std::move(__w), __success, __failure); - } - - template - inline bool - atomic_compare_exchange_weak(__shared_ptr<_Tp, _Lp>* __p, - __shared_ptr<_Tp, _Lp>* __v, - __shared_ptr<_Tp, _Lp> __w) - { - return std::atomic_compare_exchange_weak_explicit(__p, __v, - std::move(__w), memory_order_seq_cst, memory_order_seq_cst); - } -# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/shared_ptr_atomic.h" 3 -} -# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - template - struct auto_ptr_ref - { - _Tp1* _M_ptr; - - explicit - auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { } - } __attribute__ ((__deprecated__)); - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 92 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - template - class auto_ptr - { - private: - _Tp* _M_ptr; - - public: - - typedef _Tp element_type; - - - - - - - - explicit - auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { } -# 118 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { } -# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - template - auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { } -# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - auto_ptr& - operator=(auto_ptr& __a) throw() - { - reset(__a.release()); - return *this; - } -# 158 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - template - auto_ptr& - operator=(auto_ptr<_Tp1>& __a) throw() - { - reset(__a.release()); - return *this; - } -# 176 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - ~auto_ptr() { delete _M_ptr; } -# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - element_type& - operator*() const throw() - { - do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) __builtin_unreachable(); } while (false); - return *_M_ptr; - } - - - - - - - - element_type* - operator->() const throw() - { - do { if (std::__is_constant_evaluated() && !bool(_M_ptr != 0)) __builtin_unreachable(); } while (false); - return _M_ptr; - } -# 216 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - element_type* - get() const throw() { return _M_ptr; } -# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - element_type* - release() throw() - { - element_type* __tmp = _M_ptr; - _M_ptr = 0; - return __tmp; - } -# 245 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - void - reset(element_type* __p = 0) throw() - { - if (__p != _M_ptr) - { - delete _M_ptr; - _M_ptr = __p; - } - } -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/auto_ptr.h" 3 - auto_ptr(auto_ptr_ref __ref) throw() - : _M_ptr(__ref._M_ptr) { } - - auto_ptr& - operator=(auto_ptr_ref __ref) throw() - { - if (__ref._M_ptr != this->get()) - { - delete _M_ptr; - _M_ptr = __ref._M_ptr; - } - return *this; - } - - template - operator auto_ptr_ref<_Tp1>() throw() - { return auto_ptr_ref<_Tp1>(this->release()); } - - template - operator auto_ptr<_Tp1>() throw() - { return auto_ptr<_Tp1>(this->release()); } - } __attribute__ ((__deprecated__ ("use '" "std::unique_ptr" "' instead"))); - - - - template<> - class auto_ptr - { - public: - typedef void element_type; - } __attribute__ ((__deprecated__)); - - - - template<_Lock_policy _Lp> - template - inline - __shared_count<_Lp>::__shared_count(std::auto_ptr<_Tp>&& __r) - : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get())) - { __r.release(); } - - template - template - inline - __shared_ptr<_Tp, _Lp>::__shared_ptr(std::auto_ptr<_Tp1>&& __r) - : _M_ptr(__r.get()), _M_refcount() - { - - static_assert( sizeof(_Tp1) > 0, "incomplete type" ); - _Tp1* __tmp = __r.get(); - _M_refcount = __shared_count<_Lp>(std::move(__r)); - _M_enable_shared_from_this_with(__tmp); - } - - template - template - inline - shared_ptr<_Tp>::shared_ptr(std::auto_ptr<_Tp1>&& __r) - : __shared_ptr<_Tp>(std::move(__r)) { } - - - template - template - inline - unique_ptr<_Tp, _Dp>::unique_ptr(auto_ptr<_Up>&& __u) noexcept - : _M_t(__u.release(), deleter_type()) { } - - -#pragma GCC diagnostic pop - - -} -# 87 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 -# 101 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 -enum class pointer_safety { relaxed, preferred, strict }; - - -inline void -declare_reachable(void*) { } - - -template - inline _Tp* - undeclare_reachable(_Tp* __p) { return __p; } - - -inline void -declare_no_pointers(char*, size_t) { } - - -inline void -undeclare_no_pointers(char*, size_t) { } - - -inline pointer_safety -get_pointer_safety() noexcept { return pointer_safety::relaxed; } - - - -} -# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/glue_memory_defs.h" 1 3 -# 13 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/glue_memory_defs.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/execution_defs.h" 1 3 -# 15 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/execution_defs.h" 3 -namespace __pstl -{ -namespace execution -{ -inline namespace v1 -{ - - -class sequenced_policy -{ - public: - - static constexpr std::false_type - __allow_unsequenced() - { - return std::false_type{}; - } - static constexpr std::false_type - __allow_vector() - { - return std::false_type{}; - } - static constexpr std::false_type - __allow_parallel() - { - return std::false_type{}; - } -}; - - -class parallel_policy -{ - public: - - static constexpr std::false_type - __allow_unsequenced() - { - return std::false_type{}; - } - static constexpr std::false_type - __allow_vector() - { - return std::false_type{}; - } - static constexpr std::true_type - __allow_parallel() - { - return std::true_type{}; - } -}; - - -class parallel_unsequenced_policy -{ - public: - - static constexpr std::true_type - __allow_unsequenced() - { - return std::true_type{}; - } - static constexpr std::true_type - __allow_vector() - { - return std::true_type{}; - } - static constexpr std::true_type - __allow_parallel() - { - return std::true_type{}; - } -}; - -class unsequenced_policy -{ - public: - - static constexpr std::true_type - __allow_unsequenced() - { - return std::true_type{}; - } - static constexpr std::true_type - __allow_vector() - { - return std::true_type{}; - } - static constexpr std::false_type - __allow_parallel() - { - return std::false_type{}; - } -}; - - -inline constexpr sequenced_policy seq{}; -inline constexpr parallel_policy par{}; -inline constexpr parallel_unsequenced_policy par_unseq{}; -inline constexpr unsequenced_policy unseq{}; - - -template -struct is_execution_policy : std::false_type -{ -}; - -template <> -struct is_execution_policy<__pstl::execution::sequenced_policy> : std::true_type -{ -}; -template <> -struct is_execution_policy<__pstl::execution::parallel_policy> : std::true_type -{ -}; -template <> -struct is_execution_policy<__pstl::execution::parallel_unsequenced_policy> : std::true_type -{ -}; -template <> -struct is_execution_policy<__pstl::execution::unsequenced_policy> : std::true_type -{ -}; - - -template -constexpr bool is_execution_policy_v = __pstl::execution::is_execution_policy<_Tp>::value; - - -} -} - -namespace __internal -{ -template - -using __enable_if_execution_policy = - typename std::enable_if<__pstl::execution::is_execution_policy>::value, - _Tp>::type; - - - - - -} - -} -# 14 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/glue_memory_defs.h" 2 3 - -namespace std -{ - - - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> -uninitialized_copy(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> -uninitialized_copy_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); - - - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> -uninitialized_move(_ExecutionPolicy&& __exec, _InputIterator __first, _InputIterator __last, _ForwardIterator __result); - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> -uninitialized_move_n(_ExecutionPolicy&& __exec, _InputIterator __first, _Size __n, _ForwardIterator __result); - - - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> -uninitialized_fill(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value); - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> -uninitialized_fill_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n, const _Tp& __value); - - - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> -destroy(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> -destroy_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); - - - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> -uninitialized_default_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> -uninitialized_default_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); - - - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, void> -uninitialized_value_construct(_ExecutionPolicy&& __exec, _ForwardIterator __first, _ForwardIterator __last); - -template -__pstl::__internal::__enable_if_execution_policy<_ExecutionPolicy, _ForwardIterator> -uninitialized_value_construct_n(_ExecutionPolicy&& __exec, _ForwardIterator __first, _Size __n); - -} -# 155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/memory" 2 3 -# 15 "src/platform/inputs.h" 2 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 1 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 3 - - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 1 3 -# 78 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template - struct _Vector_base - { - typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template - rebind<_Tp>::other _Tp_alloc_type; - typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer - pointer; - - struct _Vector_impl_data - { - pointer _M_start; - pointer _M_finish; - pointer _M_end_of_storage; - - - _Vector_impl_data() noexcept - : _M_start(), _M_finish(), _M_end_of_storage() - { } - - - - _Vector_impl_data(_Vector_impl_data&& __x) noexcept - : _M_start(__x._M_start), _M_finish(__x._M_finish), - _M_end_of_storage(__x._M_end_of_storage) - { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); } - - - - void - _M_copy_data(_Vector_impl_data const& __x) noexcept - { - _M_start = __x._M_start; - _M_finish = __x._M_finish; - _M_end_of_storage = __x._M_end_of_storage; - } - - - void - _M_swap_data(_Vector_impl_data& __x) noexcept - { - - - _Vector_impl_data __tmp; - __tmp._M_copy_data(*this); - _M_copy_data(__x); - __x._M_copy_data(__tmp); - } - }; - - struct _Vector_impl - : public _Tp_alloc_type, public _Vector_impl_data - { - - _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value) - - : _Tp_alloc_type() - { } - - - _Vector_impl(_Tp_alloc_type const& __a) noexcept - : _Tp_alloc_type(__a) - { } - - - - - - _Vector_impl(_Vector_impl&& __x) noexcept - : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x)) - { } - - - _Vector_impl(_Tp_alloc_type&& __a) noexcept - : _Tp_alloc_type(std::move(__a)) - { } - - - _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept - : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv)) - { } -# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - }; - - public: - typedef _Alloc allocator_type; - - - _Tp_alloc_type& - _M_get_Tp_allocator() noexcept - { return this->_M_impl; } - - - const _Tp_alloc_type& - _M_get_Tp_allocator() const noexcept - { return this->_M_impl; } - - - allocator_type - get_allocator() const noexcept - { return allocator_type(_M_get_Tp_allocator()); } - - - _Vector_base() = default; - - - - - - _Vector_base(const allocator_type& __a) noexcept - : _M_impl(__a) { } - - - - - _Vector_base(size_t __n) - : _M_impl() - { _M_create_storage(__n); } - - - - _Vector_base(size_t __n, const allocator_type& __a) - : _M_impl(__a) - { _M_create_storage(__n); } - - - _Vector_base(_Vector_base&&) = default; - - - - - _Vector_base(_Tp_alloc_type&& __a) noexcept - : _M_impl(std::move(__a)) { } - - - _Vector_base(_Vector_base&& __x, const allocator_type& __a) - : _M_impl(__a) - { - if (__x.get_allocator() == __a) - this->_M_impl._M_swap_data(__x._M_impl); - else - { - size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start; - _M_create_storage(__n); - } - } - - - - _Vector_base(const allocator_type& __a, _Vector_base&& __x) - : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl)) - { } - - - - ~_Vector_base() noexcept - { - _M_deallocate(_M_impl._M_start, - _M_impl._M_end_of_storage - _M_impl._M_start); - } - - public: - _Vector_impl _M_impl; - - - pointer - _M_allocate(size_t __n) - { - typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; - return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer(); - } - - - void - _M_deallocate(pointer __p, size_t __n) - { - typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; - if (__p) - _Tr::deallocate(_M_impl, __p, __n); - } - - protected: - - void - _M_create_storage(size_t __n) - { - this->_M_impl._M_start = this->_M_allocate(__n); - this->_M_impl._M_finish = this->_M_impl._M_start; - this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; - } - }; -# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template > - class vector : protected _Vector_base<_Tp, _Alloc> - { -# 437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - static_assert(is_same::type, _Tp>::value, - "std::vector must have a non-const, non-volatile value_type"); - - static_assert(is_same::value, - "std::vector must have the same value_type as its allocator"); - - - - typedef _Vector_base<_Tp, _Alloc> _Base; - typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; - typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; - - public: - typedef _Tp value_type; - typedef typename _Base::pointer pointer; - typedef typename _Alloc_traits::const_pointer const_pointer; - typedef typename _Alloc_traits::reference reference; - typedef typename _Alloc_traits::const_reference const_reference; - typedef __gnu_cxx::__normal_iterator iterator; - typedef __gnu_cxx::__normal_iterator - const_iterator; - typedef std::reverse_iterator const_reverse_iterator; - typedef std::reverse_iterator reverse_iterator; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Alloc allocator_type; - - private: - - static constexpr bool - _S_nothrow_relocate(true_type) - { - return noexcept(std::__relocate_a(std::declval(), - std::declval(), - std::declval(), - std::declval<_Tp_alloc_type&>())); - } - - static constexpr bool - _S_nothrow_relocate(false_type) - { return false; } - - static constexpr bool - _S_use_relocate() - { - - - - return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{}); - } - - static pointer - _S_do_relocate(pointer __first, pointer __last, pointer __result, - _Tp_alloc_type& __alloc, true_type) noexcept - { - return std::__relocate_a(__first, __last, __result, __alloc); - } - - static pointer - _S_do_relocate(pointer, pointer, pointer __result, - _Tp_alloc_type&, false_type) noexcept - { return __result; } - - static pointer - _S_relocate(pointer __first, pointer __last, pointer __result, - _Tp_alloc_type& __alloc) noexcept - { - - - return std::__relocate_a(__first, __last, __result, __alloc); - - - - - } - - - protected: - using _Base::_M_allocate; - using _Base::_M_deallocate; - using _Base::_M_impl; - using _Base::_M_get_Tp_allocator; - - public: - - - - - - - - vector() = default; -# 537 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - explicit - - vector(const allocator_type& __a) noexcept - : _Base(__a) { } -# 551 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - explicit - - vector(size_type __n, const allocator_type& __a = allocator_type()) - : _Base(_S_check_init_len(__n, __a), __a) - { _M_default_initialize(__n); } -# 566 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector(size_type __n, const value_type& __value, - const allocator_type& __a = allocator_type()) - : _Base(_S_check_init_len(__n, __a), __a) - { _M_fill_initialize(__n, __value); } -# 598 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector(const vector& __x) - : _Base(__x.size(), - _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator())) - { - this->_M_impl._M_finish = - std::__uninitialized_copy_a(__x.begin(), __x.end(), - this->_M_impl._M_start, - _M_get_Tp_allocator()); - } -# 617 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector(vector&&) noexcept = default; - - - - vector(const vector& __x, const __type_identity_t& __a) - : _Base(__x.size(), __a) - { - this->_M_impl._M_finish = - std::__uninitialized_copy_a(__x.begin(), __x.end(), - this->_M_impl._M_start, - _M_get_Tp_allocator()); - } - - private: - - vector(vector&& __rv, const allocator_type& __m, true_type) noexcept - : _Base(__m, std::move(__rv)) - { } - - - vector(vector&& __rv, const allocator_type& __m, false_type) - : _Base(__m) - { - if (__rv.get_allocator() == __m) - this->_M_impl._M_swap_data(__rv._M_impl); - else if (!__rv.empty()) - { - this->_M_create_storage(__rv.size()); - this->_M_impl._M_finish = - std::__uninitialized_move_a(__rv.begin(), __rv.end(), - this->_M_impl._M_start, - _M_get_Tp_allocator()); - __rv.clear(); - } - } - - public: - - - vector(vector&& __rv, const __type_identity_t& __m) - noexcept( noexcept( - vector(std::declval(), std::declval(), - std::declval())) ) - : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{}) - { } -# 675 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector(initializer_list __l, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { - _M_range_initialize(__l.begin(), __l.end(), - random_access_iterator_tag()); - } -# 701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template> - - vector(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { - _M_range_initialize(__first, __last, - std::__iterator_category(__first)); - } -# 730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - ~vector() noexcept - { - std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - ; - } -# 747 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector& - operator=(const vector& __x); -# 762 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector& - operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) - { - constexpr bool __move_storage = - _Alloc_traits::_S_propagate_on_move_assign() - || _Alloc_traits::_S_always_equal(); - _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); - return *this; - } -# 784 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector& - operator=(initializer_list __l) - { - this->_M_assign_aux(__l.begin(), __l.end(), - random_access_iterator_tag()); - return *this; - } -# 804 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - assign(size_type __n, const value_type& __val) - { _M_fill_assign(__n, __val); } -# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template> - - void - assign(_InputIterator __first, _InputIterator __last) - { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } -# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - assign(initializer_list __l) - { - this->_M_assign_aux(__l.begin(), __l.end(), - random_access_iterator_tag()); - } - - - - using _Base::get_allocator; - - - - - - - - [[__nodiscard__]] - iterator - begin() noexcept - { return iterator(this->_M_impl._M_start); } - - - - - - - [[__nodiscard__]] - const_iterator - begin() const noexcept - { return const_iterator(this->_M_impl._M_start); } - - - - - - - [[__nodiscard__]] - iterator - end() noexcept - { return iterator(this->_M_impl._M_finish); } - - - - - - - [[__nodiscard__]] - const_iterator - end() const noexcept - { return const_iterator(this->_M_impl._M_finish); } - - - - - - - [[__nodiscard__]] - reverse_iterator - rbegin() noexcept - { return reverse_iterator(end()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - rbegin() const noexcept - { return const_reverse_iterator(end()); } - - - - - - - [[__nodiscard__]] - reverse_iterator - rend() noexcept - { return reverse_iterator(begin()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - rend() const noexcept - { return const_reverse_iterator(begin()); } - - - - - - - - [[__nodiscard__]] - const_iterator - cbegin() const noexcept - { return const_iterator(this->_M_impl._M_start); } - - - - - - - [[__nodiscard__]] - const_iterator - cend() const noexcept - { return const_iterator(this->_M_impl._M_finish); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(end()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(begin()); } - - - - - [[__nodiscard__]] - size_type - size() const noexcept - { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } - - - [[__nodiscard__]] - size_type - max_size() const noexcept - { return _S_max_size(_M_get_Tp_allocator()); } -# 1009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - resize(size_type __new_size) - { - if (__new_size > size()) - _M_default_append(__new_size - size()); - else if (__new_size < size()) - _M_erase_at_end(this->_M_impl._M_start + __new_size); - } -# 1030 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - resize(size_type __new_size, const value_type& __x) - { - if (__new_size > size()) - _M_fill_insert(end(), __new_size - size(), __x); - else if (__new_size < size()) - _M_erase_at_end(this->_M_impl._M_start + __new_size); - } -# 1064 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - shrink_to_fit() - { _M_shrink_to_fit(); } - - - - - - - [[__nodiscard__]] - size_type - capacity() const noexcept - { return size_type(this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); } - - - - - - [[__nodiscard__]] - bool - empty() const noexcept - { return begin() == end(); } -# 1106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - reserve(size_type __n); -# 1121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - [[__nodiscard__]] - reference - operator[](size_type __n) noexcept - { - ; - return *(this->_M_impl._M_start + __n); - } -# 1140 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - [[__nodiscard__]] - const_reference - operator[](size_type __n) const noexcept - { - ; - return *(this->_M_impl._M_start + __n); - } - - protected: - - - void - _M_range_check(size_type __n) const - { - if (__n >= this->size()) - __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"), - - - __n, this->size()); - } - - public: -# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - reference - at(size_type __n) - { - _M_range_check(__n); - return (*this)[__n]; - } -# 1193 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - const_reference - at(size_type __n) const - { - _M_range_check(__n); - return (*this)[__n]; - } - - - - - - [[__nodiscard__]] - reference - front() noexcept - { - ; - return *begin(); - } - - - - - - [[__nodiscard__]] - const_reference - front() const noexcept - { - ; - return *begin(); - } - - - - - - [[__nodiscard__]] - reference - back() noexcept - { - ; - return *(end() - 1); - } - - - - - - [[__nodiscard__]] - const_reference - back() const noexcept - { - ; - return *(end() - 1); - } -# 1255 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - [[__nodiscard__]] - _Tp* - data() noexcept - { return _M_data_ptr(this->_M_impl._M_start); } - - [[__nodiscard__]] - const _Tp* - data() const noexcept - { return _M_data_ptr(this->_M_impl._M_start); } -# 1277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - push_back(const value_type& __x) - { - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - __x); - ++this->_M_impl._M_finish; - ; - } - else - _M_realloc_insert(end(), __x); - } - - - - void - push_back(value_type&& __x) - { emplace_back(std::move(__x)); } - - template - - - reference - - - - emplace_back(_Args&&... __args); -# 1318 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - pop_back() noexcept - { - ; - --this->_M_impl._M_finish; - _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); - ; - } -# 1340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - - iterator - emplace(const_iterator __position, _Args&&... __args) - { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); } -# 1358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - insert(const_iterator __position, const value_type& __x); -# 1389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - insert(const_iterator __position, value_type&& __x) - { return _M_insert_rval(__position, std::move(__x)); } -# 1407 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - insert(const_iterator __position, initializer_list __l) - { - auto __offset = __position - cbegin(); - _M_range_insert(begin() + __offset, __l.begin(), __l.end(), - std::random_access_iterator_tag()); - return begin() + __offset; - } -# 1433 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - insert(const_iterator __position, size_type __n, const value_type& __x) - { - difference_type __offset = __position - cbegin(); - _M_fill_insert(begin() + __offset, __n, __x); - return begin() + __offset; - } -# 1475 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template> - - iterator - insert(const_iterator __position, _InputIterator __first, - _InputIterator __last) - { - difference_type __offset = __position - cbegin(); - _M_range_insert(begin() + __offset, __first, __last, - std::__iterator_category(__first)); - return begin() + __offset; - } -# 1529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - - erase(const_iterator __position) - { return _M_erase(begin() + (__position - cbegin())); } -# 1557 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - - erase(const_iterator __first, const_iterator __last) - { - const auto __beg = begin(); - const auto __cbeg = cbegin(); - return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg)); - } -# 1582 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - swap(vector& __x) noexcept - { - - do { if (std::__is_constant_evaluated() && !bool(_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator())) __builtin_unreachable(); } while (false); - - - this->_M_impl._M_swap_data(__x._M_impl); - _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(), - __x._M_get_Tp_allocator()); - } -# 1601 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - clear() noexcept - { _M_erase_at_end(this->_M_impl._M_start); } - - protected: - - - - - template - - pointer - _M_allocate_and_copy(size_type __n, - _ForwardIterator __first, _ForwardIterator __last) - { - pointer __result = this->_M_allocate(__n); - try - { - std::__uninitialized_copy_a(__first, __last, __result, - _M_get_Tp_allocator()); - return __result; - } - catch(...) - { - _M_deallocate(__result, __n); - throw; - } - } -# 1661 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - - void - _M_range_initialize(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag) - { - try { - for (; __first != __last; ++__first) - - emplace_back(*__first); - - - - } catch(...) { - clear(); - throw; - } - } - - - template - - void - _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag) - { - const size_type __n = std::distance(__first, __last); - this->_M_impl._M_start - = this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator())); - this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; - this->_M_impl._M_finish = - std::__uninitialized_copy_a(__first, __last, - this->_M_impl._M_start, - _M_get_Tp_allocator()); - } - - - - - void - _M_fill_initialize(size_type __n, const value_type& __value) - { - this->_M_impl._M_finish = - std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, - _M_get_Tp_allocator()); - } - - - - - void - _M_default_initialize(size_type __n) - { - this->_M_impl._M_finish = - std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, - _M_get_Tp_allocator()); - } -# 1727 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - - void - _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) - { _M_fill_assign(__n, __val); } - - - template - - void - _M_assign_dispatch(_InputIterator __first, _InputIterator __last, - __false_type) - { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } - - - template - - void - _M_assign_aux(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag); - - - template - - void - _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag); - - - - - void - _M_fill_assign(size_type __n, const value_type& __val); - - - - - - - - template - - void - _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, - __true_type) - { _M_fill_insert(__pos, __n, __val); } - - - template - - void - _M_insert_dispatch(iterator __pos, _InputIterator __first, - _InputIterator __last, __false_type) - { - _M_range_insert(__pos, __first, __last, - std::__iterator_category(__first)); - } - - - template - - void - _M_range_insert(iterator __pos, _InputIterator __first, - _InputIterator __last, std::input_iterator_tag); - - - template - - void - _M_range_insert(iterator __pos, _ForwardIterator __first, - _ForwardIterator __last, std::forward_iterator_tag); - - - - - void - _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); - - - - - void - _M_default_append(size_type __n); - - - bool - _M_shrink_to_fit(); -# 1826 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - struct _Temporary_value - { - template - explicit - _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec) - { - _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(), - std::forward<_Args>(__args)...); - } - - - ~_Temporary_value() - { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); } - - value_type& - _M_val() noexcept { return _M_storage._M_val; } - - private: - _Tp* - _M_ptr() noexcept { return std::__addressof(_M_storage._M_val); } - - union _Storage - { - constexpr _Storage() : _M_byte() { } - ~_Storage() { } - _Storage& operator=(const _Storage&) = delete; - unsigned char _M_byte; - _Tp _M_val; - }; - - vector* _M_this; - _Storage _M_storage; - }; - - - - template - - void - _M_insert_aux(iterator __position, _Arg&& __arg); - - template - - void - _M_realloc_insert(iterator __position, _Args&&... __args); - - - - iterator - _M_insert_rval(const_iterator __position, value_type&& __v); - - - template - - iterator - _M_emplace_aux(const_iterator __position, _Args&&... __args); - - - - iterator - _M_emplace_aux(const_iterator __position, value_type&& __v) - { return _M_insert_rval(__position, std::move(__v)); } - - - - - size_type - _M_check_len(size_type __n, const char* __s) const - { - if (max_size() - size() < __n) - __throw_length_error((__s)); - - const size_type __len = size() + (std::max)(size(), __n); - return (__len < size() || __len > max_size()) ? max_size() : __len; - } - - - static size_type - _S_check_init_len(size_type __n, const allocator_type& __a) - { - if (__n > _S_max_size(_Tp_alloc_type(__a))) - __throw_length_error( - ("cannot create std::vector larger than max_size()")); - return __n; - } - - static size_type - _S_max_size(const _Tp_alloc_type& __a) noexcept - { - - - - const size_t __diffmax - = __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); - const size_t __allocmax = _Alloc_traits::max_size(__a); - return (std::min)(__diffmax, __allocmax); - } - - - - - - - void - _M_erase_at_end(pointer __pos) noexcept - { - if (size_type __n = this->_M_impl._M_finish - __pos) - { - std::_Destroy(__pos, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish = __pos; - ; - } - } - - - iterator - _M_erase(iterator __position); - - - iterator - _M_erase(iterator __first, iterator __last); - - - private: - - - - - void - _M_move_assign(vector&& __x, true_type) noexcept - { - vector __tmp(get_allocator()); - this->_M_impl._M_swap_data(__x._M_impl); - __tmp._M_impl._M_swap_data(__x._M_impl); - std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); - } - - - - - void - _M_move_assign(vector&& __x, false_type) - { - if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) - _M_move_assign(std::move(__x), true_type()); - else - { - - - this->_M_assign_aux(std::make_move_iterator(__x.begin()), - std::make_move_iterator(__x.end()), - std::random_access_iterator_tag()); - __x.clear(); - } - } - - - template - - _Up* - _M_data_ptr(_Up* __ptr) const noexcept - { return __ptr; } - - - template - - typename std::pointer_traits<_Ptr>::element_type* - _M_data_ptr(_Ptr __ptr) const - { return empty() ? nullptr : std::__to_address(__ptr); } -# 2012 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - }; - - - template::value_type, - typename _Allocator = allocator<_ValT>, - typename = _RequireInputIter<_InputIterator>, - typename = _RequireAllocator<_Allocator>> - vector(_InputIterator, _InputIterator, _Allocator = _Allocator()) - -> vector<_ValT, _Allocator>; -# 2034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - - inline bool - operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return (__x.size() == __y.size() - && std::equal(__x.begin(), __x.end(), __y.begin())); } -# 2074 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - inline bool - operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return std::lexicographical_compare(__x.begin(), __x.end(), - __y.begin(), __y.end()); } - - - template - inline bool - operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return !(__x == __y); } - - - template - inline bool - operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return __y < __x; } - - - template - inline bool - operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return !(__y < __x); } - - - template - inline bool - operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return !(__x < __y); } - - - - template - - inline void - swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } - - - - - namespace __detail::__variant - { - template struct _Never_valueless_alt; - - - - template - struct _Never_valueless_alt> - : std::is_nothrow_move_assignable> - { }; - } - - - -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 1 3 -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - typedef unsigned long _Bit_type; - enum { _S_word_bit = int(8 * sizeof(_Bit_type)) }; - - __attribute__((__nonnull__)) - - void - __fill_bvector_n(_Bit_type*, size_t, bool) noexcept; - - - - struct _Bit_reference - { - _Bit_type * _M_p; - _Bit_type _M_mask; - - - _Bit_reference(_Bit_type * __x, _Bit_type __y) - : _M_p(__x), _M_mask(__y) { } - - - _Bit_reference() noexcept : _M_p(0), _M_mask(0) { } - - - _Bit_reference(const _Bit_reference&) = default; - - - [[__nodiscard__]] - operator bool() const noexcept - { return !!(*_M_p & _M_mask); } - - - _Bit_reference& - operator=(bool __x) noexcept - { - if (__x) - *_M_p |= _M_mask; - else - *_M_p &= ~_M_mask; - return *this; - } -# 122 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - _Bit_reference& - operator=(const _Bit_reference& __x) noexcept - { return *this = bool(__x); } - - [[__nodiscard__]] - bool - operator==(const _Bit_reference& __x) const - { return bool(*this) == bool(__x); } - - [[__nodiscard__]] - bool - operator<(const _Bit_reference& __x) const - { return !bool(*this) && bool(__x); } - - - void - flip() noexcept - { *_M_p ^= _M_mask; } - - - - friend void - swap(_Bit_reference __x, _Bit_reference __y) noexcept - { - bool __tmp = __x; - __x = __y; - __y = __tmp; - } - - - friend void - swap(_Bit_reference __x, bool& __y) noexcept - { - bool __tmp = __x; - __x = __y; - __y = __tmp; - } - - - friend void - swap(bool& __x, _Bit_reference __y) noexcept - { - bool __tmp = __x; - __x = __y; - __y = __tmp; - } - - }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - struct _Bit_iterator_base - : public std::iterator - { - _Bit_type * _M_p; - unsigned int _M_offset; - - - _Bit_iterator_base(_Bit_type * __x, unsigned int __y) - : _M_p(__x), _M_offset(__y) { } - - - void - _M_bump_up() - { - if (_M_offset++ == int(_S_word_bit) - 1) - { - _M_offset = 0; - ++_M_p; - } - } - - - void - _M_bump_down() - { - if (_M_offset-- == 0) - { - _M_offset = int(_S_word_bit) - 1; - --_M_p; - } - } - - - void - _M_incr(ptrdiff_t __i) - { - difference_type __n = __i + _M_offset; - _M_p += __n / int(_S_word_bit); - __n = __n % int(_S_word_bit); - if (__n < 0) - { - __n += int(_S_word_bit); - --_M_p; - } - _M_offset = static_cast(__n); - } - - [[__nodiscard__]] - friend bool - operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; } -# 237 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - [[__nodiscard__]] - friend bool - operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { - return __x._M_p < __y._M_p - || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset); - } - - [[__nodiscard__]] - friend bool - operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return !(__x == __y); } - - [[__nodiscard__]] - friend bool - operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return __y < __x; } - - [[__nodiscard__]] - friend bool - operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return !(__y < __x); } - - [[__nodiscard__]] - friend bool - operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return !(__x < __y); } - - - friend ptrdiff_t - operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { - return (int(_S_word_bit) * (__x._M_p - __y._M_p) - + __x._M_offset - __y._M_offset); - } - }; -#pragma GCC diagnostic pop - - struct _Bit_iterator : public _Bit_iterator_base - { - typedef _Bit_reference reference; - - - - typedef _Bit_reference* pointer; - - typedef _Bit_iterator iterator; - - - _Bit_iterator() : _Bit_iterator_base(0, 0) { } - - - _Bit_iterator(_Bit_type * __x, unsigned int __y) - : _Bit_iterator_base(__x, __y) { } - - - iterator - _M_const_cast() const - { return *this; } - - [[__nodiscard__]] - reference - operator*() const - { return reference(_M_p, 1UL << _M_offset); } - - - iterator& - operator++() - { - _M_bump_up(); - return *this; - } - - - iterator - operator++(int) - { - iterator __tmp = *this; - _M_bump_up(); - return __tmp; - } - - - iterator& - operator--() - { - _M_bump_down(); - return *this; - } - - - iterator - operator--(int) - { - iterator __tmp = *this; - _M_bump_down(); - return __tmp; - } - - - iterator& - operator+=(difference_type __i) - { - _M_incr(__i); - return *this; - } - - - iterator& - operator-=(difference_type __i) - { - *this += -__i; - return *this; - } - - [[__nodiscard__]] - reference - operator[](difference_type __i) const - { return *(*this + __i); } - - [[__nodiscard__]] - friend iterator - operator+(const iterator& __x, difference_type __n) - { - iterator __tmp = __x; - __tmp += __n; - return __tmp; - } - - [[__nodiscard__]] - friend iterator - operator+(difference_type __n, const iterator& __x) - { return __x + __n; } - - [[__nodiscard__]] - friend iterator - operator-(const iterator& __x, difference_type __n) - { - iterator __tmp = __x; - __tmp -= __n; - return __tmp; - } - }; - - struct _Bit_const_iterator : public _Bit_iterator_base - { - typedef bool reference; - typedef bool const_reference; - - - - typedef const bool* pointer; - - typedef _Bit_const_iterator const_iterator; - - - _Bit_const_iterator() : _Bit_iterator_base(0, 0) { } - - - _Bit_const_iterator(_Bit_type * __x, unsigned int __y) - : _Bit_iterator_base(__x, __y) { } - - - _Bit_const_iterator(const _Bit_iterator& __x) - : _Bit_iterator_base(__x._M_p, __x._M_offset) { } - - - _Bit_iterator - _M_const_cast() const - { return _Bit_iterator(_M_p, _M_offset); } - - [[__nodiscard__]] - const_reference - operator*() const - { return _Bit_reference(_M_p, 1UL << _M_offset); } - - - const_iterator& - operator++() - { - _M_bump_up(); - return *this; - } - - - const_iterator - operator++(int) - { - const_iterator __tmp = *this; - _M_bump_up(); - return __tmp; - } - - - const_iterator& - operator--() - { - _M_bump_down(); - return *this; - } - - - const_iterator - operator--(int) - { - const_iterator __tmp = *this; - _M_bump_down(); - return __tmp; - } - - - const_iterator& - operator+=(difference_type __i) - { - _M_incr(__i); - return *this; - } - - - const_iterator& - operator-=(difference_type __i) - { - *this += -__i; - return *this; - } - - [[__nodiscard__]] - const_reference - operator[](difference_type __i) const - { return *(*this + __i); } - - [[__nodiscard__]] - friend const_iterator - operator+(const const_iterator& __x, difference_type __n) - { - const_iterator __tmp = __x; - __tmp += __n; - return __tmp; - } - - [[__nodiscard__]] - friend const_iterator - operator-(const const_iterator& __x, difference_type __n) - { - const_iterator __tmp = __x; - __tmp -= __n; - return __tmp; - } - - [[__nodiscard__]] - friend const_iterator - operator+(difference_type __n, const const_iterator& __x) - { return __x + __n; } - }; - - template - struct _Bvector_base - { - typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template - rebind<_Bit_type>::other _Bit_alloc_type; - typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type> - _Bit_alloc_traits; - typedef typename _Bit_alloc_traits::pointer _Bit_pointer; - - struct _Bvector_impl_data - { - - _Bit_iterator _M_start; -# 514 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - _Bit_iterator _M_finish; - _Bit_pointer _M_end_of_storage; - - - _Bvector_impl_data() noexcept - : _M_start(), _M_finish(), _M_end_of_storage() - { } - - - _Bvector_impl_data(const _Bvector_impl_data&) = default; - - _Bvector_impl_data& - operator=(const _Bvector_impl_data&) = default; - - - _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept - : _Bvector_impl_data(__x) - { __x._M_reset(); } - - - void - _M_move_data(_Bvector_impl_data&& __x) noexcept - { - *this = __x; - __x._M_reset(); - } - - - - void - _M_reset() noexcept - { *this = _Bvector_impl_data(); } - - - void - _M_swap_data(_Bvector_impl_data& __x) noexcept - { - - - std::swap(*this, __x); - } - }; - - struct _Bvector_impl - : public _Bit_alloc_type, public _Bvector_impl_data - { - - _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value) - - : _Bit_alloc_type() - { } - - - _Bvector_impl(const _Bit_alloc_type& __a) noexcept - : _Bit_alloc_type(__a) - { } - - - - - - _Bvector_impl(_Bvector_impl&& __x) noexcept - : _Bit_alloc_type(std::move(__x)), _Bvector_impl_data(std::move(__x)) - { } - - - _Bvector_impl(_Bit_alloc_type&& __a, _Bvector_impl&& __x) noexcept - : _Bit_alloc_type(std::move(__a)), _Bvector_impl_data(std::move(__x)) - { } - - - - _Bit_type* - _M_end_addr() const noexcept - { - if (this->_M_end_of_storage) - return std::__addressof(this->_M_end_of_storage[-1]) + 1; - return 0; - } - }; - - public: - typedef _Alloc allocator_type; - - - _Bit_alloc_type& - _M_get_Bit_allocator() noexcept - { return this->_M_impl; } - - - const _Bit_alloc_type& - _M_get_Bit_allocator() const noexcept - { return this->_M_impl; } - - - allocator_type - get_allocator() const noexcept - { return allocator_type(_M_get_Bit_allocator()); } - - - _Bvector_base() = default; - - - - - - _Bvector_base(const allocator_type& __a) - : _M_impl(__a) { } - - - _Bvector_base(_Bvector_base&&) = default; - - - _Bvector_base(_Bvector_base&& __x, const allocator_type& __a) noexcept - : _M_impl(_Bit_alloc_type(__a), std::move(__x._M_impl)) - { } - - - - ~_Bvector_base() - { this->_M_deallocate(); } - - protected: - _Bvector_impl _M_impl; - - - _Bit_pointer - _M_allocate(size_t __n) - { - _Bit_pointer __p = _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); -# 652 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - return __p; - } - - - void - _M_deallocate() - { - if (_M_impl._M_start._M_p) - { - const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p; - _Bit_alloc_traits::deallocate(_M_impl, - _M_impl._M_end_of_storage - __n, - __n); - _M_impl._M_reset(); - } - } - - - - void - _M_move_data(_Bvector_base&& __x) noexcept - { _M_impl._M_move_data(std::move(__x._M_impl)); } - - - constexpr - static size_t - _S_nword(size_t __n) - { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); } - }; -# 703 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - template - class vector : protected _Bvector_base<_Alloc> - { - typedef _Bvector_base<_Alloc> _Base; - typedef typename _Base::_Bit_pointer _Bit_pointer; - typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits; - - - friend struct std::hash; - - - public: - typedef bool value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Bit_reference reference; - typedef bool const_reference; - typedef _Bit_reference* pointer; - typedef const bool* const_pointer; - typedef _Bit_iterator iterator; - typedef _Bit_const_iterator const_iterator; - typedef std::reverse_iterator const_reverse_iterator; - typedef std::reverse_iterator reverse_iterator; - typedef _Alloc allocator_type; - - - allocator_type - get_allocator() const - { return _Base::get_allocator(); } - - protected: - using _Base::_M_allocate; - using _Base::_M_deallocate; - using _Base::_S_nword; - using _Base::_M_get_Bit_allocator; - - public: - - vector() = default; - - - - - - explicit - vector(const allocator_type& __a) - : _Base(__a) { } - - - - explicit - vector(size_type __n, const allocator_type& __a = allocator_type()) - : vector(__n, false, __a) - { } - - - vector(size_type __n, const bool& __value, - const allocator_type& __a = allocator_type()) - - - - - - : _Base(__a) - { - _M_initialize(__n); - _M_initialize_value(__value); - } - - - vector(const vector& __x) - : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator())) - { - const_iterator __xbegin = __x.begin(), __xend = __x.end(); - _M_initialize(__x.size()); - _M_copy_aligned(__xbegin, __xend, begin()); - } - - - vector(vector&&) = default; - - private: - - vector(vector&& __x, const allocator_type& __a, true_type) noexcept - : _Base(std::move(__x), __a) - { } - - - vector(vector&& __x, const allocator_type& __a, false_type) - : _Base(__a) - { - if (__x.get_allocator() == __a) - this->_M_move_data(std::move(__x)); - else - { - _M_initialize(__x.size()); - _M_copy_aligned(__x.begin(), __x.end(), begin()); - __x.clear(); - } - } - - public: - - vector(vector&& __x, const __type_identity_t& __a) - noexcept(_Bit_alloc_traits::_S_always_equal()) - : vector(std::move(__x), __a, - typename _Bit_alloc_traits::is_always_equal{}) - { } - - - vector(const vector& __x, const __type_identity_t& __a) - : _Base(__a) - { - _M_initialize(__x.size()); - _M_copy_aligned(__x.begin(), __x.end(), begin()); - } - - - vector(initializer_list __l, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { - _M_initialize_range(__l.begin(), __l.end(), - random_access_iterator_tag()); - } - - - - template> - - vector(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { - _M_initialize_range(__first, __last, - std::__iterator_category(__first)); - } -# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - ~vector() noexcept { } - - - vector& - operator=(const vector& __x) - { - if (&__x == this) - return *this; - - if (_Bit_alloc_traits::_S_propagate_on_copy_assign()) - { - if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator()) - { - this->_M_deallocate(); - std::__alloc_on_copy(_M_get_Bit_allocator(), - __x._M_get_Bit_allocator()); - _M_initialize(__x.size()); - } - else - std::__alloc_on_copy(_M_get_Bit_allocator(), - __x._M_get_Bit_allocator()); - } - - if (__x.size() > capacity()) - { - this->_M_deallocate(); - _M_initialize(__x.size()); - } - this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), - begin()); - return *this; - } - - - - vector& - operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move()) - { - if (_Bit_alloc_traits::_S_propagate_on_move_assign() - || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator()) - { - this->_M_deallocate(); - this->_M_move_data(std::move(__x)); - std::__alloc_on_move(_M_get_Bit_allocator(), - __x._M_get_Bit_allocator()); - } - else - { - if (__x.size() > capacity()) - { - this->_M_deallocate(); - _M_initialize(__x.size()); - } - this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), - begin()); - __x.clear(); - } - return *this; - } - - - vector& - operator=(initializer_list __l) - { - this->assign(__l.begin(), __l.end()); - return *this; - } - - - - - - - - void - assign(size_type __n, const bool& __x) - { _M_fill_assign(__n, __x); } - - - template> - - void - assign(_InputIterator __first, _InputIterator __last) - { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } -# 952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - void - assign(initializer_list __l) - { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); } - - - [[__nodiscard__]] - iterator - begin() noexcept - { return iterator(this->_M_impl._M_start._M_p, 0); } - - [[__nodiscard__]] - const_iterator - begin() const noexcept - { return const_iterator(this->_M_impl._M_start._M_p, 0); } - - [[__nodiscard__]] - iterator - end() noexcept - { return this->_M_impl._M_finish; } - - [[__nodiscard__]] - const_iterator - end() const noexcept - { return this->_M_impl._M_finish; } - - [[__nodiscard__]] - reverse_iterator - rbegin() noexcept - { return reverse_iterator(end()); } - - [[__nodiscard__]] - const_reverse_iterator - rbegin() const noexcept - { return const_reverse_iterator(end()); } - - [[__nodiscard__]] - reverse_iterator - rend() noexcept - { return reverse_iterator(begin()); } - - [[__nodiscard__]] - const_reverse_iterator - rend() const noexcept - { return const_reverse_iterator(begin()); } - - - [[__nodiscard__]] - const_iterator - cbegin() const noexcept - { return const_iterator(this->_M_impl._M_start._M_p, 0); } - - [[__nodiscard__]] - const_iterator - cend() const noexcept - { return this->_M_impl._M_finish; } - - [[__nodiscard__]] - const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(end()); } - - [[__nodiscard__]] - const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(begin()); } - - - [[__nodiscard__]] - size_type - size() const noexcept - { return size_type(end() - begin()); } - - [[__nodiscard__]] - size_type - max_size() const noexcept - { - const size_type __isize = - __gnu_cxx::__numeric_traits::__max - - int(_S_word_bit) + 1; - const size_type __asize - = _Bit_alloc_traits::max_size(_M_get_Bit_allocator()); - return (__asize <= __isize / int(_S_word_bit) - ? __asize * int(_S_word_bit) : __isize); - } - - [[__nodiscard__]] - size_type - capacity() const noexcept - { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0) - - begin()); } - - [[__nodiscard__]] - bool - empty() const noexcept - { return begin() == end(); } - - [[__nodiscard__]] - reference - operator[](size_type __n) - { return begin()[__n]; } - - [[__nodiscard__]] - const_reference - operator[](size_type __n) const - { return begin()[__n]; } - - protected: - - void - _M_range_check(size_type __n) const - { - if (__n >= this->size()) - __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"), - - - __n, this->size()); - } - - public: - - reference - at(size_type __n) - { - _M_range_check(__n); - return (*this)[__n]; - } - - - const_reference - at(size_type __n) const - { - _M_range_check(__n); - return (*this)[__n]; - } - - - void - reserve(size_type __n) - { - if (__n > max_size()) - __throw_length_error(("vector::reserve")); - if (capacity() < __n) - _M_reallocate(__n); - } - - [[__nodiscard__]] - reference - front() - { return *begin(); } - - [[__nodiscard__]] - const_reference - front() const - { return *begin(); } - - [[__nodiscard__]] - reference - back() - { return *(end() - 1); } - - [[__nodiscard__]] - const_reference - back() const - { return *(end() - 1); } - - - void - push_back(bool __x) - { - if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) - *this->_M_impl._M_finish++ = __x; - else - _M_insert_aux(end(), __x); - } - - - void - swap(vector& __x) noexcept - { - - do { if (std::__is_constant_evaluated() && !bool(_Bit_alloc_traits::propagate_on_container_swap::value || _M_get_Bit_allocator() == __x._M_get_Bit_allocator())) __builtin_unreachable(); } while (false); - - - this->_M_impl._M_swap_data(__x._M_impl); - _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(), - __x._M_get_Bit_allocator()); - } - - - - static void - swap(reference __x, reference __y) noexcept - { - bool __tmp = __x; - __x = __y; - __y = __tmp; - } - - - iterator - - insert(const_iterator __position, const bool& __x) - - - - { - const difference_type __n = __position - begin(); - if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr() - && __position == end()) - *this->_M_impl._M_finish++ = __x; - else - _M_insert_aux(__position._M_const_cast(), __x); - return begin() + __n; - } - - - __attribute__ ((__deprecated__ ("use '" "insert(position, false)" "' instead"))) - iterator - insert(const_iterator __position) - { return this->insert(__position._M_const_cast(), false); } - - - - template> - - iterator - insert(const_iterator __position, - _InputIterator __first, _InputIterator __last) - { - difference_type __offset = __position - cbegin(); - _M_insert_range(__position._M_const_cast(), - __first, __last, - std::__iterator_category(__first)); - return begin() + __offset; - } -# 1202 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - iterator - insert(const_iterator __position, size_type __n, const bool& __x) - { - difference_type __offset = __position - cbegin(); - _M_fill_insert(__position._M_const_cast(), __n, __x); - return begin() + __offset; - } -# 1217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - iterator - insert(const_iterator __p, initializer_list __l) - { return this->insert(__p, __l.begin(), __l.end()); } - - - - void - pop_back() - { --this->_M_impl._M_finish; } - - - iterator - - erase(const_iterator __position) - - - - { return _M_erase(__position._M_const_cast()); } - - - iterator - - erase(const_iterator __first, const_iterator __last) - - - - { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } - - - void - resize(size_type __new_size, bool __x = bool()) - { - if (__new_size < size()) - _M_erase_at_end(begin() + difference_type(__new_size)); - else - insert(end(), __new_size - size(), __x); - } - - - - void - shrink_to_fit() - { _M_shrink_to_fit(); } - - - - void - flip() noexcept - { - _Bit_type * const __end = this->_M_impl._M_end_addr(); - for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p) - *__p = ~*__p; - } - - - void - clear() noexcept - { _M_erase_at_end(begin()); } - - - template - - - reference - - - - emplace_back(_Args&&... __args) - { - push_back(bool(__args...)); - - return back(); - - } - - template - - iterator - emplace(const_iterator __pos, _Args&&... __args) - { return insert(__pos, bool(__args...)); } - - - protected: - - - iterator - _M_copy_aligned(const_iterator __first, const_iterator __last, - iterator __result) - { - _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p); - return std::copy(const_iterator(__last._M_p, 0), __last, - iterator(__q, 0)); - } - - - void - _M_initialize(size_type __n) - { - if (__n) - { - _Bit_pointer __q = this->_M_allocate(__n); - this->_M_impl._M_end_of_storage = __q + _S_nword(__n); - iterator __start = iterator(std::__addressof(*__q), 0); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __start + difference_type(__n); - } - } - - - void - _M_initialize_value(bool __x) noexcept - { - if (_Bit_type* __p = this->_M_impl._M_start._M_p) - __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x); - } - - - void - _M_reallocate(size_type __n); - - - - bool - _M_shrink_to_fit(); -# 1362 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - template - - void - _M_initialize_range(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag) - { - for (; __first != __last; ++__first) - push_back(*__first); - } - - template - - void - _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag) - { - const size_type __n = std::distance(__first, __last); - _M_initialize(__n); - std::copy(__first, __last, begin()); - } -# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - void - _M_fill_assign(size_t __n, bool __x) - { - if (__n > size()) - { - _M_initialize_value(__x); - insert(end(), __n - size(), __x); - } - else - { - _M_erase_at_end(begin() + __n); - _M_initialize_value(__x); - } - } - - template - - void - _M_assign_aux(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag) - { - iterator __cur = begin(); - for (; __first != __last && __cur != end(); ++__cur, (void)++__first) - *__cur = *__first; - if (__first == __last) - _M_erase_at_end(__cur); - else - insert(end(), __first, __last); - } - - template - - void - _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag) - { - const size_type __len = std::distance(__first, __last); - if (__len < size()) - _M_erase_at_end(std::copy(__first, __last, begin())); - else - { - _ForwardIterator __mid = __first; - std::advance(__mid, size()); - std::copy(__first, __mid, begin()); - insert(end(), __mid, __last); - } - } -# 1466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - void - _M_fill_insert(iterator __position, size_type __n, bool __x); - - template - - void - _M_insert_range(iterator __pos, _InputIterator __first, - _InputIterator __last, std::input_iterator_tag) - { - for (; __first != __last; ++__first) - { - __pos = insert(__pos, *__first); - ++__pos; - } - } - - template - - void - _M_insert_range(iterator __position, _ForwardIterator __first, - _ForwardIterator __last, std::forward_iterator_tag); - - - void - _M_insert_aux(iterator __position, bool __x); - - - size_type - _M_check_len(size_type __n, const char* __s) const - { - if (max_size() - size() < __n) - __throw_length_error((__s)); - - const size_type __len = size() + std::max(size(), __n); - return (__len < size() || __len > max_size()) ? max_size() : __len; - } - - - void - _M_erase_at_end(iterator __pos) - { this->_M_impl._M_finish = __pos; } - - - iterator - _M_erase(iterator __pos); - - - iterator - _M_erase(iterator __first, iterator __last); - - protected: - - - - - - - void data() = delete; - - - - }; - - - - - - inline void - __fill_bvector(_Bit_type* __v, unsigned int __first, unsigned int __last, - bool __x) noexcept - { - const _Bit_type __fmask = ~0ul << __first; - const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last); - const _Bit_type __mask = __fmask & __lmask; - - if (__x) - *__v |= __mask; - else - *__v &= ~__mask; - } - - - __attribute__((__nonnull__)) - - inline void - __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) noexcept - { -# 1561 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type)); - } - - - - inline void - __fill_a1(std::_Bit_iterator __first, - std::_Bit_iterator __last, const bool& __x) - { - if (__first._M_p != __last._M_p) - { - _Bit_type* __first_p = __first._M_p; - if (__first._M_offset != 0) - __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x); - - __fill_bvector_n(__first_p, __last._M_p - __first_p, __x); - - if (__last._M_offset != 0) - __fill_bvector(__last._M_p, 0, __last._M_offset, __x); - } - else if (__first._M_offset != __last._M_offset) - __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x); - } - - - - - template - struct hash> - : public __hash_base> - { - size_t - operator()(const std::vector&) const noexcept; - }; - - - -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/vector.tcc" 1 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/vector.tcc" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - - void - vector<_Tp, _Alloc>:: - reserve(size_type __n) - { - if (__n > this->max_size()) - __throw_length_error(("vector::reserve")); - if (this->capacity() < __n) - { - const size_type __old_size = size(); - pointer __tmp; - - if constexpr (_S_use_relocate()) - { - __tmp = this->_M_allocate(__n); - _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish, - __tmp, _M_get_Tp_allocator()); - } - else - - { - __tmp = _M_allocate_and_copy(__n, - std::__make_move_if_noexcept_iterator(this->_M_impl._M_start), - std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish)); - std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - } - ; - _M_deallocate(this->_M_impl._M_start, - this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); - this->_M_impl._M_start = __tmp; - this->_M_impl._M_finish = __tmp + __old_size; - this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; - } - } - - - template - template - - - typename vector<_Tp, _Alloc>::reference - - - - vector<_Tp, _Alloc>:: - emplace_back(_Args&&... __args) - { - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - std::forward<_Args>(__args)...); - ++this->_M_impl._M_finish; - ; - } - else - _M_realloc_insert(end(), std::forward<_Args>(__args)...); - - return back(); - - } - - - template - - typename vector<_Tp, _Alloc>::iterator - vector<_Tp, _Alloc>:: - - insert(const_iterator __position, const value_type& __x) - - - - { - const size_type __n = __position - begin(); - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - { - do { if (std::__is_constant_evaluated() && !bool(__position != const_iterator())) __builtin_unreachable(); } while (false); - if (!(__position != const_iterator())) - __builtin_unreachable(); - - if (__position == end()) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - __x); - ++this->_M_impl._M_finish; - ; - } - else - { - - const auto __pos = begin() + (__position - cbegin()); - - - _Temporary_value __x_copy(this, __x); - _M_insert_aux(__pos, std::move(__x_copy._M_val())); - - - - } - } - else - - _M_realloc_insert(begin() + (__position - cbegin()), __x); - - - - - return iterator(this->_M_impl._M_start + __n); - } - - template - - typename vector<_Tp, _Alloc>::iterator - vector<_Tp, _Alloc>:: - _M_erase(iterator __position) - { - if (__position + 1 != end()) - std::move(__position + 1, end(), __position); - --this->_M_impl._M_finish; - _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); - ; - return __position; - } - - template - - typename vector<_Tp, _Alloc>::iterator - vector<_Tp, _Alloc>:: - _M_erase(iterator __first, iterator __last) - { - if (__first != __last) - { - if (__last != end()) - std::move(__last, end(), __first); - _M_erase_at_end(__first.base() + (end() - __last)); - } - return __first; - } - - template - - vector<_Tp, _Alloc>& - vector<_Tp, _Alloc>:: - operator=(const vector<_Tp, _Alloc>& __x) - { - if (std::__addressof(__x) != this) - { - ; - - if (_Alloc_traits::_S_propagate_on_copy_assign()) - { - if (!_Alloc_traits::_S_always_equal() - && _M_get_Tp_allocator() != __x._M_get_Tp_allocator()) - { - - this->clear(); - _M_deallocate(this->_M_impl._M_start, - this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); - this->_M_impl._M_start = nullptr; - this->_M_impl._M_finish = nullptr; - this->_M_impl._M_end_of_storage = nullptr; - } - std::__alloc_on_copy(_M_get_Tp_allocator(), - __x._M_get_Tp_allocator()); - } - - const size_type __xlen = __x.size(); - if (__xlen > capacity()) - { - pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), - __x.end()); - std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - _M_deallocate(this->_M_impl._M_start, - this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); - this->_M_impl._M_start = __tmp; - this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen; - } - else if (size() >= __xlen) - { - std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), - end(), _M_get_Tp_allocator()); - } - else - { - std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(), - this->_M_impl._M_start); - std::__uninitialized_copy_a(__x._M_impl._M_start + size(), - __x._M_impl._M_finish, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - } - this->_M_impl._M_finish = this->_M_impl._M_start + __xlen; - } - return *this; - } - - template - - void - vector<_Tp, _Alloc>:: - _M_fill_assign(size_t __n, const value_type& __val) - { - if (__n > capacity()) - { - vector __tmp(__n, __val, _M_get_Tp_allocator()); - __tmp._M_impl._M_swap_data(this->_M_impl); - } - else if (__n > size()) - { - std::fill(begin(), end(), __val); - const size_type __add = __n - size(); - ; - this->_M_impl._M_finish = - std::__uninitialized_fill_n_a(this->_M_impl._M_finish, - __add, __val, _M_get_Tp_allocator()); - ; - } - else - _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val)); - } - - template - template - - void - vector<_Tp, _Alloc>:: - _M_assign_aux(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag) - { - pointer __cur(this->_M_impl._M_start); - for (; __first != __last && __cur != this->_M_impl._M_finish; - ++__cur, (void)++__first) - *__cur = *__first; - if (__first == __last) - _M_erase_at_end(__cur); - else - _M_range_insert(end(), __first, __last, - std::__iterator_category(__first)); - } - - template - template - - void - vector<_Tp, _Alloc>:: - _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag) - { - const size_type __len = std::distance(__first, __last); - - if (__len > capacity()) - { - _S_check_init_len(__len, _M_get_Tp_allocator()); - pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); - std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - ; - _M_deallocate(this->_M_impl._M_start, - this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); - this->_M_impl._M_start = __tmp; - this->_M_impl._M_finish = this->_M_impl._M_start + __len; - this->_M_impl._M_end_of_storage = this->_M_impl._M_finish; - } - else if (size() >= __len) - _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); - else - { - _ForwardIterator __mid = __first; - std::advance(__mid, size()); - std::copy(__first, __mid, this->_M_impl._M_start); - const size_type __attribute__((__unused__)) __n = __len - size(); - ; - this->_M_impl._M_finish = - std::__uninitialized_copy_a(__mid, __last, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - ; - } - } - - - template - - auto - vector<_Tp, _Alloc>:: - _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator - { - const auto __n = __position - cbegin(); - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - if (__position == cend()) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - std::move(__v)); - ++this->_M_impl._M_finish; - ; - } - else - _M_insert_aux(begin() + __n, std::move(__v)); - else - _M_realloc_insert(begin() + __n, std::move(__v)); - - return iterator(this->_M_impl._M_start + __n); - } - - template - template - - auto - vector<_Tp, _Alloc>:: - _M_emplace_aux(const_iterator __position, _Args&&... __args) - -> iterator - { - const auto __n = __position - cbegin(); - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - if (__position == cend()) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - std::forward<_Args>(__args)...); - ++this->_M_impl._M_finish; - ; - } - else - { - - - - _Temporary_value __tmp(this, std::forward<_Args>(__args)...); - _M_insert_aux(begin() + __n, std::move(__tmp._M_val())); - } - else - _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...); - - return iterator(this->_M_impl._M_start + __n); - } - - template - template - - void - vector<_Tp, _Alloc>:: - _M_insert_aux(iterator __position, _Arg&& __arg) - - - - - - - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - std::move(*(this->_M_impl._M_finish - 1))); - ++this->_M_impl._M_finish; - ; - - - - std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1); - - - - - - *__position = std::forward<_Arg>(__arg); - - } - - - template - template - - void - vector<_Tp, _Alloc>:: - _M_realloc_insert(iterator __position, _Args&&... __args) - - - - - - - { - const size_type __len = - _M_check_len(size_type(1), "vector::_M_realloc_insert"); - pointer __old_start = this->_M_impl._M_start; - pointer __old_finish = this->_M_impl._M_finish; - const size_type __elems_before = __position - begin(); - pointer __new_start(this->_M_allocate(__len)); - pointer __new_finish(__new_start); - try - { - - - - - - _Alloc_traits::construct(this->_M_impl, - __new_start + __elems_before, - - std::forward<_Args>(__args)...); - - - - __new_finish = pointer(); - - - if constexpr (_S_use_relocate()) - { - __new_finish = _S_relocate(__old_start, __position.base(), - __new_start, _M_get_Tp_allocator()); - - ++__new_finish; - - __new_finish = _S_relocate(__position.base(), __old_finish, - __new_finish, _M_get_Tp_allocator()); - } - else - - { - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__old_start, __position.base(), - __new_start, _M_get_Tp_allocator()); - - ++__new_finish; - - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__position.base(), __old_finish, - __new_finish, _M_get_Tp_allocator()); - } - } - catch(...) - { - if (!__new_finish) - _Alloc_traits::destroy(this->_M_impl, - __new_start + __elems_before); - else - std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); - _M_deallocate(__new_start, __len); - throw; - } - - if constexpr (!_S_use_relocate()) - - std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); - ; - _M_deallocate(__old_start, - this->_M_impl._M_end_of_storage - __old_start); - this->_M_impl._M_start = __new_start; - this->_M_impl._M_finish = __new_finish; - this->_M_impl._M_end_of_storage = __new_start + __len; - } - - template - - void - vector<_Tp, _Alloc>:: - _M_fill_insert(iterator __position, size_type __n, const value_type& __x) - { - if (__n != 0) - { - if (size_type(this->_M_impl._M_end_of_storage - - this->_M_impl._M_finish) >= __n) - { - - - - _Temporary_value __tmp(this, __x); - value_type& __x_copy = __tmp._M_val(); - - const size_type __elems_after = end() - __position; - pointer __old_finish(this->_M_impl._M_finish); - if (__elems_after > __n) - { - ; - std::__uninitialized_move_a(__old_finish - __n, - __old_finish, - __old_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __n; - ; - std::move_backward(__position.base(), __old_finish - __n, __old_finish); - - std::fill(__position.base(), __position.base() + __n, - __x_copy); - } - else - { - ; - this->_M_impl._M_finish = - std::__uninitialized_fill_n_a(__old_finish, - __n - __elems_after, - __x_copy, - _M_get_Tp_allocator()); - ; - std::__uninitialized_move_a(__position.base(), __old_finish, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __elems_after; - ; - std::fill(__position.base(), __old_finish, __x_copy); - } - } - else - { - - - pointer __old_start = this->_M_impl._M_start; - pointer __old_finish = this->_M_impl._M_finish; - const pointer __pos = __position.base(); - - const size_type __len = - _M_check_len(__n, "vector::_M_fill_insert"); - const size_type __elems_before = __pos - __old_start; - pointer __new_start(this->_M_allocate(__len)); - pointer __new_finish(__new_start); - try - { - - std::__uninitialized_fill_n_a(__new_start + __elems_before, - __n, __x, - _M_get_Tp_allocator()); - __new_finish = pointer(); - - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__old_start, __pos, __new_start, _M_get_Tp_allocator()); - - __new_finish += __n; - - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__pos, __old_finish, __new_finish, _M_get_Tp_allocator()); - } - catch(...) - { - if (!__new_finish) - std::_Destroy(__new_start + __elems_before, - __new_start + __elems_before + __n, - _M_get_Tp_allocator()); - else - std::_Destroy(__new_start, __new_finish, - _M_get_Tp_allocator()); - _M_deallocate(__new_start, __len); - throw; - } - std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); - ; - _M_deallocate(__old_start, - this->_M_impl._M_end_of_storage - __old_start); - this->_M_impl._M_start = __new_start; - this->_M_impl._M_finish = __new_finish; - this->_M_impl._M_end_of_storage = __new_start + __len; - } - } - } - - - template - - void - vector<_Tp, _Alloc>:: - _M_default_append(size_type __n) - { - if (__n != 0) - { - const size_type __size = size(); - size_type __navail = size_type(this->_M_impl._M_end_of_storage - - this->_M_impl._M_finish); - - if (__size > max_size() || __navail > max_size() - __size) - __builtin_unreachable(); - - if (__navail >= __n) - { - ; - this->_M_impl._M_finish = - std::__uninitialized_default_n_a(this->_M_impl._M_finish, - __n, _M_get_Tp_allocator()); - ; - } - else - { - - - pointer __old_start = this->_M_impl._M_start; - pointer __old_finish = this->_M_impl._M_finish; - - const size_type __len = - _M_check_len(__n, "vector::_M_default_append"); - pointer __new_start(this->_M_allocate(__len)); - if constexpr (_S_use_relocate()) - { - try - { - std::__uninitialized_default_n_a(__new_start + __size, - __n, _M_get_Tp_allocator()); - } - catch(...) - { - _M_deallocate(__new_start, __len); - throw; - } - _S_relocate(__old_start, __old_finish, - __new_start, _M_get_Tp_allocator()); - } - else - { - pointer __destroy_from = pointer(); - try - { - std::__uninitialized_default_n_a(__new_start + __size, - __n, _M_get_Tp_allocator()); - __destroy_from = __new_start + __size; - std::__uninitialized_move_if_noexcept_a( - __old_start, __old_finish, - __new_start, _M_get_Tp_allocator()); - } - catch(...) - { - if (__destroy_from) - std::_Destroy(__destroy_from, __destroy_from + __n, - _M_get_Tp_allocator()); - _M_deallocate(__new_start, __len); - throw; - } - std::_Destroy(__old_start, __old_finish, - _M_get_Tp_allocator()); - } - ; - _M_deallocate(__old_start, - this->_M_impl._M_end_of_storage - __old_start); - this->_M_impl._M_start = __new_start; - this->_M_impl._M_finish = __new_start + __size + __n; - this->_M_impl._M_end_of_storage = __new_start + __len; - } - } - } - - template - - bool - vector<_Tp, _Alloc>:: - _M_shrink_to_fit() - { - if (capacity() == size()) - return false; - ; - return std::__shrink_to_fit_aux::_S_do_it(*this); - } - - - template - template - - void - vector<_Tp, _Alloc>:: - _M_range_insert(iterator __pos, _InputIterator __first, - _InputIterator __last, std::input_iterator_tag) - { - if (__pos == end()) - { - for (; __first != __last; ++__first) - insert(end(), *__first); - } - else if (__first != __last) - { - vector __tmp(__first, __last, _M_get_Tp_allocator()); - insert(__pos, - std::make_move_iterator(__tmp.begin()), - std::make_move_iterator(__tmp.end())); - } - } - - template - template - - void - vector<_Tp, _Alloc>:: - _M_range_insert(iterator __position, _ForwardIterator __first, - _ForwardIterator __last, std::forward_iterator_tag) - { - if (__first != __last) - { - const size_type __n = std::distance(__first, __last); - if (size_type(this->_M_impl._M_end_of_storage - - this->_M_impl._M_finish) >= __n) - { - const size_type __elems_after = end() - __position; - pointer __old_finish(this->_M_impl._M_finish); - if (__elems_after > __n) - { - ; - std::__uninitialized_move_a(this->_M_impl._M_finish - __n, - this->_M_impl._M_finish, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __n; - ; - std::move_backward(__position.base(), __old_finish - __n, __old_finish); - - std::copy(__first, __last, __position); - } - else - { - _ForwardIterator __mid = __first; - std::advance(__mid, __elems_after); - ; - std::__uninitialized_copy_a(__mid, __last, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __n - __elems_after; - ; - std::__uninitialized_move_a(__position.base(), - __old_finish, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __elems_after; - ; - std::copy(__first, __mid, __position); - } - } - else - { - - - - pointer __old_start = this->_M_impl._M_start; - pointer __old_finish = this->_M_impl._M_finish; - - const size_type __len = - _M_check_len(__n, "vector::_M_range_insert"); - pointer __new_start(this->_M_allocate(__len)); - pointer __new_finish(__new_start); - try - { - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__old_start, __position.base(), - __new_start, _M_get_Tp_allocator()); - __new_finish - = std::__uninitialized_copy_a(__first, __last, - __new_finish, - _M_get_Tp_allocator()); - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__position.base(), __old_finish, - __new_finish, _M_get_Tp_allocator()); - } - catch(...) - { - std::_Destroy(__new_start, __new_finish, - _M_get_Tp_allocator()); - _M_deallocate(__new_start, __len); - throw; - } - std::_Destroy(__old_start, __old_finish, - _M_get_Tp_allocator()); - ; - _M_deallocate(__old_start, - this->_M_impl._M_end_of_storage - __old_start); - this->_M_impl._M_start = __new_start; - this->_M_impl._M_finish = __new_finish; - this->_M_impl._M_end_of_storage = __new_start + __len; - } - } - } - - - - template - - void - vector:: - _M_reallocate(size_type __n) - { - _Bit_pointer __q = this->_M_allocate(__n); - iterator __start(std::__addressof(*__q), 0); - iterator __finish(_M_copy_aligned(begin(), end(), __start)); - this->_M_deallocate(); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __finish; - this->_M_impl._M_end_of_storage = __q + _S_nword(__n); - } - - template - - void - vector:: - _M_fill_insert(iterator __position, size_type __n, bool __x) - { - if (__n == 0) - return; - if (capacity() - size() >= __n) - { - std::copy_backward(__position, end(), - this->_M_impl._M_finish + difference_type(__n)); - std::fill(__position, __position + difference_type(__n), __x); - this->_M_impl._M_finish += difference_type(__n); - } - else - { - const size_type __len = - _M_check_len(__n, "vector::_M_fill_insert"); - _Bit_pointer __q = this->_M_allocate(__len); - iterator __start(std::__addressof(*__q), 0); - iterator __i = _M_copy_aligned(begin(), __position, __start); - std::fill(__i, __i + difference_type(__n), __x); - iterator __finish = std::copy(__position, end(), - __i + difference_type(__n)); - this->_M_deallocate(); - this->_M_impl._M_end_of_storage = __q + _S_nword(__len); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __finish; - } - } - - template - template - - void - vector:: - _M_insert_range(iterator __position, _ForwardIterator __first, - _ForwardIterator __last, std::forward_iterator_tag) - { - if (__first != __last) - { - size_type __n = std::distance(__first, __last); - if (capacity() - size() >= __n) - { - std::copy_backward(__position, end(), - this->_M_impl._M_finish - + difference_type(__n)); - std::copy(__first, __last, __position); - this->_M_impl._M_finish += difference_type(__n); - } - else - { - const size_type __len = - _M_check_len(__n, "vector::_M_insert_range"); - const iterator __begin = begin(), __end = end(); - _Bit_pointer __q = this->_M_allocate(__len); - iterator __start(std::__addressof(*__q), 0); - iterator __i = _M_copy_aligned(__begin, __position, __start); - __i = std::copy(__first, __last, __i); - iterator __finish = std::copy(__position, __end, __i); - this->_M_deallocate(); - this->_M_impl._M_end_of_storage = __q + _S_nword(__len); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __finish; - } - } - } - - template - - void - vector:: - _M_insert_aux(iterator __position, bool __x) - { - if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) - { - std::copy_backward(__position, this->_M_impl._M_finish, - this->_M_impl._M_finish + 1); - *__position = __x; - ++this->_M_impl._M_finish; - } - else - { - const size_type __len = - _M_check_len(size_type(1), "vector::_M_insert_aux"); - _Bit_pointer __q = this->_M_allocate(__len); - iterator __start(std::__addressof(*__q), 0); - iterator __i = _M_copy_aligned(begin(), __position, __start); - *__i++ = __x; - iterator __finish = std::copy(__position, end(), __i); - this->_M_deallocate(); - this->_M_impl._M_end_of_storage = __q + _S_nword(__len); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __finish; - } - } - - template - - typename vector::iterator - vector:: - _M_erase(iterator __position) - { - if (__position + 1 != end()) - std::copy(__position + 1, end(), __position); - --this->_M_impl._M_finish; - return __position; - } - - template - - typename vector::iterator - vector:: - _M_erase(iterator __first, iterator __last) - { - if (__first != __last) - _M_erase_at_end(std::copy(__last, end(), __first)); - return __first; - } - - - template - - bool - vector:: - _M_shrink_to_fit() - { - if (capacity() - size() < int(_S_word_bit)) - return false; - try - { - if (size_type __n = size()) - _M_reallocate(__n); - else - { - this->_M_deallocate(); - this->_M_impl._M_reset(); - } - return true; - } - catch(...) - { return false; } - } - - - - -} - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - size_t - hash>:: - operator()(const std::vector& __b) const noexcept - { - size_t __hash = 0; - const size_t __words = __b.size() / _S_word_bit; - if (__words) - { - const size_t __clength = __words * sizeof(_Bit_type); - __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength); - } - - const size_t __extrabits = __b.size() % _S_word_bit; - if (__extrabits) - { - _Bit_type __hiword = *__b._M_impl._M_finish._M_p; - __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits); - - const size_t __clength - = (__extrabits + 8 - 1) / 8; - if (__words) - __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash); - else - __hash = std::_Hash_impl::hash(&__hiword, __clength); - } - - return __hash; - } - - -} -# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 - - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 1 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 - - - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 -# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 2 3 - -extern "C++" -{ - -namespace std -{ - - using ::max_align_t; -} - - - -namespace std -{ - - - - - enum class byte : unsigned char {}; - - template struct __byte_operand { }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - - - - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; -# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - - template - using __byte_op_t = typename __byte_operand<_IntegerType>::__type; - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType> - operator<<(byte __b, _IntegerType __shift) noexcept - { return (byte)(unsigned char)((unsigned)__b << __shift); } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType> - operator>>(byte __b, _IntegerType __shift) noexcept - { return (byte)(unsigned char)((unsigned)__b >> __shift); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator|(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator&(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator^(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator~(byte __b) noexcept - { return (byte)(unsigned char)~(unsigned)__b; } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType>& - operator<<=(byte& __b, _IntegerType __shift) noexcept - { return __b = __b << __shift; } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType>& - operator>>=(byte& __b, _IntegerType __shift) noexcept - { return __b = __b >> __shift; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator|=(byte& __l, byte __r) noexcept - { return __l = __l | __r; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator&=(byte& __l, byte __r) noexcept - { return __l = __l & __r; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator^=(byte& __l, byte __r) noexcept - { return __l = __l ^ __r; } - - template - [[nodiscard,__gnu__::__always_inline__]] - constexpr _IntegerType - to_integer(__byte_op_t<_IntegerType> __b) noexcept - { return _IntegerType(__b); } - - -} - -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 - - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - -namespace pmr -{ - - - - - - - class memory_resource - { - static constexpr size_t _S_max_align = alignof(max_align_t); - - public: - memory_resource() = default; - memory_resource(const memory_resource&) = default; - virtual ~memory_resource(); - - memory_resource& operator=(const memory_resource&) = default; - - [[nodiscard]] - void* - allocate(size_t __bytes, size_t __alignment = _S_max_align) - __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3))) - { return ::operator new(__bytes, do_allocate(__bytes, __alignment)); } - - void - deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align) - __attribute__((__nonnull__)) - { return do_deallocate(__p, __bytes, __alignment); } - - [[nodiscard]] - bool - is_equal(const memory_resource& __other) const noexcept - { return do_is_equal(__other); } - - private: - virtual void* - do_allocate(size_t __bytes, size_t __alignment) = 0; - - virtual void - do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0; - - virtual bool - do_is_equal(const memory_resource& __other) const noexcept = 0; - }; - - [[nodiscard]] - inline bool - operator==(const memory_resource& __a, const memory_resource& __b) noexcept - { return &__a == &__b || __a.is_equal(__b); } - - - [[nodiscard]] - inline bool - operator!=(const memory_resource& __a, const memory_resource& __b) noexcept - { return !(__a == __b); } -# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - class polymorphic_allocator - { - - - template - struct __not_pair { using type = void; }; - - template - struct __not_pair> { }; - - public: - using value_type = _Tp; - - polymorphic_allocator() noexcept - { - extern memory_resource* get_default_resource() noexcept - __attribute__((__returns_nonnull__)); - _M_resource = get_default_resource(); - } - - polymorphic_allocator(memory_resource* __r) noexcept - __attribute__((__nonnull__)) - : _M_resource(__r) - { ; } - - polymorphic_allocator(const polymorphic_allocator& __other) = default; - - template - polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept - : _M_resource(__x.resource()) - { } - - polymorphic_allocator& - operator=(const polymorphic_allocator&) = delete; - - [[nodiscard]] - _Tp* - allocate(size_t __n) - __attribute__((__returns_nonnull__)) - { - if ((__gnu_cxx::__int_traits::__max / sizeof(_Tp)) < __n) - std::__throw_bad_array_new_length(); - return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp), - alignof(_Tp))); - } - - void - deallocate(_Tp* __p, size_t __n) noexcept - __attribute__((__nonnull__)) - { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); } -# 224 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - __attribute__((__nonnull__)) - typename __not_pair<_Tp1>::type - construct(_Tp1* __p, _Args&&... __args) - { - - - using __use_tag - = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>; - if constexpr (is_base_of_v<__uses_alloc0, __use_tag>) - ::new(__p) _Tp1(std::forward<_Args>(__args)...); - else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>) - ::new(__p) _Tp1(allocator_arg, *this, - std::forward<_Args>(__args)...); - else - ::new(__p) _Tp1(std::forward<_Args>(__args)..., *this); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t, - tuple<_Args1...> __x, tuple<_Args2...> __y) - { - auto __x_tag = - __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this); - auto __y_tag = - __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this); - index_sequence_for<_Args1...> __x_i; - index_sequence_for<_Args2...> __y_i; - - ::new(__p) pair<_Tp1, _Tp2>(piecewise_construct, - _S_construct_p(__x_tag, __x_i, __x), - _S_construct_p(__y_tag, __y_i, __y)); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p) - { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y) - { - this->construct(__p, piecewise_construct, - std::forward_as_tuple(std::forward<_Up>(__x)), - std::forward_as_tuple(std::forward<_Vp>(__y))); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, const std::pair<_Up, _Vp>& __pr) - { - this->construct(__p, piecewise_construct, - std::forward_as_tuple(__pr.first), - std::forward_as_tuple(__pr.second)); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr) - { - this->construct(__p, piecewise_construct, - std::forward_as_tuple(std::forward<_Up>(__pr.first)), - std::forward_as_tuple(std::forward<_Vp>(__pr.second))); - } -# 307 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - - __attribute__((__nonnull__)) - void - destroy(_Up* __p) - { __p->~_Up(); } - - polymorphic_allocator - select_on_container_copy_construction() const noexcept - { return polymorphic_allocator(); } - - memory_resource* - resource() const noexcept - __attribute__((__returns_nonnull__)) - { return _M_resource; } - - - - [[nodiscard]] - friend bool - operator==(const polymorphic_allocator& __a, - const polymorphic_allocator& __b) noexcept - { return *__a.resource() == *__b.resource(); } - - - [[nodiscard]] - friend bool - operator!=(const polymorphic_allocator& __a, - const polymorphic_allocator& __b) noexcept - { return !(__a == __b); } - - - private: - - using __uses_alloc1_ = __uses_alloc1; - using __uses_alloc2_ = __uses_alloc2; - - template - static tuple<_Args&&...> - _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t) - { return std::move(__t); } - - template - static tuple - _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>, - tuple<_Args...>& __t) - { - return { - allocator_arg, *__ua._M_a, std::get<_Ind>(std::move(__t))... - }; - } - - template - static tuple<_Args&&..., polymorphic_allocator> - _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>, - tuple<_Args...>& __t) - { return { std::get<_Ind>(std::move(__t))..., *__ua._M_a }; } - - - memory_resource* _M_resource; - }; - - template - [[nodiscard]] - inline bool - operator==(const polymorphic_allocator<_Tp1>& __a, - const polymorphic_allocator<_Tp2>& __b) noexcept - { return *__a.resource() == *__b.resource(); } - - - template - [[nodiscard]] - inline bool - operator!=(const polymorphic_allocator<_Tp1>& __a, - const polymorphic_allocator<_Tp2>& __b) noexcept - { return !(__a == __b); } - - -} - - template struct allocator_traits; - - - template - struct allocator_traits> - { - - using allocator_type = pmr::polymorphic_allocator<_Tp>; - - - using value_type = _Tp; - - - using pointer = _Tp*; - - - using const_pointer = const _Tp*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - - - - using propagate_on_container_copy_assignment = false_type; - using propagate_on_container_move_assignment = false_type; - using propagate_on_container_swap = false_type; - - static allocator_type - select_on_container_copy_construction(const allocator_type&) noexcept - { return allocator_type(); } - - - - using is_always_equal = false_type; - - template - using rebind_alloc = pmr::polymorphic_allocator<_Up>; - - template - using rebind_traits = allocator_traits>; -# 446 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - [[nodiscard]] static pointer - allocate(allocator_type& __a, size_type __n) - { return __a.allocate(__n); } -# 461 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - [[nodiscard]] static pointer - allocate(allocator_type& __a, size_type __n, const_void_pointer) - { return __a.allocate(__n); } -# 473 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - static void - deallocate(allocator_type& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - static void - construct(allocator_type& __a, _Up* __p, _Args&&... __args) - { __a.construct(__p, std::forward<_Args>(__args)...); } -# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - static void - destroy(allocator_type&, _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { __p->~_Up(); } - - - - - - static size_type - max_size(const allocator_type&) noexcept - { return size_t(-1) / sizeof(value_type); } - }; - - -} -# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - namespace pmr { - template - using vector = std::vector<_Tp, polymorphic_allocator<_Tp>>; - } -# 96 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 3 -} -# 16 "src/platform/inputs.h" 2 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdint" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdint" 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdint" 3 -namespace std -{ - - using ::int8_t; - using ::int16_t; - using ::int32_t; - using ::int64_t; - - using ::int_fast8_t; - using ::int_fast16_t; - using ::int_fast32_t; - using ::int_fast64_t; - - using ::int_least8_t; - using ::int_least16_t; - using ::int_least32_t; - using ::int_least64_t; - - using ::intmax_t; - using ::intptr_t; - - using ::uint8_t; - using ::uint16_t; - using ::uint32_t; - using ::uint64_t; - - using ::uint_fast8_t; - using ::uint_fast16_t; - using ::uint_fast32_t; - using ::uint_fast64_t; - - using ::uint_least8_t; - using ::uint_least16_t; - using ::uint_least32_t; - using ::uint_least64_t; - - using ::uintmax_t; - using ::uintptr_t; -# 142 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdint" 3 -} -# 17 "src/platform/inputs.h" 2 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 1 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - class bad_function_call : public std::exception - { - public: - virtual ~bad_function_call() noexcept; - - const char* what() const noexcept; - }; - - - - - - - - template - struct __is_location_invariant - : is_trivially_copyable<_Tp>::type - { }; - - class _Undefined_class; - - union _Nocopy_types - { - void* _M_object; - const void* _M_const_object; - void (*_M_function_pointer)(); - void (_Undefined_class::*_M_member_pointer)(); - }; - - union [[gnu::may_alias]] _Any_data - { - void* _M_access() noexcept { return &_M_pod_data[0]; } - const void* _M_access() const noexcept { return &_M_pod_data[0]; } - - template - _Tp& - _M_access() noexcept - { return *static_cast<_Tp*>(_M_access()); } - - template - const _Tp& - _M_access() const noexcept - { return *static_cast(_M_access()); } - - _Nocopy_types _M_unused; - char _M_pod_data[sizeof(_Nocopy_types)]; - }; - - enum _Manager_operation - { - __get_type_info, - __get_functor_ptr, - __clone_functor, - __destroy_functor - }; - - template - class function; - - - class _Function_base - { - public: - static const size_t _M_max_size = sizeof(_Nocopy_types); - static const size_t _M_max_align = __alignof__(_Nocopy_types); - - template - class _Base_manager - { - protected: - static const bool __stored_locally = - (__is_location_invariant<_Functor>::value - && sizeof(_Functor) <= _M_max_size - && __alignof__(_Functor) <= _M_max_align - && (_M_max_align % __alignof__(_Functor) == 0)); - - using _Local_storage = integral_constant; - - - static _Functor* - _M_get_pointer(const _Any_data& __source) noexcept - { - if constexpr (__stored_locally) - { - const _Functor& __f = __source._M_access<_Functor>(); - return const_cast<_Functor*>(std::__addressof(__f)); - } - else - return __source._M_access<_Functor*>(); - } - - private: - - - template - static void - _M_create(_Any_data& __dest, _Fn&& __f, true_type) - { - ::new (__dest._M_access()) _Functor(std::forward<_Fn>(__f)); - } - - - template - static void - _M_create(_Any_data& __dest, _Fn&& __f, false_type) - { - __dest._M_access<_Functor*>() - = new _Functor(std::forward<_Fn>(__f)); - } - - - static void - _M_destroy(_Any_data& __victim, true_type) - { - __victim._M_access<_Functor>().~_Functor(); - } - - - static void - _M_destroy(_Any_data& __victim, false_type) - { - delete __victim._M_access<_Functor*>(); - } - - public: - static bool - _M_manager(_Any_data& __dest, const _Any_data& __source, - _Manager_operation __op) - { - switch (__op) - { - case __get_type_info: - - __dest._M_access() = &typeid(_Functor); - - - - break; - - case __get_functor_ptr: - __dest._M_access<_Functor*>() = _M_get_pointer(__source); - break; - - case __clone_functor: - _M_init_functor(__dest, - *const_cast(_M_get_pointer(__source))); - break; - - case __destroy_functor: - _M_destroy(__dest, _Local_storage()); - break; - } - return false; - } - - template - static void - _M_init_functor(_Any_data& __functor, _Fn&& __f) - noexcept(__and_<_Local_storage, - is_nothrow_constructible<_Functor, _Fn>>::value) - { - _M_create(__functor, std::forward<_Fn>(__f), _Local_storage()); - } - - template - static bool - _M_not_empty_function(const function<_Signature>& __f) noexcept - { return static_cast(__f); } - - template - static bool - _M_not_empty_function(_Tp* __fp) noexcept - { return __fp != nullptr; } - - template - static bool - _M_not_empty_function(_Tp _Class::* __mp) noexcept - { return __mp != nullptr; } - - template - static bool - _M_not_empty_function(const _Tp&) noexcept - { return true; } - }; - - _Function_base() = default; - - ~_Function_base() - { - if (_M_manager) - _M_manager(_M_functor, _M_functor, __destroy_functor); - } - - bool _M_empty() const { return !_M_manager; } - - using _Manager_type - = bool (*)(_Any_data&, const _Any_data&, _Manager_operation); - - _Any_data _M_functor{}; - _Manager_type _M_manager{}; - }; - - template - class _Function_handler; - - template - class _Function_handler<_Res(_ArgTypes...), _Functor> - : public _Function_base::_Base_manager<_Functor> - { - using _Base = _Function_base::_Base_manager<_Functor>; - - public: - static bool - _M_manager(_Any_data& __dest, const _Any_data& __source, - _Manager_operation __op) - { - switch (__op) - { - - case __get_type_info: - __dest._M_access() = &typeid(_Functor); - break; - - case __get_functor_ptr: - __dest._M_access<_Functor*>() = _Base::_M_get_pointer(__source); - break; - - default: - _Base::_M_manager(__dest, __source, __op); - } - return false; - } - - static _Res - _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args) - { - return std::__invoke_r<_Res>(*_Base::_M_get_pointer(__functor), - std::forward<_ArgTypes>(__args)...); - } - - template - static constexpr bool - _S_nothrow_init() noexcept - { - return __and_>::value; - } - }; - - - template<> - class _Function_handler - { - public: - static bool - _M_manager(_Any_data&, const _Any_data&, _Manager_operation) - { return false; } - }; - - - - - - template::value> - struct _Target_handler - : _Function_handler<_Signature, typename remove_cv<_Functor>::type> - { }; - - template - struct _Target_handler<_Signature, _Functor, false> - : _Function_handler - { }; - - - - - - - template - class function<_Res(_ArgTypes...)> - : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>, - private _Function_base - { - - - template, function>::value> - using _Decay_t - = typename __enable_if_t>::type; - - template, - typename _Res2 = __invoke_result<_DFunc&, _ArgTypes...>> - struct _Callable - : __is_invocable_impl<_Res2, _Res>::type - { }; - - template - using _Requires = __enable_if_t<_Cond::value, _Tp>; - - template - using _Handler - = _Function_handler<_Res(_ArgTypes...), __decay_t<_Functor>>; - - public: - typedef _Res result_type; - - - - - - - - function() noexcept - : _Function_base() { } - - - - - - function(nullptr_t) noexcept - : _Function_base() { } -# 386 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - function(const function& __x) - : _Function_base() - { - if (static_cast(__x)) - { - __x._M_manager(_M_functor, __x._M_functor, __clone_functor); - _M_invoker = __x._M_invoker; - _M_manager = __x._M_manager; - } - } -# 404 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - function(function&& __x) noexcept - : _Function_base(), _M_invoker(__x._M_invoker) - { - if (static_cast(__x)) - { - _M_functor = __x._M_functor; - _M_manager = __x._M_manager; - __x._M_manager = nullptr; - __x._M_invoker = nullptr; - } - } -# 433 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - template>> - function(_Functor&& __f) - noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>()) - : _Function_base() - { - static_assert(is_copy_constructible<__decay_t<_Functor>>::value, - "std::function target must be copy-constructible"); - static_assert(is_constructible<__decay_t<_Functor>, _Functor>::value, - "std::function target must be constructible from the " - "constructor argument"); - - using _My_handler = _Handler<_Functor>; - - if (_My_handler::_M_not_empty_function(__f)) - { - _My_handler::_M_init_functor(_M_functor, - std::forward<_Functor>(__f)); - _M_invoker = &_My_handler::_M_invoke; - _M_manager = &_My_handler::_M_manager; - } - } -# 468 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - function& - operator=(const function& __x) - { - function(__x).swap(*this); - return *this; - } -# 486 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - function& - operator=(function&& __x) noexcept - { - function(std::move(__x)).swap(*this); - return *this; - } -# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - function& - operator=(nullptr_t) noexcept - { - if (_M_manager) - { - _M_manager(_M_functor, _M_functor, __destroy_functor); - _M_manager = nullptr; - _M_invoker = nullptr; - } - return *this; - } -# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - template - _Requires<_Callable<_Functor>, function&> - operator=(_Functor&& __f) - noexcept(_Handler<_Functor>::template _S_nothrow_init<_Functor>()) - { - function(std::forward<_Functor>(__f)).swap(*this); - return *this; - } - - - template - function& - operator=(reference_wrapper<_Functor> __f) noexcept - { - function(__f).swap(*this); - return *this; - } -# 556 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - void swap(function& __x) noexcept - { - std::swap(_M_functor, __x._M_functor); - std::swap(_M_manager, __x._M_manager); - std::swap(_M_invoker, __x._M_invoker); - } -# 573 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - explicit operator bool() const noexcept - { return !_M_empty(); } -# 586 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - _Res - operator()(_ArgTypes... __args) const - { - if (_M_empty()) - __throw_bad_function_call(); - return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...); - } -# 605 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - const type_info& - target_type() const noexcept - { - if (_M_manager) - { - _Any_data __typeinfo_result; - _M_manager(__typeinfo_result, _M_functor, __get_type_info); - if (auto __ti = __typeinfo_result._M_access()) - return *__ti; - } - return typeid(void); - } -# 630 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - template - _Functor* - target() noexcept - { - const function* __const_this = this; - const _Functor* __func = __const_this->template target<_Functor>(); - - - return *const_cast<_Functor**>(&__func); - } - - template - const _Functor* - target() const noexcept - { - if constexpr (is_object<_Functor>::value) - { - - - using _Handler = _Target_handler<_Res(_ArgTypes...), _Functor>; - - if (_M_manager == &_Handler::_M_manager - - || (_M_manager && typeid(_Functor) == target_type()) - - ) - { - _Any_data __ptr; - _M_manager(__ptr, _M_functor, __get_functor_ptr); - return __ptr._M_access(); - } - } - return nullptr; - } - - - private: - using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...); - _Invoker_type _M_invoker = nullptr; - }; - - - template - struct __function_guide_helper - { }; - - template - struct __function_guide_helper< - _Res (_Tp::*) (_Args...) noexcept(_Nx) - > - { using type = _Res(_Args...); }; - - template - struct __function_guide_helper< - _Res (_Tp::*) (_Args...) & noexcept(_Nx) - > - { using type = _Res(_Args...); }; - - template - struct __function_guide_helper< - _Res (_Tp::*) (_Args...) const noexcept(_Nx) - > - { using type = _Res(_Args...); }; - - template - struct __function_guide_helper< - _Res (_Tp::*) (_Args...) const & noexcept(_Nx) - > - { using type = _Res(_Args...); }; -# 715 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - template - using __function_guide_t = typename __function_guide_helper<_Op>::type; - - - template - function(_Res(*)(_ArgTypes...)) -> function<_Res(_ArgTypes...)>; - - template> - function(_Fn) -> function<_Signature>; -# 735 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - template - inline bool - operator==(const function<_Res(_Args...)>& __f, nullptr_t) noexcept - { return !static_cast(__f); } - - - - template - inline bool - operator==(nullptr_t, const function<_Res(_Args...)>& __f) noexcept - { return !static_cast(__f); } - - - - - - - - template - inline bool - operator!=(const function<_Res(_Args...)>& __f, nullptr_t) noexcept - { return static_cast(__f); } - - - template - inline bool - operator!=(nullptr_t, const function<_Res(_Args...)>& __f) noexcept - { return static_cast(__f); } -# 774 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_function.h" 3 - template - inline void - swap(function<_Res(_Args...)>& __x, function<_Res(_Args...)>& __y) noexcept - { __x.swap(__y); } - - - namespace __detail::__variant - { - template struct _Never_valueless_alt; - - - - template - struct _Never_valueless_alt> - : std::true_type - { }; - } - - - -} -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 2 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/unordered_map" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/unordered_map" 3 - - - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 1 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - class _Hashtable; - -namespace __detail -{ - - - - - - template - struct _Hashtable_base; - - - - template - inline typename std::iterator_traits<_Iterator>::difference_type - __distance_fw(_Iterator __first, _Iterator __last, - std::input_iterator_tag) - { return __first != __last ? 1 : 0; } - - template - inline typename std::iterator_traits<_Iterator>::difference_type - __distance_fw(_Iterator __first, _Iterator __last, - std::forward_iterator_tag) - { return std::distance(__first, __last); } - - template - inline typename std::iterator_traits<_Iterator>::difference_type - __distance_fw(_Iterator __first, _Iterator __last) - { return __distance_fw(__first, __last, - std::__iterator_category(__first)); } - - struct _Identity - { - template - _Tp&& - operator()(_Tp&& __x) const noexcept - { return std::forward<_Tp>(__x); } - }; - - struct _Select1st - { - template - struct __1st_type; - - template - struct __1st_type> - { using type = _Tp; }; - - template - struct __1st_type> - { using type = const _Tp; }; - - template - struct __1st_type<_Pair&> - { using type = typename __1st_type<_Pair>::type&; }; - - template - typename __1st_type<_Tp>::type&& - operator()(_Tp&& __x) const noexcept - { return std::forward<_Tp>(__x).first; } - }; - - template - struct _ConvertToValueType; - - template - struct _ConvertToValueType<_Identity, _Value> - { - template - constexpr _Kt&& - operator()(_Kt&& __k) const noexcept - { return std::forward<_Kt>(__k); } - }; - - template - struct _ConvertToValueType<_Select1st, _Value> - { - constexpr _Value&& - operator()(_Value&& __x) const noexcept - { return std::move(__x); } - - constexpr const _Value& - operator()(const _Value& __x) const noexcept - { return __x; } - - template - constexpr std::pair<_Kt, _Val>&& - operator()(std::pair<_Kt, _Val>&& __x) const noexcept - { return std::move(__x); } - - template - constexpr const std::pair<_Kt, _Val>& - operator()(const std::pair<_Kt, _Val>& __x) const noexcept - { return __x; } - }; - - template - struct _NodeBuilder; - - template<> - struct _NodeBuilder<_Select1st> - { - template - static auto - _S_build(_Kt&& __k, _Arg&& __arg, const _NodeGenerator& __node_gen) - -> typename _NodeGenerator::__node_type* - { - return __node_gen(std::forward<_Kt>(__k), - std::forward<_Arg>(__arg).second); - } - }; - - template<> - struct _NodeBuilder<_Identity> - { - template - static auto - _S_build(_Kt&& __k, _Arg&&, const _NodeGenerator& __node_gen) - -> typename _NodeGenerator::__node_type* - { return __node_gen(std::forward<_Kt>(__k)); } - }; - - template - struct _Hashtable_alloc; - - - - template - struct _ReuseOrAllocNode - { - private: - using __node_alloc_type = _NodeAlloc; - using __hashtable_alloc = _Hashtable_alloc<__node_alloc_type>; - using __node_alloc_traits = - typename __hashtable_alloc::__node_alloc_traits; - - public: - using __node_type = typename __hashtable_alloc::__node_type; - - _ReuseOrAllocNode(__node_type* __nodes, __hashtable_alloc& __h) - : _M_nodes(__nodes), _M_h(__h) { } - _ReuseOrAllocNode(const _ReuseOrAllocNode&) = delete; - - ~_ReuseOrAllocNode() - { _M_h._M_deallocate_nodes(_M_nodes); } - - template - __node_type* - operator()(_Args&&... __args) const - { - if (_M_nodes) - { - __node_type* __node = _M_nodes; - _M_nodes = _M_nodes->_M_next(); - __node->_M_nxt = nullptr; - auto& __a = _M_h._M_node_allocator(); - __node_alloc_traits::destroy(__a, __node->_M_valptr()); - try - { - __node_alloc_traits::construct(__a, __node->_M_valptr(), - std::forward<_Args>(__args)...); - } - catch(...) - { - _M_h._M_deallocate_node_ptr(__node); - throw; - } - return __node; - } - return _M_h._M_allocate_node(std::forward<_Args>(__args)...); - } - - private: - mutable __node_type* _M_nodes; - __hashtable_alloc& _M_h; - }; - - - - template - struct _AllocNode - { - private: - using __hashtable_alloc = _Hashtable_alloc<_NodeAlloc>; - - public: - using __node_type = typename __hashtable_alloc::__node_type; - - _AllocNode(__hashtable_alloc& __h) - : _M_h(__h) { } - - template - __node_type* - operator()(_Args&&... __args) const - { return _M_h._M_allocate_node(std::forward<_Args>(__args)...); } - - private: - __hashtable_alloc& _M_h; - }; -# 279 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 - template - struct _Hashtable_traits - { - using __hash_cached = __bool_constant<_Cache_hash_code>; - using __constant_iterators = __bool_constant<_Constant_iterators>; - using __unique_keys = __bool_constant<_Unique_keys>; - }; - - - - - - - - template - struct _Hashtable_hash_traits - { - static constexpr std::size_t - __small_size_threshold() noexcept - { return std::__is_fast_hash<_Hash>::value ? 0 : 20; } - }; -# 309 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 - struct _Hash_node_base - { - _Hash_node_base* _M_nxt; - - _Hash_node_base() noexcept : _M_nxt() { } - - _Hash_node_base(_Hash_node_base* __next) noexcept : _M_nxt(__next) { } - }; - - - - - - - template - struct _Hash_node_value_base - { - typedef _Value value_type; - - __gnu_cxx::__aligned_buffer<_Value> _M_storage; - - _Value* - _M_valptr() noexcept - { return _M_storage._M_ptr(); } - - const _Value* - _M_valptr() const noexcept - { return _M_storage._M_ptr(); } - - _Value& - _M_v() noexcept - { return *_M_valptr(); } - - const _Value& - _M_v() const noexcept - { return *_M_valptr(); } - }; - - - - - template - struct _Hash_node_code_cache - { }; - - - - - template<> - struct _Hash_node_code_cache - { std::size_t _M_hash_code; }; - - template - struct _Hash_node_value - : _Hash_node_value_base<_Value> - , _Hash_node_code_cache<_Cache_hash_code> - { }; - - - - - template - struct _Hash_node - : _Hash_node_base - , _Hash_node_value<_Value, _Cache_hash_code> - { - _Hash_node* - _M_next() const noexcept - { return static_cast<_Hash_node*>(this->_M_nxt); } - }; - - - template - struct _Node_iterator_base - { - using __node_type = _Hash_node<_Value, _Cache_hash_code>; - - __node_type* _M_cur; - - _Node_iterator_base() : _M_cur(nullptr) { } - _Node_iterator_base(__node_type* __p) noexcept - : _M_cur(__p) { } - - void - _M_incr() noexcept - { _M_cur = _M_cur->_M_next(); } - - friend bool - operator==(const _Node_iterator_base& __x, const _Node_iterator_base& __y) - noexcept - { return __x._M_cur == __y._M_cur; } - - - friend bool - operator!=(const _Node_iterator_base& __x, const _Node_iterator_base& __y) - noexcept - { return __x._M_cur != __y._M_cur; } - - }; - - - template - struct _Node_iterator - : public _Node_iterator_base<_Value, __cache> - { - private: - using __base_type = _Node_iterator_base<_Value, __cache>; - using __node_type = typename __base_type::__node_type; - - public: - using value_type = _Value; - using difference_type = std::ptrdiff_t; - using iterator_category = std::forward_iterator_tag; - - using pointer = __conditional_t<__constant_iterators, - const value_type*, value_type*>; - - using reference = __conditional_t<__constant_iterators, - const value_type&, value_type&>; - - _Node_iterator() = default; - - explicit - _Node_iterator(__node_type* __p) noexcept - : __base_type(__p) { } - - reference - operator*() const noexcept - { return this->_M_cur->_M_v(); } - - pointer - operator->() const noexcept - { return this->_M_cur->_M_valptr(); } - - _Node_iterator& - operator++() noexcept - { - this->_M_incr(); - return *this; - } - - _Node_iterator - operator++(int) noexcept - { - _Node_iterator __tmp(*this); - this->_M_incr(); - return __tmp; - } - }; - - - template - struct _Node_const_iterator - : public _Node_iterator_base<_Value, __cache> - { - private: - using __base_type = _Node_iterator_base<_Value, __cache>; - using __node_type = typename __base_type::__node_type; - - public: - typedef _Value value_type; - typedef std::ptrdiff_t difference_type; - typedef std::forward_iterator_tag iterator_category; - - typedef const value_type* pointer; - typedef const value_type& reference; - - _Node_const_iterator() = default; - - explicit - _Node_const_iterator(__node_type* __p) noexcept - : __base_type(__p) { } - - _Node_const_iterator(const _Node_iterator<_Value, __constant_iterators, - __cache>& __x) noexcept - : __base_type(__x._M_cur) { } - - reference - operator*() const noexcept - { return this->_M_cur->_M_v(); } - - pointer - operator->() const noexcept - { return this->_M_cur->_M_valptr(); } - - _Node_const_iterator& - operator++() noexcept - { - this->_M_incr(); - return *this; - } - - _Node_const_iterator - operator++(int) noexcept - { - _Node_const_iterator __tmp(*this); - this->_M_incr(); - return __tmp; - } - }; - - - - - - - struct _Mod_range_hashing - { - typedef std::size_t first_argument_type; - typedef std::size_t second_argument_type; - typedef std::size_t result_type; - - result_type - operator()(first_argument_type __num, - second_argument_type __den) const noexcept - { return __num % __den; } - }; - - - - - - - struct _Default_ranged_hash { }; - - - - struct _Prime_rehash_policy - { - using __has_load_factor = true_type; - - _Prime_rehash_policy(float __z = 1.0) noexcept - : _M_max_load_factor(__z), _M_next_resize(0) { } - - float - max_load_factor() const noexcept - { return _M_max_load_factor; } - - - std::size_t - _M_next_bkt(std::size_t __n) const; - - - std::size_t - _M_bkt_for_elements(std::size_t __n) const - { return __builtin_ceil(__n / (double)_M_max_load_factor); } - - - - - - std::pair - _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, - std::size_t __n_ins) const; - - typedef std::size_t _State; - - _State - _M_state() const - { return _M_next_resize; } - - void - _M_reset() noexcept - { _M_next_resize = 0; } - - void - _M_reset(_State __state) - { _M_next_resize = __state; } - - static const std::size_t _S_growth_factor = 2; - - float _M_max_load_factor; - mutable std::size_t _M_next_resize; - }; - - - struct _Mask_range_hashing - { - typedef std::size_t first_argument_type; - typedef std::size_t second_argument_type; - typedef std::size_t result_type; - - result_type - operator()(first_argument_type __num, - second_argument_type __den) const noexcept - { return __num & (__den - 1); } - }; - - - inline std::size_t - __clp2(std::size_t __n) noexcept - { - using __gnu_cxx::__int_traits; - - if (__n < 2) - return __n; - const unsigned __lz = sizeof(size_t) > sizeof(long) - ? __builtin_clzll(__n - 1ull) - : __builtin_clzl(__n - 1ul); - - return (size_t(1) << (__int_traits::__digits - __lz - 1)) << 1; - } - - - - struct _Power2_rehash_policy - { - using __has_load_factor = true_type; - - _Power2_rehash_policy(float __z = 1.0) noexcept - : _M_max_load_factor(__z), _M_next_resize(0) { } - - float - max_load_factor() const noexcept - { return _M_max_load_factor; } - - - - std::size_t - _M_next_bkt(std::size_t __n) noexcept - { - if (__n == 0) - - - - return 1; - - const auto __max_width = std::min(sizeof(size_t), 8); - const auto __max_bkt = size_t(1) << (__max_width * 8 - 1); - std::size_t __res = __clp2(__n); - - if (__res == 0) - __res = __max_bkt; - else if (__res == 1) - - - - __res = 2; - - if (__res == __max_bkt) - - - - _M_next_resize = size_t(-1); - else - _M_next_resize - = __builtin_floor(__res * (double)_M_max_load_factor); - - return __res; - } - - - std::size_t - _M_bkt_for_elements(std::size_t __n) const noexcept - { return __builtin_ceil(__n / (double)_M_max_load_factor); } - - - - - - std::pair - _M_need_rehash(std::size_t __n_bkt, std::size_t __n_elt, - std::size_t __n_ins) noexcept - { - if (__n_elt + __n_ins > _M_next_resize) - { - - - - double __min_bkts - = std::max(__n_elt + __n_ins, _M_next_resize ? 0 : 11) - / (double)_M_max_load_factor; - if (__min_bkts >= __n_bkt) - return { true, - _M_next_bkt(std::max(__builtin_floor(__min_bkts) + 1, - __n_bkt * _S_growth_factor)) }; - - _M_next_resize - = __builtin_floor(__n_bkt * (double)_M_max_load_factor); - return { false, 0 }; - } - else - return { false, 0 }; - } - - typedef std::size_t _State; - - _State - _M_state() const noexcept - { return _M_next_resize; } - - void - _M_reset() noexcept - { _M_next_resize = 0; } - - void - _M_reset(_State __state) noexcept - { _M_next_resize = __state; } - - static const std::size_t _S_growth_factor = 2; - - float _M_max_load_factor; - std::size_t _M_next_resize; - }; -# 732 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 - template - struct _Map_base { }; - - - template - struct _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> - { - using mapped_type = _Val; - }; - - - template - struct _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true> - { - private: - using __hashtable_base = _Hashtable_base<_Key, pair, - _Select1st, _Equal, _Hash, - _RangeHash, _Unused, - _Traits>; - - using __hashtable = _Hashtable<_Key, pair, _Alloc, - _Select1st, _Equal, _Hash, _RangeHash, - _Unused, _RehashPolicy, _Traits>; - - using __hash_code = typename __hashtable_base::__hash_code; - - public: - using key_type = typename __hashtable_base::key_type; - using mapped_type = _Val; - - mapped_type& - operator[](const key_type& __k); - - mapped_type& - operator[](key_type&& __k); - - - - mapped_type& - at(const key_type& __k) - { - auto __ite = static_cast<__hashtable*>(this)->find(__k); - if (!__ite._M_cur) - __throw_out_of_range(("unordered_map::at")); - return __ite->second; - } - - const mapped_type& - at(const key_type& __k) const - { - auto __ite = static_cast(this)->find(__k); - if (!__ite._M_cur) - __throw_out_of_range(("unordered_map::at")); - return __ite->second; - } - }; - - template - auto - _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>:: - operator[](const key_type& __k) - -> mapped_type& - { - __hashtable* __h = static_cast<__hashtable*>(this); - __hash_code __code = __h->_M_hash_code(__k); - std::size_t __bkt = __h->_M_bucket_index(__code); - if (auto __node = __h->_M_find_node(__bkt, __k, __code)) - return __node->_M_v().second; - - typename __hashtable::_Scoped_node __node { - __h, - std::piecewise_construct, - std::tuple(__k), - std::tuple<>() - }; - auto __pos - = __h->_M_insert_unique_node(__bkt, __code, __node._M_node); - __node._M_node = nullptr; - return __pos->second; - } - - template - auto - _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>:: - operator[](key_type&& __k) - -> mapped_type& - { - __hashtable* __h = static_cast<__hashtable*>(this); - __hash_code __code = __h->_M_hash_code(__k); - std::size_t __bkt = __h->_M_bucket_index(__code); - if (auto __node = __h->_M_find_node(__bkt, __k, __code)) - return __node->_M_v().second; - - typename __hashtable::_Scoped_node __node { - __h, - std::piecewise_construct, - std::forward_as_tuple(std::move(__k)), - std::tuple<>() - }; - auto __pos - = __h->_M_insert_unique_node(__bkt, __code, __node._M_node); - __node._M_node = nullptr; - return __pos->second; - } - - - template - struct _Map_base, - _Alloc, _Select1st, _Equal, _Hash, - _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq> - : _Map_base<_Key, pair, _Alloc, _Select1st, _Equal, _Hash, - _RangeHash, _Unused, _RehashPolicy, _Traits, __uniq> - { }; - - - - - - - template - struct _Insert_base - { - protected: - using __hashtable_base = _Hashtable_base<_Key, _Value, _ExtractKey, - _Equal, _Hash, _RangeHash, - _Unused, _Traits>; - - using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, - _Unused, _RehashPolicy, _Traits>; - - using __hash_cached = typename _Traits::__hash_cached; - using __constant_iterators = typename _Traits::__constant_iterators; - - using __hashtable_alloc = _Hashtable_alloc< - __alloc_rebind<_Alloc, _Hash_node<_Value, - __hash_cached::value>>>; - - using value_type = typename __hashtable_base::value_type; - using size_type = typename __hashtable_base::size_type; - - using __unique_keys = typename _Traits::__unique_keys; - using __node_alloc_type = typename __hashtable_alloc::__node_alloc_type; - using __node_gen_type = _AllocNode<__node_alloc_type>; - - __hashtable& - _M_conjure_hashtable() - { return *(static_cast<__hashtable*>(this)); } - - template - void - _M_insert_range(_InputIterator __first, _InputIterator __last, - const _NodeGetter&, true_type __uks); - - template - void - _M_insert_range(_InputIterator __first, _InputIterator __last, - const _NodeGetter&, false_type __uks); - - public: - using iterator = _Node_iterator<_Value, __constant_iterators::value, - __hash_cached::value>; - - using const_iterator = _Node_const_iterator<_Value, - __constant_iterators::value, - __hash_cached::value>; - - using __ireturn_type = __conditional_t<__unique_keys::value, - std::pair, - iterator>; - - __ireturn_type - insert(const value_type& __v) - { - __hashtable& __h = _M_conjure_hashtable(); - __node_gen_type __node_gen(__h); - return __h._M_insert(__v, __node_gen, __unique_keys{}); - } - - iterator - insert(const_iterator __hint, const value_type& __v) - { - __hashtable& __h = _M_conjure_hashtable(); - __node_gen_type __node_gen(__h); - return __h._M_insert(__hint, __v, __node_gen, __unique_keys{}); - } - - template - std::pair - try_emplace(const_iterator, _KType&& __k, _Args&&... __args) - { - __hashtable& __h = _M_conjure_hashtable(); - auto __code = __h._M_hash_code(__k); - std::size_t __bkt = __h._M_bucket_index(__code); - if (auto __node = __h._M_find_node(__bkt, __k, __code)) - return { iterator(__node), false }; - - typename __hashtable::_Scoped_node __node { - &__h, - std::piecewise_construct, - std::forward_as_tuple(std::forward<_KType>(__k)), - std::forward_as_tuple(std::forward<_Args>(__args)...) - }; - auto __it - = __h._M_insert_unique_node(__bkt, __code, __node._M_node); - __node._M_node = nullptr; - return { __it, true }; - } - - void - insert(initializer_list __l) - { this->insert(__l.begin(), __l.end()); } - - template - void - insert(_InputIterator __first, _InputIterator __last) - { - __hashtable& __h = _M_conjure_hashtable(); - __node_gen_type __node_gen(__h); - return _M_insert_range(__first, __last, __node_gen, __unique_keys{}); - } - }; - - template - template - void - _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>:: - _M_insert_range(_InputIterator __first, _InputIterator __last, - const _NodeGetter& __node_gen, true_type __uks) - { - __hashtable& __h = _M_conjure_hashtable(); - for (; __first != __last; ++__first) - __h._M_insert(*__first, __node_gen, __uks); - } - - template - template - void - _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>:: - _M_insert_range(_InputIterator __first, _InputIterator __last, - const _NodeGetter& __node_gen, false_type __uks) - { - using __rehash_type = typename __hashtable::__rehash_type; - using __rehash_state = typename __hashtable::__rehash_state; - using pair_type = std::pair; - - size_type __n_elt = __detail::__distance_fw(__first, __last); - if (__n_elt == 0) - return; - - __hashtable& __h = _M_conjure_hashtable(); - __rehash_type& __rehash = __h._M_rehash_policy; - const __rehash_state& __saved_state = __rehash._M_state(); - pair_type __do_rehash = __rehash._M_need_rehash(__h._M_bucket_count, - __h._M_element_count, - __n_elt); - - if (__do_rehash.first) - __h._M_rehash(__do_rehash.second, __saved_state); - - for (; __first != __last; ++__first) - __h._M_insert(*__first, __node_gen, __uks); - } - - - - - - - - template - struct _Insert; - - - template - struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits, true> - : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits> - { - using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>; - - using value_type = typename __base_type::value_type; - using iterator = typename __base_type::iterator; - using const_iterator = typename __base_type::const_iterator; - using __ireturn_type = typename __base_type::__ireturn_type; - - using __unique_keys = typename __base_type::__unique_keys; - using __hashtable = typename __base_type::__hashtable; - using __node_gen_type = typename __base_type::__node_gen_type; - - using __base_type::insert; - - __ireturn_type - insert(value_type&& __v) - { - __hashtable& __h = this->_M_conjure_hashtable(); - __node_gen_type __node_gen(__h); - return __h._M_insert(std::move(__v), __node_gen, __unique_keys{}); - } - - iterator - insert(const_iterator __hint, value_type&& __v) - { - __hashtable& __h = this->_M_conjure_hashtable(); - __node_gen_type __node_gen(__h); - return __h._M_insert(__hint, std::move(__v), __node_gen, - __unique_keys{}); - } - }; - - - template - struct _Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> - : public _Insert_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits> - { - using __base_type = _Insert_base<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>; - using value_type = typename __base_type::value_type; - using iterator = typename __base_type::iterator; - using const_iterator = typename __base_type::const_iterator; - - using __unique_keys = typename __base_type::__unique_keys; - using __hashtable = typename __base_type::__hashtable; - using __ireturn_type = typename __base_type::__ireturn_type; - - using __base_type::insert; - - template - using __is_cons = std::is_constructible; - - template - using _IFcons = std::enable_if<__is_cons<_Pair>::value>; - - template - using _IFconsp = typename _IFcons<_Pair>::type; - - template> - __ireturn_type - insert(_Pair&& __v) - { - __hashtable& __h = this->_M_conjure_hashtable(); - return __h._M_emplace(__unique_keys{}, std::forward<_Pair>(__v)); - } - - template> - iterator - insert(const_iterator __hint, _Pair&& __v) - { - __hashtable& __h = this->_M_conjure_hashtable(); - return __h._M_emplace(__hint, __unique_keys{}, - std::forward<_Pair>(__v)); - } - }; - - template - using __has_load_factor = typename _Policy::__has_load_factor; - - - - - - - - template> - struct _Rehash_base; - - - template - struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, - false_type > - { - }; - - - template - struct _Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, - true_type > - { - private: - using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>; - - public: - float - max_load_factor() const noexcept - { - const __hashtable* __this = static_cast(this); - return __this->__rehash_policy().max_load_factor(); - } - - void - max_load_factor(float __z) - { - __hashtable* __this = static_cast<__hashtable*>(this); - __this->__rehash_policy(_RehashPolicy(__z)); - } - - void - reserve(std::size_t __n) - { - __hashtable* __this = static_cast<__hashtable*>(this); - __this->rehash(__this->__rehash_policy()._M_bkt_for_elements(__n)); - } - }; - - - - - - - - template - struct _Hashtable_ebo_helper; - - - template - struct _Hashtable_ebo_helper<_Nm, _Tp, true> - : private _Tp - { - _Hashtable_ebo_helper() noexcept(noexcept(_Tp())) : _Tp() { } - - template - _Hashtable_ebo_helper(_OtherTp&& __tp) - : _Tp(std::forward<_OtherTp>(__tp)) - { } - - const _Tp& _M_cget() const { return static_cast(*this); } - _Tp& _M_get() { return static_cast<_Tp&>(*this); } - }; - - - template - struct _Hashtable_ebo_helper<_Nm, _Tp, false> - { - _Hashtable_ebo_helper() = default; - - template - _Hashtable_ebo_helper(_OtherTp&& __tp) - : _M_tp(std::forward<_OtherTp>(__tp)) - { } - - const _Tp& _M_cget() const { return _M_tp; } - _Tp& _M_get() { return _M_tp; } - - private: - _Tp _M_tp{}; - }; - - - - - - - - template - struct _Local_iterator_base; -# 1272 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 - template - struct _Hash_code_base - : private _Hashtable_ebo_helper<1, _Hash> - { - private: - using __ebo_hash = _Hashtable_ebo_helper<1, _Hash>; - - - friend struct _Local_iterator_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, false>; - - public: - typedef _Hash hasher; - - hasher - hash_function() const - { return _M_hash(); } - - protected: - typedef std::size_t __hash_code; - - - - _Hash_code_base() = default; - - _Hash_code_base(const _Hash& __hash) : __ebo_hash(__hash) { } - - __hash_code - _M_hash_code(const _Key& __k) const - { - static_assert(__is_invocable{}, - "hash function must be invocable with an argument of key type"); - return _M_hash()(__k); - } - - template - __hash_code - _M_hash_code_tr(const _Kt& __k) const - { - static_assert(__is_invocable{}, - "hash function must be invocable with an argument of key type"); - return _M_hash()(__k); - } - - __hash_code - _M_hash_code(const _Hash&, - const _Hash_node_value<_Value, true>& __n) const - { return __n._M_hash_code; } - - - - template - __hash_code - _M_hash_code(const _H2&, - const _Hash_node_value<_Value, __cache_hash_code>& __n) const - { return _M_hash_code(_ExtractKey{}(__n._M_v())); } - - __hash_code - _M_hash_code(const _Hash_node_value<_Value, false>& __n) const - { return _M_hash_code(_ExtractKey{}(__n._M_v())); } - - __hash_code - _M_hash_code(const _Hash_node_value<_Value, true>& __n) const - { return __n._M_hash_code; } - - std::size_t - _M_bucket_index(__hash_code __c, std::size_t __bkt_count) const - { return _RangeHash{}(__c, __bkt_count); } - - std::size_t - _M_bucket_index(const _Hash_node_value<_Value, false>& __n, - std::size_t __bkt_count) const - noexcept( noexcept(declval()(declval())) - && noexcept(declval()((__hash_code)0, - (std::size_t)0)) ) - { - return _RangeHash{}(_M_hash_code(_ExtractKey{}(__n._M_v())), - __bkt_count); - } - - std::size_t - _M_bucket_index(const _Hash_node_value<_Value, true>& __n, - std::size_t __bkt_count) const - noexcept( noexcept(declval()((__hash_code)0, - (std::size_t)0)) ) - { return _RangeHash{}(__n._M_hash_code, __bkt_count); } - - void - _M_store_code(_Hash_node_code_cache&, __hash_code) const - { } - - void - _M_copy_code(_Hash_node_code_cache&, - const _Hash_node_code_cache&) const - { } - - void - _M_store_code(_Hash_node_code_cache& __n, __hash_code __c) const - { __n._M_hash_code = __c; } - - void - _M_copy_code(_Hash_node_code_cache& __to, - const _Hash_node_code_cache& __from) const - { __to._M_hash_code = __from._M_hash_code; } - - void - _M_swap(_Hash_code_base& __x) - { std::swap(__ebo_hash::_M_get(), __x.__ebo_hash::_M_get()); } - - const _Hash& - _M_hash() const { return __ebo_hash::_M_cget(); } - }; - - - template - struct _Local_iterator_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, true> - : public _Node_iterator_base<_Value, true> - { - protected: - using __base_node_iter = _Node_iterator_base<_Value, true>; - using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, true>; - - _Local_iterator_base() = default; - _Local_iterator_base(const __hash_code_base&, - _Hash_node<_Value, true>* __p, - std::size_t __bkt, std::size_t __bkt_count) - : __base_node_iter(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) - { } - - void - _M_incr() - { - __base_node_iter::_M_incr(); - if (this->_M_cur) - { - std::size_t __bkt - = _RangeHash{}(this->_M_cur->_M_hash_code, _M_bucket_count); - if (__bkt != _M_bucket) - this->_M_cur = nullptr; - } - } - - std::size_t _M_bucket; - std::size_t _M_bucket_count; - - public: - std::size_t - _M_get_bucket() const { return _M_bucket; } - }; - - - - - - template::value> - struct _Hash_code_storage - { - __gnu_cxx::__aligned_buffer<_Tp> _M_storage; - - _Tp* - _M_h() { return _M_storage._M_ptr(); } - - const _Tp* - _M_h() const { return _M_storage._M_ptr(); } - }; - - - template - struct _Hash_code_storage<_Tp, true> - { - static_assert( std::is_empty<_Tp>::value, "Type must be empty" ); - - - - _Tp* - _M_h() { return reinterpret_cast<_Tp*>(this); } - - const _Tp* - _M_h() const { return reinterpret_cast(this); } - }; - - template - using __hash_code_for_local_iter - = _Hash_code_storage<_Hash_code_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, false>>; - - - template - struct _Local_iterator_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, false> - : __hash_code_for_local_iter<_Key, _Value, _ExtractKey, _Hash, _RangeHash, - _Unused> - , _Node_iterator_base<_Value, false> - { - protected: - using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, false>; - using __node_iter_base = _Node_iterator_base<_Value, false>; - - _Local_iterator_base() : _M_bucket_count(-1) { } - - _Local_iterator_base(const __hash_code_base& __base, - _Hash_node<_Value, false>* __p, - std::size_t __bkt, std::size_t __bkt_count) - : __node_iter_base(__p), _M_bucket(__bkt), _M_bucket_count(__bkt_count) - { _M_init(__base); } - - ~_Local_iterator_base() - { - if (_M_bucket_count != size_t(-1)) - _M_destroy(); - } - - _Local_iterator_base(const _Local_iterator_base& __iter) - : __node_iter_base(__iter._M_cur), _M_bucket(__iter._M_bucket) - , _M_bucket_count(__iter._M_bucket_count) - { - if (_M_bucket_count != size_t(-1)) - _M_init(*__iter._M_h()); - } - - _Local_iterator_base& - operator=(const _Local_iterator_base& __iter) - { - if (_M_bucket_count != -1) - _M_destroy(); - this->_M_cur = __iter._M_cur; - _M_bucket = __iter._M_bucket; - _M_bucket_count = __iter._M_bucket_count; - if (_M_bucket_count != -1) - _M_init(*__iter._M_h()); - return *this; - } - - void - _M_incr() - { - __node_iter_base::_M_incr(); - if (this->_M_cur) - { - std::size_t __bkt = this->_M_h()->_M_bucket_index(*this->_M_cur, - _M_bucket_count); - if (__bkt != _M_bucket) - this->_M_cur = nullptr; - } - } - - std::size_t _M_bucket; - std::size_t _M_bucket_count; - - void - _M_init(const __hash_code_base& __base) - { ::new(this->_M_h()) __hash_code_base(__base); } - - void - _M_destroy() { this->_M_h()->~__hash_code_base(); } - - public: - std::size_t - _M_get_bucket() const { return _M_bucket; } - }; - - - template - struct _Local_iterator - : public _Local_iterator_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, __cache> - { - private: - using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, __cache>; - using __hash_code_base = typename __base_type::__hash_code_base; - - public: - using value_type = _Value; - using pointer = __conditional_t<__constant_iterators, - const value_type*, value_type*>; - using reference = __conditional_t<__constant_iterators, - const value_type&, value_type&>; - using difference_type = ptrdiff_t; - using iterator_category = forward_iterator_tag; - - _Local_iterator() = default; - - _Local_iterator(const __hash_code_base& __base, - _Hash_node<_Value, __cache>* __n, - std::size_t __bkt, std::size_t __bkt_count) - : __base_type(__base, __n, __bkt, __bkt_count) - { } - - reference - operator*() const - { return this->_M_cur->_M_v(); } - - pointer - operator->() const - { return this->_M_cur->_M_valptr(); } - - _Local_iterator& - operator++() - { - this->_M_incr(); - return *this; - } - - _Local_iterator - operator++(int) - { - _Local_iterator __tmp(*this); - this->_M_incr(); - return __tmp; - } - }; - - - template - struct _Local_const_iterator - : public _Local_iterator_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, __cache> - { - private: - using __base_type = _Local_iterator_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, __cache>; - using __hash_code_base = typename __base_type::__hash_code_base; - - public: - typedef _Value value_type; - typedef const value_type* pointer; - typedef const value_type& reference; - typedef std::ptrdiff_t difference_type; - typedef std::forward_iterator_tag iterator_category; - - _Local_const_iterator() = default; - - _Local_const_iterator(const __hash_code_base& __base, - _Hash_node<_Value, __cache>* __n, - std::size_t __bkt, std::size_t __bkt_count) - : __base_type(__base, __n, __bkt, __bkt_count) - { } - - _Local_const_iterator(const _Local_iterator<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, - __constant_iterators, - __cache>& __x) - : __base_type(__x) - { } - - reference - operator*() const - { return this->_M_cur->_M_v(); } - - pointer - operator->() const - { return this->_M_cur->_M_valptr(); } - - _Local_const_iterator& - operator++() - { - this->_M_incr(); - return *this; - } - - _Local_const_iterator - operator++(int) - { - _Local_const_iterator __tmp(*this); - this->_M_incr(); - return __tmp; - } - }; -# 1664 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 - template - struct _Hashtable_base - : public _Hash_code_base<_Key, _Value, _ExtractKey, _Hash, _RangeHash, - _Unused, _Traits::__hash_cached::value>, - private _Hashtable_ebo_helper<0, _Equal> - { - public: - typedef _Key key_type; - typedef _Value value_type; - typedef _Equal key_equal; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - - using __traits_type = _Traits; - using __hash_cached = typename __traits_type::__hash_cached; - - using __hash_code_base = _Hash_code_base<_Key, _Value, _ExtractKey, - _Hash, _RangeHash, _Unused, - __hash_cached::value>; - - using __hash_code = typename __hash_code_base::__hash_code; - - private: - using _EqualEBO = _Hashtable_ebo_helper<0, _Equal>; - - static bool - _S_equals(__hash_code, const _Hash_node_code_cache&) - { return true; } - - static bool - _S_node_equals(const _Hash_node_code_cache&, - const _Hash_node_code_cache&) - { return true; } - - static bool - _S_equals(__hash_code __c, const _Hash_node_code_cache& __n) - { return __c == __n._M_hash_code; } - - static bool - _S_node_equals(const _Hash_node_code_cache& __lhn, - const _Hash_node_code_cache& __rhn) - { return __lhn._M_hash_code == __rhn._M_hash_code; } - - protected: - _Hashtable_base() = default; - - _Hashtable_base(const _Hash& __hash, const _Equal& __eq) - : __hash_code_base(__hash), _EqualEBO(__eq) - { } - - bool - _M_key_equals(const _Key& __k, - const _Hash_node_value<_Value, - __hash_cached::value>& __n) const - { - static_assert(__is_invocable{}, - "key equality predicate must be invocable with two arguments of " - "key type"); - return _M_eq()(__k, _ExtractKey{}(__n._M_v())); - } - - template - bool - _M_key_equals_tr(const _Kt& __k, - const _Hash_node_value<_Value, - __hash_cached::value>& __n) const - { - static_assert( - __is_invocable{}, - "key equality predicate must be invocable with two arguments of " - "key type"); - return _M_eq()(__k, _ExtractKey{}(__n._M_v())); - } - - bool - _M_equals(const _Key& __k, __hash_code __c, - const _Hash_node_value<_Value, __hash_cached::value>& __n) const - { return _S_equals(__c, __n) && _M_key_equals(__k, __n); } - - template - bool - _M_equals_tr(const _Kt& __k, __hash_code __c, - const _Hash_node_value<_Value, - __hash_cached::value>& __n) const - { return _S_equals(__c, __n) && _M_key_equals_tr(__k, __n); } - - bool - _M_node_equals( - const _Hash_node_value<_Value, __hash_cached::value>& __lhn, - const _Hash_node_value<_Value, __hash_cached::value>& __rhn) const - { - return _S_node_equals(__lhn, __rhn) - && _M_key_equals(_ExtractKey{}(__lhn._M_v()), __rhn); - } - - void - _M_swap(_Hashtable_base& __x) - { - __hash_code_base::_M_swap(__x); - std::swap(_EqualEBO::_M_get(), __x._EqualEBO::_M_get()); - } - - const _Equal& - _M_eq() const { return _EqualEBO::_M_cget(); } - }; -# 1780 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable_policy.h" 3 - template - struct _Equality; - - - template - struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true> - { - using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>; - - bool - _M_equal(const __hashtable&) const; - }; - - template - bool - _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, true>:: - _M_equal(const __hashtable& __other) const - { - using __node_type = typename __hashtable::__node_type; - const __hashtable* __this = static_cast(this); - if (__this->size() != __other.size()) - return false; - - for (auto __itx = __this->begin(); __itx != __this->end(); ++__itx) - { - std::size_t __ybkt = __other._M_bucket_index(*__itx._M_cur); - auto __prev_n = __other._M_buckets[__ybkt]; - if (!__prev_n) - return false; - - for (__node_type* __n = static_cast<__node_type*>(__prev_n->_M_nxt);; - __n = __n->_M_next()) - { - if (__n->_M_v() == *__itx) - break; - - if (!__n->_M_nxt - || __other._M_bucket_index(*__n->_M_next()) != __ybkt) - return false; - } - } - - return true; - } - - - template - struct _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false> - { - using __hashtable = _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>; - - bool - _M_equal(const __hashtable&) const; - }; - - template - bool - _Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits, false>:: - _M_equal(const __hashtable& __other) const - { - using __node_type = typename __hashtable::__node_type; - const __hashtable* __this = static_cast(this); - if (__this->size() != __other.size()) - return false; - - for (auto __itx = __this->begin(); __itx != __this->end();) - { - std::size_t __x_count = 1; - auto __itx_end = __itx; - for (++__itx_end; __itx_end != __this->end() - && __this->key_eq()(_ExtractKey{}(*__itx), - _ExtractKey{}(*__itx_end)); - ++__itx_end) - ++__x_count; - - std::size_t __ybkt = __other._M_bucket_index(*__itx._M_cur); - auto __y_prev_n = __other._M_buckets[__ybkt]; - if (!__y_prev_n) - return false; - - __node_type* __y_n = static_cast<__node_type*>(__y_prev_n->_M_nxt); - for (;;) - { - if (__this->key_eq()(_ExtractKey{}(__y_n->_M_v()), - _ExtractKey{}(*__itx))) - break; - - auto __y_ref_n = __y_n; - for (__y_n = __y_n->_M_next(); __y_n; __y_n = __y_n->_M_next()) - if (!__other._M_node_equals(*__y_ref_n, *__y_n)) - break; - - if (!__y_n || __other._M_bucket_index(*__y_n) != __ybkt) - return false; - } - - typename __hashtable::const_iterator __ity(__y_n); - for (auto __ity_end = __ity; __ity_end != __other.end(); ++__ity_end) - if (--__x_count == 0) - break; - - if (__x_count != 0) - return false; - - if (!std::is_permutation(__itx, __itx_end, __ity)) - return false; - - __itx = __itx_end; - } - return true; - } - - - - - - template - struct _Hashtable_alloc : private _Hashtable_ebo_helper<0, _NodeAlloc> - { - private: - using __ebo_node_alloc = _Hashtable_ebo_helper<0, _NodeAlloc>; - - template - struct __get_value_type; - template - struct __get_value_type<_Hash_node<_Val, _Cache_hash_code>> - { using type = _Val; }; - - public: - using __node_type = typename _NodeAlloc::value_type; - using __node_alloc_type = _NodeAlloc; - - using __node_alloc_traits = __gnu_cxx::__alloc_traits<__node_alloc_type>; - - using __value_alloc_traits = typename __node_alloc_traits::template - rebind_traits::type>; - - using __node_ptr = __node_type*; - using __node_base = _Hash_node_base; - using __node_base_ptr = __node_base*; - using __buckets_alloc_type = - __alloc_rebind<__node_alloc_type, __node_base_ptr>; - using __buckets_alloc_traits = std::allocator_traits<__buckets_alloc_type>; - using __buckets_ptr = __node_base_ptr*; - - _Hashtable_alloc() = default; - _Hashtable_alloc(const _Hashtable_alloc&) = default; - _Hashtable_alloc(_Hashtable_alloc&&) = default; - - template - _Hashtable_alloc(_Alloc&& __a) - : __ebo_node_alloc(std::forward<_Alloc>(__a)) - { } - - __node_alloc_type& - _M_node_allocator() - { return __ebo_node_alloc::_M_get(); } - - const __node_alloc_type& - _M_node_allocator() const - { return __ebo_node_alloc::_M_cget(); } - - - template - __node_ptr - _M_allocate_node(_Args&&... __args); - - - void - _M_deallocate_node(__node_ptr __n); - - - void - _M_deallocate_node_ptr(__node_ptr __n); - - - - void - _M_deallocate_nodes(__node_ptr __n); - - __buckets_ptr - _M_allocate_buckets(std::size_t __bkt_count); - - void - _M_deallocate_buckets(__buckets_ptr, std::size_t __bkt_count); - }; - - - - template - template - auto - _Hashtable_alloc<_NodeAlloc>::_M_allocate_node(_Args&&... __args) - -> __node_ptr - { - auto __nptr = __node_alloc_traits::allocate(_M_node_allocator(), 1); - __node_ptr __n = std::__to_address(__nptr); - try - { - ::new ((void*)__n) __node_type; - __node_alloc_traits::construct(_M_node_allocator(), - __n->_M_valptr(), - std::forward<_Args>(__args)...); - return __n; - } - catch(...) - { - __node_alloc_traits::deallocate(_M_node_allocator(), __nptr, 1); - throw; - } - } - - template - void - _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node(__node_ptr __n) - { - __node_alloc_traits::destroy(_M_node_allocator(), __n->_M_valptr()); - _M_deallocate_node_ptr(__n); - } - - template - void - _Hashtable_alloc<_NodeAlloc>::_M_deallocate_node_ptr(__node_ptr __n) - { - typedef typename __node_alloc_traits::pointer _Ptr; - auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__n); - __n->~__node_type(); - __node_alloc_traits::deallocate(_M_node_allocator(), __ptr, 1); - } - - template - void - _Hashtable_alloc<_NodeAlloc>::_M_deallocate_nodes(__node_ptr __n) - { - while (__n) - { - __node_ptr __tmp = __n; - __n = __n->_M_next(); - _M_deallocate_node(__tmp); - } - } - - template - auto - _Hashtable_alloc<_NodeAlloc>::_M_allocate_buckets(std::size_t __bkt_count) - -> __buckets_ptr - { - __buckets_alloc_type __alloc(_M_node_allocator()); - - auto __ptr = __buckets_alloc_traits::allocate(__alloc, __bkt_count); - __buckets_ptr __p = std::__to_address(__ptr); - __builtin_memset(__p, 0, __bkt_count * sizeof(__node_base_ptr)); - return __p; - } - - template - void - _Hashtable_alloc<_NodeAlloc>:: - _M_deallocate_buckets(__buckets_ptr __bkts, - std::size_t __bkt_count) - { - typedef typename __buckets_alloc_traits::pointer _Ptr; - auto __ptr = std::pointer_traits<_Ptr>::pointer_to(*__bkts); - __buckets_alloc_type __alloc(_M_node_allocator()); - __buckets_alloc_traits::deallocate(__alloc, __ptr, __bkt_count); - } - - -} - - -} -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/enable_special_members.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/enable_special_members.h" 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - struct _Enable_default_constructor_tag - { - explicit constexpr _Enable_default_constructor_tag() = default; - }; - - - - - - -template - struct _Enable_default_constructor - { - constexpr _Enable_default_constructor() noexcept = default; - constexpr _Enable_default_constructor(_Enable_default_constructor const&) - noexcept = default; - constexpr _Enable_default_constructor(_Enable_default_constructor&&) - noexcept = default; - _Enable_default_constructor& - operator=(_Enable_default_constructor const&) noexcept = default; - _Enable_default_constructor& - operator=(_Enable_default_constructor&&) noexcept = default; - - - constexpr explicit - _Enable_default_constructor(_Enable_default_constructor_tag) { } - }; - - - - - - - -template - struct _Enable_destructor { }; - - - - - - -template - struct _Enable_copy_move { }; -# 96 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/enable_special_members.h" 3 -template - struct _Enable_special_members - : private _Enable_default_constructor<_Default, _Tag>, - private _Enable_destructor<_Destructor, _Tag>, - private _Enable_copy_move<_Copy, _CopyAssignment, - _Move, _MoveAssignment, - _Tag> - { }; - - - -template - struct _Enable_default_constructor - { - constexpr _Enable_default_constructor() noexcept = delete; - constexpr _Enable_default_constructor(_Enable_default_constructor const&) - noexcept = default; - constexpr _Enable_default_constructor(_Enable_default_constructor&&) - noexcept = default; - _Enable_default_constructor& - operator=(_Enable_default_constructor const&) noexcept = default; - _Enable_default_constructor& - operator=(_Enable_default_constructor&&) noexcept = default; - - - constexpr explicit - _Enable_default_constructor(_Enable_default_constructor_tag) { } - }; - -template - struct _Enable_destructor - { ~_Enable_destructor() noexcept = delete; }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = default; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = default; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = default; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = default; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = default; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = default; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = default; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = delete; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = delete; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = delete; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = delete; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = delete; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = default; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = delete; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = delete; - }; - -template - struct _Enable_copy_move - { - constexpr _Enable_copy_move() noexcept = default; - constexpr _Enable_copy_move(_Enable_copy_move const&) noexcept = delete; - constexpr _Enable_copy_move(_Enable_copy_move&&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move const&) noexcept = delete; - _Enable_copy_move& - operator=(_Enable_copy_move&&) noexcept = delete; - }; - - - -} -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/node_handle.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/node_handle.h" 3 - - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/node_handle.h" 3 - template - class _Node_handle_common - { - using _AllocTraits = allocator_traits<_NodeAlloc>; - - public: - using allocator_type = __alloc_rebind<_NodeAlloc, _Val>; - - allocator_type - get_allocator() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __builtin_unreachable(); } while (false); - return allocator_type(_M_alloc._M_alloc); - } - - explicit operator bool() const noexcept { return _M_ptr != nullptr; } - - [[nodiscard]] bool empty() const noexcept { return _M_ptr == nullptr; } - - - protected: - constexpr _Node_handle_common() noexcept : _M_ptr() { } - - ~_Node_handle_common() - { - if (!empty()) - _M_reset(); - } - - _Node_handle_common(_Node_handle_common&& __nh) noexcept - : _M_ptr(__nh._M_ptr) - { - if (_M_ptr) - _M_move(std::move(__nh)); - } - - _Node_handle_common& - operator=(_Node_handle_common&& __nh) noexcept - { - if (empty()) - { - if (!__nh.empty()) - _M_move(std::move(__nh)); - } - else if (__nh.empty()) - _M_reset(); - else - { - - _AllocTraits::destroy(*_M_alloc, _M_ptr->_M_valptr()); - _AllocTraits::deallocate(*_M_alloc, _M_ptr, 1); - - _M_alloc = __nh._M_alloc.release(); - _M_ptr = __nh._M_ptr; - __nh._M_ptr = nullptr; - } - return *this; - } - - _Node_handle_common(typename _AllocTraits::pointer __ptr, - const _NodeAlloc& __alloc) - : _M_ptr(__ptr), _M_alloc(__alloc) - { - do { if (std::__is_constant_evaluated() && !bool(__ptr != nullptr)) __builtin_unreachable(); } while (false); - } - - void - _M_swap(_Node_handle_common& __nh) noexcept - { - if (empty()) - { - if (!__nh.empty()) - _M_move(std::move(__nh)); - } - else if (__nh.empty()) - __nh._M_move(std::move(*this)); - else - { - using std::swap; - swap(_M_ptr, __nh._M_ptr); - _M_alloc.swap(__nh._M_alloc); - } - } - - private: - - - - void - _M_move(_Node_handle_common&& __nh) noexcept - { - ::new (std::__addressof(_M_alloc)) _NodeAlloc(__nh._M_alloc.release()); - _M_ptr = __nh._M_ptr; - __nh._M_ptr = nullptr; - } - - - - - void - _M_reset() noexcept - { - _NodeAlloc __alloc = _M_alloc.release(); - _AllocTraits::destroy(__alloc, _M_ptr->_M_valptr()); - _AllocTraits::deallocate(__alloc, _M_ptr, 1); - _M_ptr = nullptr; - } - - protected: - typename _AllocTraits::pointer _M_ptr; - - private: - - - union _Optional_alloc - { - _Optional_alloc() { } - ~_Optional_alloc() { } - - _Optional_alloc(_Optional_alloc&&) = delete; - _Optional_alloc& operator=(_Optional_alloc&&) = delete; - - _Optional_alloc(const _NodeAlloc& __alloc) noexcept - : _M_alloc(__alloc) - { } - - - void - operator=(_NodeAlloc&& __alloc) noexcept - { - using _ATr = _AllocTraits; - if constexpr (_ATr::propagate_on_container_move_assignment::value) - _M_alloc = std::move(__alloc); - else if constexpr (!_AllocTraits::is_always_equal::value) - do { if (std::__is_constant_evaluated() && !bool(_M_alloc == __alloc)) __builtin_unreachable(); } while (false); - } - - - void - swap(_Optional_alloc& __other) noexcept - { - using std::swap; - if constexpr (_AllocTraits::propagate_on_container_swap::value) - swap(_M_alloc, __other._M_alloc); - else if constexpr (!_AllocTraits::is_always_equal::value) - do { if (std::__is_constant_evaluated() && !bool(_M_alloc == __other._M_alloc)) __builtin_unreachable(); } while (false); - } - - - _NodeAlloc& operator*() noexcept { return _M_alloc; } - - - _NodeAlloc release() noexcept - { - _NodeAlloc __tmp = std::move(_M_alloc); - _M_alloc.~_NodeAlloc(); - return __tmp; - } - - struct _Empty { }; - - [[__no_unique_address__]] _Empty _M_empty; - [[__no_unique_address__]] _NodeAlloc _M_alloc; - }; - - [[__no_unique_address__]] _Optional_alloc _M_alloc; - - template - friend class _Rb_tree; - - - }; - - - template - class _Node_handle : public _Node_handle_common<_Value, _NodeAlloc> - { - public: - constexpr _Node_handle() noexcept = default; - ~_Node_handle() = default; - _Node_handle(_Node_handle&&) noexcept = default; - - _Node_handle& - operator=(_Node_handle&&) noexcept = default; - - using key_type = _Key; - using mapped_type = typename _Value::second_type; - - key_type& - key() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __builtin_unreachable(); } while (false); - return *_M_pkey; - } - - mapped_type& - mapped() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __builtin_unreachable(); } while (false); - return *_M_pmapped; - } - - void - swap(_Node_handle& __nh) noexcept - { - this->_M_swap(__nh); - using std::swap; - swap(_M_pkey, __nh._M_pkey); - swap(_M_pmapped, __nh._M_pmapped); - } - - friend void - swap(_Node_handle& __x, _Node_handle& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } - - private: - using _AllocTraits = allocator_traits<_NodeAlloc>; - - _Node_handle(typename _AllocTraits::pointer __ptr, - const _NodeAlloc& __alloc) - : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) - { - if (__ptr) - { - auto& __key = const_cast<_Key&>(__ptr->_M_valptr()->first); - _M_pkey = _S_pointer_to(__key); - _M_pmapped = _S_pointer_to(__ptr->_M_valptr()->second); - } - else - { - _M_pkey = nullptr; - _M_pmapped = nullptr; - } - } - - template - using __pointer - = __ptr_rebind>; - - __pointer<_Key> _M_pkey = nullptr; - __pointer _M_pmapped = nullptr; - - template - __pointer<_Tp> - _S_pointer_to(_Tp& __obj) - { return pointer_traits<__pointer<_Tp>>::pointer_to(__obj); } - - const key_type& - _M_key() const noexcept { return key(); } - - template - friend class _Rb_tree; - - template - friend class _Hashtable; - }; - - - template - class _Node_handle<_Value, _Value, _NodeAlloc> - : public _Node_handle_common<_Value, _NodeAlloc> - { - public: - constexpr _Node_handle() noexcept = default; - ~_Node_handle() = default; - _Node_handle(_Node_handle&&) noexcept = default; - - _Node_handle& - operator=(_Node_handle&&) noexcept = default; - - using value_type = _Value; - - value_type& - value() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(!this->empty())) __builtin_unreachable(); } while (false); - return *this->_M_ptr->_M_valptr(); - } - - void - swap(_Node_handle& __nh) noexcept - { this->_M_swap(__nh); } - - friend void - swap(_Node_handle& __x, _Node_handle& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } - - private: - using _AllocTraits = allocator_traits<_NodeAlloc>; - - _Node_handle(typename _AllocTraits::pointer __ptr, - const _NodeAlloc& __alloc) - : _Node_handle_common<_Value, _NodeAlloc>(__ptr, __alloc) { } - - const value_type& - _M_key() const noexcept { return value(); } - - template - friend class _Rb_tree; - - template - friend class _Hashtable; - }; - - - template - struct _Node_insert_return - { - _Iterator position = _Iterator(); - bool inserted = false; - _NodeHandle node; - }; - - - - -} -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - using __cache_default - = __not_<__and_< - __is_fast_hash<_Hash>, - - __is_nothrow_invocable>>; - - - - - template - using _Hashtable_enable_default_ctor - = _Enable_default_constructor<__and_, - is_default_constructible<_Hash>, - is_default_constructible<_Allocator>>{}, - __detail::_Hash_node_base>; -# 177 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 - template - class _Hashtable - : public __detail::_Hashtable_base<_Key, _Value, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _Traits>, - public __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>, - public __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>, - public __detail::_Rehash_base<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>, - public __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>, - private __detail::_Hashtable_alloc< - __alloc_rebind<_Alloc, - __detail::_Hash_node<_Value, - _Traits::__hash_cached::value>>>, - private _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc> - { - static_assert(is_same::type, _Value>::value, - "unordered container must have a non-const, non-volatile value_type"); - - static_assert(is_same{}, - "unordered container must have the same value_type as its allocator"); - - - using __traits_type = _Traits; - using __hash_cached = typename __traits_type::__hash_cached; - using __constant_iterators = typename __traits_type::__constant_iterators; - using __node_type = __detail::_Hash_node<_Value, __hash_cached::value>; - using __node_alloc_type = __alloc_rebind<_Alloc, __node_type>; - - using __hashtable_alloc = __detail::_Hashtable_alloc<__node_alloc_type>; - - using __node_value_type = - __detail::_Hash_node_value<_Value, __hash_cached::value>; - using __node_ptr = typename __hashtable_alloc::__node_ptr; - using __value_alloc_traits = - typename __hashtable_alloc::__value_alloc_traits; - using __node_alloc_traits = - typename __hashtable_alloc::__node_alloc_traits; - using __node_base = typename __hashtable_alloc::__node_base; - using __node_base_ptr = typename __hashtable_alloc::__node_base_ptr; - using __buckets_ptr = typename __hashtable_alloc::__buckets_ptr; - - using __insert_base = __detail::_Insert<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _Hash, - _RangeHash, _Unused, - _RehashPolicy, _Traits>; - using __enable_default_ctor - = _Hashtable_enable_default_ctor<_Equal, _Hash, _Alloc>; - - public: - typedef _Key key_type; - typedef _Value value_type; - typedef _Alloc allocator_type; - typedef _Equal key_equal; - - - - typedef typename __value_alloc_traits::pointer pointer; - typedef typename __value_alloc_traits::const_pointer const_pointer; - typedef value_type& reference; - typedef const value_type& const_reference; - - using iterator = typename __insert_base::iterator; - - using const_iterator = typename __insert_base::const_iterator; - - using local_iterator = __detail::_Local_iterator; - - using const_local_iterator = __detail::_Local_const_iterator< - key_type, _Value, - _ExtractKey, _Hash, _RangeHash, _Unused, - __constant_iterators::value, __hash_cached::value>; - - private: - using __rehash_type = _RehashPolicy; - using __rehash_state = typename __rehash_type::_State; - - using __unique_keys = typename __traits_type::__unique_keys; - - using __hashtable_base = __detail:: - _Hashtable_base<_Key, _Value, _ExtractKey, - _Equal, _Hash, _RangeHash, _Unused, _Traits>; - - using __hash_code_base = typename __hashtable_base::__hash_code_base; - using __hash_code = typename __hashtable_base::__hash_code; - using __ireturn_type = typename __insert_base::__ireturn_type; - - using __map_base = __detail::_Map_base<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>; - - using __rehash_base = __detail::_Rehash_base<_Key, _Value, _Alloc, - _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>; - - using __eq_base = __detail::_Equality<_Key, _Value, _Alloc, _ExtractKey, - _Equal, _Hash, _RangeHash, _Unused, - _RehashPolicy, _Traits>; - - using __reuse_or_alloc_node_gen_t = - __detail::_ReuseOrAllocNode<__node_alloc_type>; - using __alloc_node_gen_t = - __detail::_AllocNode<__node_alloc_type>; - using __node_builder_t = - __detail::_NodeBuilder<_ExtractKey>; - - - struct _Scoped_node - { - - _Scoped_node(__node_ptr __n, __hashtable_alloc* __h) - : _M_h(__h), _M_node(__n) { } - - - template - _Scoped_node(__hashtable_alloc* __h, _Args&&... __args) - : _M_h(__h), - _M_node(__h->_M_allocate_node(std::forward<_Args>(__args)...)) - { } - - - ~_Scoped_node() { if (_M_node) _M_h->_M_deallocate_node(_M_node); }; - - _Scoped_node(const _Scoped_node&) = delete; - _Scoped_node& operator=(const _Scoped_node&) = delete; - - __hashtable_alloc* _M_h; - __node_ptr _M_node; - }; - - template - static constexpr - __conditional_t::value, - const value_type&, value_type&&> - __fwd_value_for(value_type& __val) noexcept - { return std::move(__val); } - - - - - - struct __hash_code_base_access : __hash_code_base - { using __hash_code_base::_M_bucket_index; }; - - - static_assert(is_nothrow_default_constructible<_RangeHash>::value, - "Functor used to map hash code to bucket index" - " must be nothrow default constructible"); - static_assert(noexcept( - std::declval()((std::size_t)0, (std::size_t)0)), - "Functor used to map hash code to bucket index must be" - " noexcept"); - - - static_assert(is_nothrow_default_constructible<_ExtractKey>::value, - "_ExtractKey must be nothrow default constructible"); - static_assert(noexcept( - std::declval()(std::declval<_Value>())), - "_ExtractKey functor must be noexcept invocable"); - - template - friend struct __detail::_Map_base; - - template - friend struct __detail::_Insert_base; - - template - friend struct __detail::_Insert; - - template - friend struct __detail::_Equality; - - public: - using size_type = typename __hashtable_base::size_type; - using difference_type = typename __hashtable_base::difference_type; - - - using node_type = _Node_handle<_Key, _Value, __node_alloc_type>; - using insert_return_type = _Node_insert_return; - - - private: - __buckets_ptr _M_buckets = &_M_single_bucket; - size_type _M_bucket_count = 1; - __node_base _M_before_begin; - size_type _M_element_count = 0; - _RehashPolicy _M_rehash_policy; - - - - - - - - __node_base_ptr _M_single_bucket = nullptr; - - void - _M_update_bbegin() - { - if (_M_begin()) - _M_buckets[_M_bucket_index(*_M_begin())] = &_M_before_begin; - } - - void - _M_update_bbegin(__node_ptr __n) - { - _M_before_begin._M_nxt = __n; - _M_update_bbegin(); - } - - bool - _M_uses_single_bucket(__buckets_ptr __bkts) const - { return __builtin_expect(__bkts == &_M_single_bucket, false); } - - bool - _M_uses_single_bucket() const - { return _M_uses_single_bucket(_M_buckets); } - - static constexpr size_t - __small_size_threshold() noexcept - { - return - __detail::_Hashtable_hash_traits<_Hash>::__small_size_threshold(); - } - - __hashtable_alloc& - _M_base_alloc() { return *this; } - - __buckets_ptr - _M_allocate_buckets(size_type __bkt_count) - { - if (__builtin_expect(__bkt_count == 1, false)) - { - _M_single_bucket = nullptr; - return &_M_single_bucket; - } - - return __hashtable_alloc::_M_allocate_buckets(__bkt_count); - } - - void - _M_deallocate_buckets(__buckets_ptr __bkts, size_type __bkt_count) - { - if (_M_uses_single_bucket(__bkts)) - return; - - __hashtable_alloc::_M_deallocate_buckets(__bkts, __bkt_count); - } - - void - _M_deallocate_buckets() - { _M_deallocate_buckets(_M_buckets, _M_bucket_count); } - - - - __node_ptr - _M_bucket_begin(size_type __bkt) const; - - __node_ptr - _M_begin() const - { return static_cast<__node_ptr>(_M_before_begin._M_nxt); } - - - - template - void - _M_assign_elements(_Ht&&); - - template - void - _M_assign(_Ht&&, const _NodeGenerator&); - - void - _M_move_assign(_Hashtable&&, true_type); - - void - _M_move_assign(_Hashtable&&, false_type); - - void - _M_reset() noexcept; - - _Hashtable(const _Hash& __h, const _Equal& __eq, - const allocator_type& __a) - : __hashtable_base(__h, __eq), - __hashtable_alloc(__node_alloc_type(__a)), - __enable_default_ctor(_Enable_default_constructor_tag{}) - { } - - template - static constexpr bool - _S_nothrow_move() - { - - - - - - if constexpr (_No_realloc) - if constexpr (is_nothrow_copy_constructible<_Hash>()) - return is_nothrow_copy_constructible<_Equal>(); - return false; - - } - - _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, - true_type ) - noexcept(_S_nothrow_move()); - - _Hashtable(_Hashtable&&, __node_alloc_type&&, - false_type ); - - template - _Hashtable(_InputIterator __first, _InputIterator __last, - size_type __bkt_count_hint, - const _Hash&, const _Equal&, const allocator_type&, - true_type __uks); - - template - _Hashtable(_InputIterator __first, _InputIterator __last, - size_type __bkt_count_hint, - const _Hash&, const _Equal&, const allocator_type&, - false_type __uks); - - public: - - _Hashtable() = default; - - _Hashtable(const _Hashtable&); - - _Hashtable(const _Hashtable&, const allocator_type&); - - explicit - _Hashtable(size_type __bkt_count_hint, - const _Hash& __hf = _Hash(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()); - - - _Hashtable(_Hashtable&& __ht) - noexcept(_S_nothrow_move()) - : _Hashtable(std::move(__ht), std::move(__ht._M_node_allocator()), - true_type{}) - { } - - _Hashtable(_Hashtable&& __ht, const allocator_type& __a) - noexcept(_S_nothrow_move<__node_alloc_traits::_S_always_equal()>()) - : _Hashtable(std::move(__ht), __node_alloc_type(__a), - typename __node_alloc_traits::is_always_equal{}) - { } - - explicit - _Hashtable(const allocator_type& __a) - : __hashtable_alloc(__node_alloc_type(__a)), - __enable_default_ctor(_Enable_default_constructor_tag{}) - { } - - template - _Hashtable(_InputIterator __f, _InputIterator __l, - size_type __bkt_count_hint = 0, - const _Hash& __hf = _Hash(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _Hashtable(__f, __l, __bkt_count_hint, __hf, __eql, __a, - __unique_keys{}) - { } - - _Hashtable(initializer_list __l, - size_type __bkt_count_hint = 0, - const _Hash& __hf = _Hash(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _Hashtable(__l.begin(), __l.end(), __bkt_count_hint, - __hf, __eql, __a, __unique_keys{}) - { } - - _Hashtable& - operator=(const _Hashtable& __ht); - - _Hashtable& - operator=(_Hashtable&& __ht) - noexcept(__node_alloc_traits::_S_nothrow_move() - && is_nothrow_move_assignable<_Hash>::value - && is_nothrow_move_assignable<_Equal>::value) - { - constexpr bool __move_storage = - __node_alloc_traits::_S_propagate_on_move_assign() - || __node_alloc_traits::_S_always_equal(); - _M_move_assign(std::move(__ht), __bool_constant<__move_storage>()); - return *this; - } - - _Hashtable& - operator=(initializer_list __l) - { - __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); - _M_before_begin._M_nxt = nullptr; - clear(); - - - auto __l_bkt_count = _M_rehash_policy._M_bkt_for_elements(__l.size()); - - - if (_M_bucket_count < __l_bkt_count) - rehash(__l_bkt_count); - - this->_M_insert_range(__l.begin(), __l.end(), __roan, __unique_keys{}); - return *this; - } - - ~_Hashtable() noexcept; - - void - swap(_Hashtable&) - noexcept(__and_<__is_nothrow_swappable<_Hash>, - __is_nothrow_swappable<_Equal>>::value); - - - iterator - begin() noexcept - { return iterator(_M_begin()); } - - const_iterator - begin() const noexcept - { return const_iterator(_M_begin()); } - - iterator - end() noexcept - { return iterator(nullptr); } - - const_iterator - end() const noexcept - { return const_iterator(nullptr); } - - const_iterator - cbegin() const noexcept - { return const_iterator(_M_begin()); } - - const_iterator - cend() const noexcept - { return const_iterator(nullptr); } - - size_type - size() const noexcept - { return _M_element_count; } - - [[__nodiscard__]] bool - empty() const noexcept - { return size() == 0; } - - allocator_type - get_allocator() const noexcept - { return allocator_type(this->_M_node_allocator()); } - - size_type - max_size() const noexcept - { return __node_alloc_traits::max_size(this->_M_node_allocator()); } - - - key_equal - key_eq() const - { return this->_M_eq(); } - - - - - size_type - bucket_count() const noexcept - { return _M_bucket_count; } - - size_type - max_bucket_count() const noexcept - { return max_size(); } - - size_type - bucket_size(size_type __bkt) const - { return std::distance(begin(__bkt), end(__bkt)); } - - size_type - bucket(const key_type& __k) const - { return _M_bucket_index(this->_M_hash_code(__k)); } - - local_iterator - begin(size_type __bkt) - { - return local_iterator(*this, _M_bucket_begin(__bkt), - __bkt, _M_bucket_count); - } - - local_iterator - end(size_type __bkt) - { return local_iterator(*this, nullptr, __bkt, _M_bucket_count); } - - const_local_iterator - begin(size_type __bkt) const - { - return const_local_iterator(*this, _M_bucket_begin(__bkt), - __bkt, _M_bucket_count); - } - - const_local_iterator - end(size_type __bkt) const - { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } - - - const_local_iterator - cbegin(size_type __bkt) const - { - return const_local_iterator(*this, _M_bucket_begin(__bkt), - __bkt, _M_bucket_count); - } - - const_local_iterator - cend(size_type __bkt) const - { return const_local_iterator(*this, nullptr, __bkt, _M_bucket_count); } - - float - load_factor() const noexcept - { - return static_cast(size()) / static_cast(bucket_count()); - } - - - - - - - const _RehashPolicy& - __rehash_policy() const - { return _M_rehash_policy; } - - void - __rehash_policy(const _RehashPolicy& __pol) - { _M_rehash_policy = __pol; } - - - iterator - find(const key_type& __k); - - const_iterator - find(const key_type& __k) const; - - size_type - count(const key_type& __k) const; - - std::pair - equal_range(const key_type& __k); - - std::pair - equal_range(const key_type& __k) const; -# 789 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 - private: - - size_type - _M_bucket_index(const __node_value_type& __n) const noexcept - { return __hash_code_base::_M_bucket_index(__n, _M_bucket_count); } - - size_type - _M_bucket_index(__hash_code __c) const - { return __hash_code_base::_M_bucket_index(__c, _M_bucket_count); } - - __node_base_ptr - _M_find_before_node(const key_type&); - - - - __node_base_ptr - _M_find_before_node(size_type, const key_type&, __hash_code) const; - - template - __node_base_ptr - _M_find_before_node_tr(size_type, const _Kt&, __hash_code) const; - - __node_ptr - _M_find_node(size_type __bkt, const key_type& __key, - __hash_code __c) const - { - __node_base_ptr __before_n = _M_find_before_node(__bkt, __key, __c); - if (__before_n) - return static_cast<__node_ptr>(__before_n->_M_nxt); - return nullptr; - } - - template - __node_ptr - _M_find_node_tr(size_type __bkt, const _Kt& __key, - __hash_code __c) const - { - auto __before_n = _M_find_before_node_tr(__bkt, __key, __c); - if (__before_n) - return static_cast<__node_ptr>(__before_n->_M_nxt); - return nullptr; - } - - - void - _M_insert_bucket_begin(size_type, __node_ptr); - - - void - _M_remove_bucket_begin(size_type __bkt, __node_ptr __next_n, - size_type __next_bkt); - - - __node_base_ptr - _M_get_previous_node(size_type __bkt, __node_ptr __n); - - pair - _M_compute_hash_code(const_iterator __hint, const key_type& __k) const; - - - - - iterator - _M_insert_unique_node(size_type __bkt, __hash_code, - __node_ptr __n, size_type __n_elt = 1); - - - - iterator - _M_insert_multi_node(__node_ptr __hint, - __hash_code __code, __node_ptr __n); - - template - std::pair - _M_emplace(true_type __uks, _Args&&... __args); - - template - iterator - _M_emplace(false_type __uks, _Args&&... __args) - { return _M_emplace(cend(), __uks, std::forward<_Args>(__args)...); } - - - template - iterator - _M_emplace(const_iterator, true_type __uks, _Args&&... __args) - { return _M_emplace(__uks, std::forward<_Args>(__args)...).first; } - - template - iterator - _M_emplace(const_iterator, false_type __uks, _Args&&... __args); - - template - std::pair - _M_insert_unique(_Kt&&, _Arg&&, const _NodeGenerator&); - - template - static __conditional_t< - __and_<__is_nothrow_invocable<_Hash&, const key_type&>, - __not_<__is_nothrow_invocable<_Hash&, _Kt>>>::value, - key_type, _Kt&&> - _S_forward_key(_Kt&& __k) - { return std::forward<_Kt>(__k); } - - static const key_type& - _S_forward_key(const key_type& __k) - { return __k; } - - static key_type&& - _S_forward_key(key_type&& __k) - { return std::move(__k); } - - template - std::pair - _M_insert_unique_aux(_Arg&& __arg, const _NodeGenerator& __node_gen) - { - return _M_insert_unique( - _S_forward_key(_ExtractKey{}(std::forward<_Arg>(__arg))), - std::forward<_Arg>(__arg), __node_gen); - } - - template - std::pair - _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, - true_type ) - { - using __to_value - = __detail::_ConvertToValueType<_ExtractKey, value_type>; - return _M_insert_unique_aux( - __to_value{}(std::forward<_Arg>(__arg)), __node_gen); - } - - template - iterator - _M_insert(_Arg&& __arg, const _NodeGenerator& __node_gen, - false_type __uks) - { - using __to_value - = __detail::_ConvertToValueType<_ExtractKey, value_type>; - return _M_insert(cend(), - __to_value{}(std::forward<_Arg>(__arg)), __node_gen, __uks); - } - - - template - iterator - _M_insert(const_iterator, _Arg&& __arg, - const _NodeGenerator& __node_gen, true_type __uks) - { - return - _M_insert(std::forward<_Arg>(__arg), __node_gen, __uks).first; - } - - - template - iterator - _M_insert(const_iterator, _Arg&&, - const _NodeGenerator&, false_type __uks); - - size_type - _M_erase(true_type __uks, const key_type&); - - size_type - _M_erase(false_type __uks, const key_type&); - - iterator - _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n); - - public: - - template - __ireturn_type - emplace(_Args&&... __args) - { return _M_emplace(__unique_keys{}, std::forward<_Args>(__args)...); } - - template - iterator - emplace_hint(const_iterator __hint, _Args&&... __args) - { - return _M_emplace(__hint, __unique_keys{}, - std::forward<_Args>(__args)...); - } - - - - - iterator - erase(const_iterator); - - - iterator - erase(iterator __it) - { return erase(const_iterator(__it)); } - - size_type - erase(const key_type& __k) - { return _M_erase(__unique_keys{}, __k); } - - iterator - erase(const_iterator, const_iterator); - - void - clear() noexcept; - - - - void rehash(size_type __bkt_count); - - - - - - - insert_return_type - _M_reinsert_node(node_type&& __nh) - { - insert_return_type __ret; - if (__nh.empty()) - __ret.position = end(); - else - { - do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __nh.get_allocator())) __builtin_unreachable(); } while (false); - - const key_type& __k = __nh._M_key(); - __hash_code __code = this->_M_hash_code(__k); - size_type __bkt = _M_bucket_index(__code); - if (__node_ptr __n = _M_find_node(__bkt, __k, __code)) - { - __ret.node = std::move(__nh); - __ret.position = iterator(__n); - __ret.inserted = false; - } - else - { - __ret.position - = _M_insert_unique_node(__bkt, __code, __nh._M_ptr); - __nh._M_ptr = nullptr; - __ret.inserted = true; - } - } - return __ret; - } - - - iterator - _M_reinsert_node_multi(const_iterator __hint, node_type&& __nh) - { - if (__nh.empty()) - return end(); - - do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __nh.get_allocator())) __builtin_unreachable(); } while (false); - - const key_type& __k = __nh._M_key(); - auto __code = this->_M_hash_code(__k); - auto __ret - = _M_insert_multi_node(__hint._M_cur, __code, __nh._M_ptr); - __nh._M_ptr = nullptr; - return __ret; - } - - private: - node_type - _M_extract_node(size_t __bkt, __node_base_ptr __prev_n) - { - __node_ptr __n = static_cast<__node_ptr>(__prev_n->_M_nxt); - if (__prev_n == _M_buckets[__bkt]) - _M_remove_bucket_begin(__bkt, __n->_M_next(), - __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0); - else if (__n->_M_nxt) - { - size_type __next_bkt = _M_bucket_index(*__n->_M_next()); - if (__next_bkt != __bkt) - _M_buckets[__next_bkt] = __prev_n; - } - - __prev_n->_M_nxt = __n->_M_nxt; - __n->_M_nxt = nullptr; - --_M_element_count; - return { __n, this->_M_node_allocator() }; - } - - public: - - node_type - extract(const_iterator __pos) - { - size_t __bkt = _M_bucket_index(*__pos._M_cur); - return _M_extract_node(__bkt, - _M_get_previous_node(__bkt, __pos._M_cur)); - } - - - node_type - extract(const _Key& __k) - { - node_type __nh; - __hash_code __code = this->_M_hash_code(__k); - std::size_t __bkt = _M_bucket_index(__code); - if (__node_base_ptr __prev_node = _M_find_before_node(__bkt, __k, __code)) - __nh = _M_extract_node(__bkt, __prev_node); - return __nh; - } - - - template - void - _M_merge_unique(_Compatible_Hashtable& __src) - { - static_assert(is_same_v, "Node types are compatible"); - do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) __builtin_unreachable(); } while (false); - - auto __n_elt = __src.size(); - for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;) - { - auto __pos = __i++; - const key_type& __k = _ExtractKey{}(*__pos); - __hash_code __code - = this->_M_hash_code(__src.hash_function(), *__pos._M_cur); - size_type __bkt = _M_bucket_index(__code); - if (_M_find_node(__bkt, __k, __code) == nullptr) - { - auto __nh = __src.extract(__pos); - _M_insert_unique_node(__bkt, __code, __nh._M_ptr, __n_elt); - __nh._M_ptr = nullptr; - __n_elt = 1; - } - else if (__n_elt != 1) - --__n_elt; - } - } - - - template - void - _M_merge_multi(_Compatible_Hashtable& __src) - { - static_assert(is_same_v, "Node types are compatible"); - do { if (std::__is_constant_evaluated() && !bool(get_allocator() == __src.get_allocator())) __builtin_unreachable(); } while (false); - - __node_ptr __hint = nullptr; - this->reserve(size() + __src.size()); - for (auto __i = __src.cbegin(), __end = __src.cend(); __i != __end;) - { - auto __pos = __i++; - __hash_code __code - = this->_M_hash_code(__src.hash_function(), *__pos._M_cur); - auto __nh = __src.extract(__pos); - __hint = _M_insert_multi_node(__hint, __code, __nh._M_ptr)._M_cur; - __nh._M_ptr = nullptr; - } - } - - - private: - - void _M_rehash_aux(size_type __bkt_count, true_type __uks); - - - void _M_rehash_aux(size_type __bkt_count, false_type __uks); - - - - void _M_rehash(size_type __bkt_count, const __rehash_state& __state); - }; - - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_bucket_begin(size_type __bkt) const - -> __node_ptr - { - __node_base_ptr __n = _M_buckets[__bkt]; - return __n ? static_cast<__node_ptr>(__n->_M_nxt) : nullptr; - } - - template - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _Hashtable(size_type __bkt_count_hint, - const _Hash& __h, const _Equal& __eq, const allocator_type& __a) - : _Hashtable(__h, __eq, __a) - { - auto __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count_hint); - if (__bkt_count > _M_bucket_count) - { - _M_buckets = _M_allocate_buckets(__bkt_count); - _M_bucket_count = __bkt_count; - } - } - - template - template - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _Hashtable(_InputIterator __f, _InputIterator __l, - size_type __bkt_count_hint, - const _Hash& __h, const _Equal& __eq, - const allocator_type& __a, true_type ) - : _Hashtable(__bkt_count_hint, __h, __eq, __a) - { this->insert(__f, __l); } - - template - template - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _Hashtable(_InputIterator __f, _InputIterator __l, - size_type __bkt_count_hint, - const _Hash& __h, const _Equal& __eq, - const allocator_type& __a, false_type __uks) - : _Hashtable(__h, __eq, __a) - { - auto __nb_elems = __detail::__distance_fw(__f, __l); - auto __bkt_count = - _M_rehash_policy._M_next_bkt( - std::max(_M_rehash_policy._M_bkt_for_elements(__nb_elems), - __bkt_count_hint)); - - if (__bkt_count > _M_bucket_count) - { - _M_buckets = _M_allocate_buckets(__bkt_count); - _M_bucket_count = __bkt_count; - } - - __alloc_node_gen_t __node_gen(*this); - for (; __f != __l; ++__f) - _M_insert(*__f, __node_gen, __uks); - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - operator=(const _Hashtable& __ht) - -> _Hashtable& - { - if (&__ht == this) - return *this; - - if (__node_alloc_traits::_S_propagate_on_copy_assign()) - { - auto& __this_alloc = this->_M_node_allocator(); - auto& __that_alloc = __ht._M_node_allocator(); - if (!__node_alloc_traits::_S_always_equal() - && __this_alloc != __that_alloc) - { - - this->_M_deallocate_nodes(_M_begin()); - _M_before_begin._M_nxt = nullptr; - _M_deallocate_buckets(); - _M_buckets = nullptr; - std::__alloc_on_copy(__this_alloc, __that_alloc); - __hashtable_base::operator=(__ht); - _M_bucket_count = __ht._M_bucket_count; - _M_element_count = __ht._M_element_count; - _M_rehash_policy = __ht._M_rehash_policy; - __alloc_node_gen_t __alloc_node_gen(*this); - try - { - _M_assign(__ht, __alloc_node_gen); - } - catch(...) - { - - - _M_reset(); - throw; - } - return *this; - } - std::__alloc_on_copy(__this_alloc, __that_alloc); - } - - - _M_assign_elements(__ht); - return *this; - } - - template - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_assign_elements(_Ht&& __ht) - { - __buckets_ptr __former_buckets = nullptr; - std::size_t __former_bucket_count = _M_bucket_count; - const __rehash_state& __former_state = _M_rehash_policy._M_state(); - - if (_M_bucket_count != __ht._M_bucket_count) - { - __former_buckets = _M_buckets; - _M_buckets = _M_allocate_buckets(__ht._M_bucket_count); - _M_bucket_count = __ht._M_bucket_count; - } - else - __builtin_memset(_M_buckets, 0, - _M_bucket_count * sizeof(__node_base_ptr)); - - try - { - __hashtable_base::operator=(std::forward<_Ht>(__ht)); - _M_element_count = __ht._M_element_count; - _M_rehash_policy = __ht._M_rehash_policy; - __reuse_or_alloc_node_gen_t __roan(_M_begin(), *this); - _M_before_begin._M_nxt = nullptr; - _M_assign(std::forward<_Ht>(__ht), __roan); - if (__former_buckets) - _M_deallocate_buckets(__former_buckets, __former_bucket_count); - } - catch(...) - { - if (__former_buckets) - { - - _M_deallocate_buckets(); - _M_rehash_policy._M_reset(__former_state); - _M_buckets = __former_buckets; - _M_bucket_count = __former_bucket_count; - } - __builtin_memset(_M_buckets, 0, - _M_bucket_count * sizeof(__node_base_ptr)); - throw; - } - } - - template - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_assign(_Ht&& __ht, const _NodeGenerator& __node_gen) - { - __buckets_ptr __buckets = nullptr; - if (!_M_buckets) - _M_buckets = __buckets = _M_allocate_buckets(_M_bucket_count); - - try - { - if (!__ht._M_before_begin._M_nxt) - return; - - - - __node_ptr __ht_n = __ht._M_begin(); - __node_ptr __this_n - = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); - this->_M_copy_code(*__this_n, *__ht_n); - _M_update_bbegin(__this_n); - - - __node_ptr __prev_n = __this_n; - for (__ht_n = __ht_n->_M_next(); __ht_n; __ht_n = __ht_n->_M_next()) - { - __this_n = __node_gen(__fwd_value_for<_Ht>(__ht_n->_M_v())); - __prev_n->_M_nxt = __this_n; - this->_M_copy_code(*__this_n, *__ht_n); - size_type __bkt = _M_bucket_index(*__this_n); - if (!_M_buckets[__bkt]) - _M_buckets[__bkt] = __prev_n; - __prev_n = __this_n; - } - } - catch(...) - { - clear(); - if (__buckets) - _M_deallocate_buckets(); - throw; - } - } - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_reset() noexcept - { - _M_rehash_policy._M_reset(); - _M_bucket_count = 1; - _M_single_bucket = nullptr; - _M_buckets = &_M_single_bucket; - _M_before_begin._M_nxt = nullptr; - _M_element_count = 0; - } - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_move_assign(_Hashtable&& __ht, true_type) - { - if (__builtin_expect(std::__addressof(__ht) == this, false)) - return; - - this->_M_deallocate_nodes(_M_begin()); - _M_deallocate_buckets(); - __hashtable_base::operator=(std::move(__ht)); - _M_rehash_policy = __ht._M_rehash_policy; - if (!__ht._M_uses_single_bucket()) - _M_buckets = __ht._M_buckets; - else - { - _M_buckets = &_M_single_bucket; - _M_single_bucket = __ht._M_single_bucket; - } - - _M_bucket_count = __ht._M_bucket_count; - _M_before_begin._M_nxt = __ht._M_before_begin._M_nxt; - _M_element_count = __ht._M_element_count; - std::__alloc_on_move(this->_M_node_allocator(), __ht._M_node_allocator()); - - - _M_update_bbegin(); - __ht._M_reset(); - } - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_move_assign(_Hashtable&& __ht, false_type) - { - if (__ht._M_node_allocator() == this->_M_node_allocator()) - _M_move_assign(std::move(__ht), true_type{}); - else - { - - _M_assign_elements(std::move(__ht)); - __ht.clear(); - } - } - - template - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _Hashtable(const _Hashtable& __ht) - : __hashtable_base(__ht), - __map_base(__ht), - __rehash_base(__ht), - __hashtable_alloc( - __node_alloc_traits::_S_select_on_copy(__ht._M_node_allocator())), - __enable_default_ctor(__ht), - _M_buckets(nullptr), - _M_bucket_count(__ht._M_bucket_count), - _M_element_count(__ht._M_element_count), - _M_rehash_policy(__ht._M_rehash_policy) - { - __alloc_node_gen_t __alloc_node_gen(*this); - _M_assign(__ht, __alloc_node_gen); - } - - template - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, - true_type ) - noexcept(_S_nothrow_move()) - : __hashtable_base(__ht), - __map_base(__ht), - __rehash_base(__ht), - __hashtable_alloc(std::move(__a)), - __enable_default_ctor(__ht), - _M_buckets(__ht._M_buckets), - _M_bucket_count(__ht._M_bucket_count), - _M_before_begin(__ht._M_before_begin._M_nxt), - _M_element_count(__ht._M_element_count), - _M_rehash_policy(__ht._M_rehash_policy) - { - - if (__ht._M_uses_single_bucket()) - { - _M_buckets = &_M_single_bucket; - _M_single_bucket = __ht._M_single_bucket; - } - - - _M_update_bbegin(); - - __ht._M_reset(); - } - - template - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _Hashtable(const _Hashtable& __ht, const allocator_type& __a) - : __hashtable_base(__ht), - __map_base(__ht), - __rehash_base(__ht), - __hashtable_alloc(__node_alloc_type(__a)), - __enable_default_ctor(__ht), - _M_buckets(), - _M_bucket_count(__ht._M_bucket_count), - _M_element_count(__ht._M_element_count), - _M_rehash_policy(__ht._M_rehash_policy) - { - __alloc_node_gen_t __alloc_node_gen(*this); - _M_assign(__ht, __alloc_node_gen); - } - - template - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _Hashtable(_Hashtable&& __ht, __node_alloc_type&& __a, - false_type ) - : __hashtable_base(__ht), - __map_base(__ht), - __rehash_base(__ht), - __hashtable_alloc(std::move(__a)), - __enable_default_ctor(__ht), - _M_buckets(nullptr), - _M_bucket_count(__ht._M_bucket_count), - _M_element_count(__ht._M_element_count), - _M_rehash_policy(__ht._M_rehash_policy) - { - if (__ht._M_node_allocator() == this->_M_node_allocator()) - { - if (__ht._M_uses_single_bucket()) - { - _M_buckets = &_M_single_bucket; - _M_single_bucket = __ht._M_single_bucket; - } - else - _M_buckets = __ht._M_buckets; - - - - _M_update_bbegin(__ht._M_begin()); - - __ht._M_reset(); - } - else - { - __alloc_node_gen_t __alloc_gen(*this); - - using _Fwd_Ht = __conditional_t< - __move_if_noexcept_cond::value, - const _Hashtable&, _Hashtable&&>; - _M_assign(std::forward<_Fwd_Ht>(__ht), __alloc_gen); - __ht.clear(); - } - } - - template - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - ~_Hashtable() noexcept - { - - - - static_assert(noexcept(declval() - ._M_bucket_index(declval(), - (std::size_t)0)), - "Cache the hash code or qualify your functors involved" - " in hash code and bucket index computation with noexcept"); - - clear(); - _M_deallocate_buckets(); - } - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - swap(_Hashtable& __x) - noexcept(__and_<__is_nothrow_swappable<_Hash>, - __is_nothrow_swappable<_Equal>>::value) - { - - - - this->_M_swap(__x); - - std::__alloc_on_swap(this->_M_node_allocator(), __x._M_node_allocator()); - std::swap(_M_rehash_policy, __x._M_rehash_policy); - - - if (this->_M_uses_single_bucket()) - { - if (!__x._M_uses_single_bucket()) - { - _M_buckets = __x._M_buckets; - __x._M_buckets = &__x._M_single_bucket; - } - } - else if (__x._M_uses_single_bucket()) - { - __x._M_buckets = _M_buckets; - _M_buckets = &_M_single_bucket; - } - else - std::swap(_M_buckets, __x._M_buckets); - - std::swap(_M_bucket_count, __x._M_bucket_count); - std::swap(_M_before_begin._M_nxt, __x._M_before_begin._M_nxt); - std::swap(_M_element_count, __x._M_element_count); - std::swap(_M_single_bucket, __x._M_single_bucket); - - - - _M_update_bbegin(); - __x._M_update_bbegin(); - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - find(const key_type& __k) - -> iterator - { - if (size() <= __small_size_threshold()) - { - for (auto __it = begin(); __it != end(); ++__it) - if (this->_M_key_equals(__k, *__it._M_cur)) - return __it; - return end(); - } - - __hash_code __code = this->_M_hash_code(__k); - std::size_t __bkt = _M_bucket_index(__code); - return iterator(_M_find_node(__bkt, __k, __code)); - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - find(const key_type& __k) const - -> const_iterator - { - if (size() <= __small_size_threshold()) - { - for (auto __it = begin(); __it != end(); ++__it) - if (this->_M_key_equals(__k, *__it._M_cur)) - return __it; - return end(); - } - - __hash_code __code = this->_M_hash_code(__k); - std::size_t __bkt = _M_bucket_index(__code); - return const_iterator(_M_find_node(__bkt, __k, __code)); - } -# 1724 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - count(const key_type& __k) const - -> size_type - { - auto __it = find(__k); - if (!__it._M_cur) - return 0; - - if (__unique_keys::value) - return 1; - - - - - size_type __result = 1; - for (auto __ref = __it++; - __it._M_cur && this->_M_node_equals(*__ref._M_cur, *__it._M_cur); - ++__it) - ++__result; - - return __result; - } -# 1785 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - equal_range(const key_type& __k) - -> pair - { - auto __ite = find(__k); - if (!__ite._M_cur) - return { __ite, __ite }; - - auto __beg = __ite++; - if (__unique_keys::value) - return { __beg, __ite }; - - - - - while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur)) - ++__ite; - - return { __beg, __ite }; - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - equal_range(const key_type& __k) const - -> pair - { - auto __ite = find(__k); - if (!__ite._M_cur) - return { __ite, __ite }; - - auto __beg = __ite++; - if (__unique_keys::value) - return { __beg, __ite }; - - - - - while (__ite._M_cur && this->_M_node_equals(*__beg._M_cur, *__ite._M_cur)) - ++__ite; - - return { __beg, __ite }; - } -# 1899 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hashtable.h" 3 - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_find_before_node(const key_type& __k) - -> __node_base_ptr - { - __node_base_ptr __prev_p = &_M_before_begin; - if (!__prev_p->_M_nxt) - return nullptr; - - for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt); - __p != nullptr; - __p = __p->_M_next()) - { - if (this->_M_key_equals(__k, *__p)) - return __prev_p; - - __prev_p = __p; - } - - return nullptr; - } - - - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_find_before_node(size_type __bkt, const key_type& __k, - __hash_code __code) const - -> __node_base_ptr - { - __node_base_ptr __prev_p = _M_buckets[__bkt]; - if (!__prev_p) - return nullptr; - - for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);; - __p = __p->_M_next()) - { - if (this->_M_equals(__k, __code, *__p)) - return __prev_p; - - if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt) - break; - __prev_p = __p; - } - - return nullptr; - } - - template - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_find_before_node_tr(size_type __bkt, const _Kt& __k, - __hash_code __code) const - -> __node_base_ptr - { - __node_base_ptr __prev_p = _M_buckets[__bkt]; - if (!__prev_p) - return nullptr; - - for (__node_ptr __p = static_cast<__node_ptr>(__prev_p->_M_nxt);; - __p = __p->_M_next()) - { - if (this->_M_equals_tr(__k, __code, *__p)) - return __prev_p; - - if (!__p->_M_nxt || _M_bucket_index(*__p->_M_next()) != __bkt) - break; - __prev_p = __p; - } - - return nullptr; - } - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_insert_bucket_begin(size_type __bkt, __node_ptr __node) - { - if (_M_buckets[__bkt]) - { - - - __node->_M_nxt = _M_buckets[__bkt]->_M_nxt; - _M_buckets[__bkt]->_M_nxt = __node; - } - else - { - - - - __node->_M_nxt = _M_before_begin._M_nxt; - _M_before_begin._M_nxt = __node; - - if (__node->_M_nxt) - - - _M_buckets[_M_bucket_index(*__node->_M_next())] = __node; - - _M_buckets[__bkt] = &_M_before_begin; - } - } - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_remove_bucket_begin(size_type __bkt, __node_ptr __next, - size_type __next_bkt) - { - if (!__next || __next_bkt != __bkt) - { - - - if (__next) - _M_buckets[__next_bkt] = _M_buckets[__bkt]; - - - if (&_M_before_begin == _M_buckets[__bkt]) - _M_before_begin._M_nxt = __next; - _M_buckets[__bkt] = nullptr; - } - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_get_previous_node(size_type __bkt, __node_ptr __n) - -> __node_base_ptr - { - __node_base_ptr __prev_n = _M_buckets[__bkt]; - while (__prev_n->_M_nxt != __n) - __prev_n = __prev_n->_M_nxt; - return __prev_n; - } - - template - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_emplace(true_type , _Args&&... __args) - -> pair - { - - _Scoped_node __node { this, std::forward<_Args>(__args)... }; - const key_type& __k = _ExtractKey{}(__node._M_node->_M_v()); - if (size() <= __small_size_threshold()) - { - for (auto __it = begin(); __it != end(); ++__it) - if (this->_M_key_equals(__k, *__it._M_cur)) - - return { __it, false }; - } - - __hash_code __code = this->_M_hash_code(__k); - size_type __bkt = _M_bucket_index(__code); - if (size() > __small_size_threshold()) - if (__node_ptr __p = _M_find_node(__bkt, __k, __code)) - - return { iterator(__p), false }; - - - auto __pos = _M_insert_unique_node(__bkt, __code, __node._M_node); - __node._M_node = nullptr; - return { __pos, true }; - } - - template - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_emplace(const_iterator __hint, false_type , - _Args&&... __args) - -> iterator - { - - _Scoped_node __node { this, std::forward<_Args>(__args)... }; - const key_type& __k = _ExtractKey{}(__node._M_node->_M_v()); - - auto __res = this->_M_compute_hash_code(__hint, __k); - auto __pos - = _M_insert_multi_node(__res.first._M_cur, __res.second, - __node._M_node); - __node._M_node = nullptr; - return __pos; - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_compute_hash_code(const_iterator __hint, const key_type& __k) const - -> pair - { - if (size() <= __small_size_threshold()) - { - if (__hint != cend()) - { - for (auto __it = __hint; __it != cend(); ++__it) - if (this->_M_key_equals(__k, *__it._M_cur)) - return { __it, this->_M_hash_code(*__it._M_cur) }; - } - - for (auto __it = cbegin(); __it != __hint; ++__it) - if (this->_M_key_equals(__k, *__it._M_cur)) - return { __it, this->_M_hash_code(*__it._M_cur) }; - } - - return { __hint, this->_M_hash_code(__k) }; - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_insert_unique_node(size_type __bkt, __hash_code __code, - __node_ptr __node, size_type __n_elt) - -> iterator - { - const __rehash_state& __saved_state = _M_rehash_policy._M_state(); - std::pair __do_rehash - = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, - __n_elt); - - if (__do_rehash.first) - { - _M_rehash(__do_rehash.second, __saved_state); - __bkt = _M_bucket_index(__code); - } - - this->_M_store_code(*__node, __code); - - - _M_insert_bucket_begin(__bkt, __node); - ++_M_element_count; - return iterator(__node); - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_insert_multi_node(__node_ptr __hint, - __hash_code __code, __node_ptr __node) - -> iterator - { - const __rehash_state& __saved_state = _M_rehash_policy._M_state(); - std::pair __do_rehash - = _M_rehash_policy._M_need_rehash(_M_bucket_count, _M_element_count, 1); - - if (__do_rehash.first) - _M_rehash(__do_rehash.second, __saved_state); - - this->_M_store_code(*__node, __code); - const key_type& __k = _ExtractKey{}(__node->_M_v()); - size_type __bkt = _M_bucket_index(__code); - - - - __node_base_ptr __prev - = __builtin_expect(__hint != nullptr, false) - && this->_M_equals(__k, __code, *__hint) - ? __hint - : _M_find_before_node(__bkt, __k, __code); - - if (__prev) - { - - __node->_M_nxt = __prev->_M_nxt; - __prev->_M_nxt = __node; - if (__builtin_expect(__prev == __hint, false)) - - - if (__node->_M_nxt - && !this->_M_equals(__k, __code, *__node->_M_next())) - { - size_type __next_bkt = _M_bucket_index(*__node->_M_next()); - if (__next_bkt != __bkt) - _M_buckets[__next_bkt] = __node; - } - } - else - - - - _M_insert_bucket_begin(__bkt, __node); - ++_M_element_count; - return iterator(__node); - } - - - template - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_insert_unique(_Kt&& __k, _Arg&& __v, - const _NodeGenerator& __node_gen) - -> pair - { - if (size() <= __small_size_threshold()) - for (auto __it = begin(); __it != end(); ++__it) - if (this->_M_key_equals_tr(__k, *__it._M_cur)) - return { __it, false }; - - __hash_code __code = this->_M_hash_code_tr(__k); - size_type __bkt = _M_bucket_index(__code); - - if (size() > __small_size_threshold()) - if (__node_ptr __node = _M_find_node_tr(__bkt, __k, __code)) - return { iterator(__node), false }; - - _Scoped_node __node { - __node_builder_t::_S_build(std::forward<_Kt>(__k), - std::forward<_Arg>(__v), - __node_gen), - this - }; - auto __pos - = _M_insert_unique_node(__bkt, __code, __node._M_node); - __node._M_node = nullptr; - return { __pos, true }; - } - - - template - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_insert(const_iterator __hint, _Arg&& __v, - const _NodeGenerator& __node_gen, - false_type ) - -> iterator - { - - _Scoped_node __node{ __node_gen(std::forward<_Arg>(__v)), this }; - - - auto __res = this->_M_compute_hash_code( - __hint, _ExtractKey{}(__node._M_node->_M_v())); - - auto __pos - = _M_insert_multi_node(__res.first._M_cur, __res.second, - __node._M_node); - __node._M_node = nullptr; - return __pos; - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - erase(const_iterator __it) - -> iterator - { - __node_ptr __n = __it._M_cur; - std::size_t __bkt = _M_bucket_index(*__n); - - - - - __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n); - return _M_erase(__bkt, __prev_n, __n); - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_erase(size_type __bkt, __node_base_ptr __prev_n, __node_ptr __n) - -> iterator - { - if (__prev_n == _M_buckets[__bkt]) - _M_remove_bucket_begin(__bkt, __n->_M_next(), - __n->_M_nxt ? _M_bucket_index(*__n->_M_next()) : 0); - else if (__n->_M_nxt) - { - size_type __next_bkt = _M_bucket_index(*__n->_M_next()); - if (__next_bkt != __bkt) - _M_buckets[__next_bkt] = __prev_n; - } - - __prev_n->_M_nxt = __n->_M_nxt; - iterator __result(__n->_M_next()); - this->_M_deallocate_node(__n); - --_M_element_count; - - return __result; - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_erase(true_type , const key_type& __k) - -> size_type - { - __node_base_ptr __prev_n; - __node_ptr __n; - std::size_t __bkt; - if (size() <= __small_size_threshold()) - { - __prev_n = _M_find_before_node(__k); - if (!__prev_n) - return 0; - - - __n = static_cast<__node_ptr>(__prev_n->_M_nxt); - __bkt = _M_bucket_index(*__n); - } - else - { - __hash_code __code = this->_M_hash_code(__k); - __bkt = _M_bucket_index(__code); - - - __prev_n = _M_find_before_node(__bkt, __k, __code); - if (!__prev_n) - return 0; - - - __n = static_cast<__node_ptr>(__prev_n->_M_nxt); - } - - _M_erase(__bkt, __prev_n, __n); - return 1; - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_erase(false_type , const key_type& __k) - -> size_type - { - std::size_t __bkt; - __node_base_ptr __prev_n; - __node_ptr __n; - if (size() <= __small_size_threshold()) - { - __prev_n = _M_find_before_node(__k); - if (!__prev_n) - return 0; - - - __n = static_cast<__node_ptr>(__prev_n->_M_nxt); - __bkt = _M_bucket_index(*__n); - } - else - { - __hash_code __code = this->_M_hash_code(__k); - __bkt = _M_bucket_index(__code); - - - __prev_n = _M_find_before_node(__bkt, __k, __code); - if (!__prev_n) - return 0; - - __n = static_cast<__node_ptr>(__prev_n->_M_nxt); - } - - - - - - - - __node_ptr __n_last = __n->_M_next(); - while (__n_last && this->_M_node_equals(*__n, *__n_last)) - __n_last = __n_last->_M_next(); - - std::size_t __n_last_bkt = __n_last ? _M_bucket_index(*__n_last) : __bkt; - - - size_type __result = 0; - do - { - __node_ptr __p = __n->_M_next(); - this->_M_deallocate_node(__n); - __n = __p; - ++__result; - } - while (__n != __n_last); - - _M_element_count -= __result; - if (__prev_n == _M_buckets[__bkt]) - _M_remove_bucket_begin(__bkt, __n_last, __n_last_bkt); - else if (__n_last_bkt != __bkt) - _M_buckets[__n_last_bkt] = __prev_n; - __prev_n->_M_nxt = __n_last; - return __result; - } - - template - auto - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - erase(const_iterator __first, const_iterator __last) - -> iterator - { - __node_ptr __n = __first._M_cur; - __node_ptr __last_n = __last._M_cur; - if (__n == __last_n) - return iterator(__n); - - std::size_t __bkt = _M_bucket_index(*__n); - - __node_base_ptr __prev_n = _M_get_previous_node(__bkt, __n); - bool __is_bucket_begin = __n == _M_bucket_begin(__bkt); - std::size_t __n_bkt = __bkt; - for (;;) - { - do - { - __node_ptr __tmp = __n; - __n = __n->_M_next(); - this->_M_deallocate_node(__tmp); - --_M_element_count; - if (!__n) - break; - __n_bkt = _M_bucket_index(*__n); - } - while (__n != __last_n && __n_bkt == __bkt); - if (__is_bucket_begin) - _M_remove_bucket_begin(__bkt, __n, __n_bkt); - if (__n == __last_n) - break; - __is_bucket_begin = true; - __bkt = __n_bkt; - } - - if (__n && (__n_bkt != __bkt || __is_bucket_begin)) - _M_buckets[__n_bkt] = __prev_n; - __prev_n->_M_nxt = __n; - return iterator(__n); - } - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - clear() noexcept - { - this->_M_deallocate_nodes(_M_begin()); - __builtin_memset(_M_buckets, 0, - _M_bucket_count * sizeof(__node_base_ptr)); - _M_element_count = 0; - _M_before_begin._M_nxt = nullptr; - } - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - rehash(size_type __bkt_count) - { - const __rehash_state& __saved_state = _M_rehash_policy._M_state(); - __bkt_count - = std::max(_M_rehash_policy._M_bkt_for_elements(_M_element_count + 1), - __bkt_count); - __bkt_count = _M_rehash_policy._M_next_bkt(__bkt_count); - - if (__bkt_count != _M_bucket_count) - _M_rehash(__bkt_count, __saved_state); - else - - - _M_rehash_policy._M_reset(__saved_state); - } - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_rehash(size_type __bkt_count, const __rehash_state& __state) - { - try - { - _M_rehash_aux(__bkt_count, __unique_keys{}); - } - catch(...) - { - - - _M_rehash_policy._M_reset(__state); - throw; - } - } - - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_rehash_aux(size_type __bkt_count, true_type ) - { - __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count); - __node_ptr __p = _M_begin(); - _M_before_begin._M_nxt = nullptr; - std::size_t __bbegin_bkt = 0; - while (__p) - { - __node_ptr __next = __p->_M_next(); - std::size_t __bkt - = __hash_code_base::_M_bucket_index(*__p, __bkt_count); - if (!__new_buckets[__bkt]) - { - __p->_M_nxt = _M_before_begin._M_nxt; - _M_before_begin._M_nxt = __p; - __new_buckets[__bkt] = &_M_before_begin; - if (__p->_M_nxt) - __new_buckets[__bbegin_bkt] = __p; - __bbegin_bkt = __bkt; - } - else - { - __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; - __new_buckets[__bkt]->_M_nxt = __p; - } - - __p = __next; - } - - _M_deallocate_buckets(); - _M_bucket_count = __bkt_count; - _M_buckets = __new_buckets; - } - - - - template - void - _Hashtable<_Key, _Value, _Alloc, _ExtractKey, _Equal, - _Hash, _RangeHash, _Unused, _RehashPolicy, _Traits>:: - _M_rehash_aux(size_type __bkt_count, false_type ) - { - __buckets_ptr __new_buckets = _M_allocate_buckets(__bkt_count); - __node_ptr __p = _M_begin(); - _M_before_begin._M_nxt = nullptr; - std::size_t __bbegin_bkt = 0; - std::size_t __prev_bkt = 0; - __node_ptr __prev_p = nullptr; - bool __check_bucket = false; - - while (__p) - { - __node_ptr __next = __p->_M_next(); - std::size_t __bkt - = __hash_code_base::_M_bucket_index(*__p, __bkt_count); - - if (__prev_p && __prev_bkt == __bkt) - { - - - - __p->_M_nxt = __prev_p->_M_nxt; - __prev_p->_M_nxt = __p; - - - - - - - __check_bucket = true; - } - else - { - if (__check_bucket) - { - - - if (__prev_p->_M_nxt) - { - std::size_t __next_bkt - = __hash_code_base::_M_bucket_index( - *__prev_p->_M_next(), __bkt_count); - if (__next_bkt != __prev_bkt) - __new_buckets[__next_bkt] = __prev_p; - } - __check_bucket = false; - } - - if (!__new_buckets[__bkt]) - { - __p->_M_nxt = _M_before_begin._M_nxt; - _M_before_begin._M_nxt = __p; - __new_buckets[__bkt] = &_M_before_begin; - if (__p->_M_nxt) - __new_buckets[__bbegin_bkt] = __p; - __bbegin_bkt = __bkt; - } - else - { - __p->_M_nxt = __new_buckets[__bkt]->_M_nxt; - __new_buckets[__bkt]->_M_nxt = __p; - } - } - __prev_p = __p; - __prev_bkt = __bkt; - __p = __next; - } - - if (__check_bucket && __prev_p->_M_nxt) - { - std::size_t __next_bkt - = __hash_code_base::_M_bucket_index(*__prev_p->_M_next(), - __bkt_count); - if (__next_bkt != __prev_bkt) - __new_buckets[__next_bkt] = __prev_p; - } - - _M_deallocate_buckets(); - _M_bucket_count = __bkt_count; - _M_buckets = __new_buckets; - } - - - template class _Hash_merge_helper { }; - - - - - template - using _RequireNotAllocatorOrIntegral - = __enable_if_t, __is_allocator<_Hash>>::value>; - - - - -} -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 2 3 - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template - using __umap_traits = __detail::_Hashtable_traits<_Cache, false, true>; - - template, - typename _Pred = std::equal_to<_Key>, - typename _Alloc = std::allocator >, - typename _Tr = __umap_traits<__cache_default<_Key, _Hash>::value>> - using __umap_hashtable = _Hashtable<_Key, std::pair, - _Alloc, __detail::_Select1st, - _Pred, _Hash, - __detail::_Mod_range_hashing, - __detail::_Default_ranged_hash, - __detail::_Prime_rehash_policy, _Tr>; - - - template - using __ummap_traits = __detail::_Hashtable_traits<_Cache, false, false>; - - template, - typename _Pred = std::equal_to<_Key>, - typename _Alloc = std::allocator >, - typename _Tr = __ummap_traits<__cache_default<_Key, _Hash>::value>> - using __ummap_hashtable = _Hashtable<_Key, std::pair, - _Alloc, __detail::_Select1st, - _Pred, _Hash, - __detail::_Mod_range_hashing, - __detail::_Default_ranged_hash, - __detail::_Prime_rehash_policy, _Tr>; - - template - class unordered_multimap; -# 105 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template, - typename _Pred = equal_to<_Key>, - typename _Alloc = allocator>> - class unordered_map - { - typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; - _Hashtable _M_h; - - public: - - - - typedef typename _Hashtable::key_type key_type; - typedef typename _Hashtable::value_type value_type; - typedef typename _Hashtable::mapped_type mapped_type; - typedef typename _Hashtable::hasher hasher; - typedef typename _Hashtable::key_equal key_equal; - typedef typename _Hashtable::allocator_type allocator_type; - - - - - typedef typename _Hashtable::pointer pointer; - typedef typename _Hashtable::const_pointer const_pointer; - typedef typename _Hashtable::reference reference; - typedef typename _Hashtable::const_reference const_reference; - typedef typename _Hashtable::iterator iterator; - typedef typename _Hashtable::const_iterator const_iterator; - typedef typename _Hashtable::local_iterator local_iterator; - typedef typename _Hashtable::const_local_iterator const_local_iterator; - typedef typename _Hashtable::size_type size_type; - typedef typename _Hashtable::difference_type difference_type; - - - - using node_type = typename _Hashtable::node_type; - using insert_return_type = typename _Hashtable::insert_return_type; - - - - - - unordered_map() = default; -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - explicit - unordered_map(size_type __n, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _M_h(__n, __hf, __eql, __a) - { } -# 178 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - unordered_map(_InputIterator __first, _InputIterator __last, - size_type __n = 0, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _M_h(__first, __last, __n, __hf, __eql, __a) - { } - - - unordered_map(const unordered_map&) = default; - - - unordered_map(unordered_map&&) = default; - - - - - - explicit - unordered_map(const allocator_type& __a) - : _M_h(__a) - { } - - - - - - - unordered_map(const unordered_map& __umap, - const allocator_type& __a) - : _M_h(__umap._M_h, __a) - { } - - - - - - - unordered_map(unordered_map&& __umap, - const allocator_type& __a) - noexcept( noexcept(_Hashtable(std::move(__umap._M_h), __a)) ) - : _M_h(std::move(__umap._M_h), __a) - { } -# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - unordered_map(initializer_list __l, - size_type __n = 0, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _M_h(__l, __n, __hf, __eql, __a) - { } - - unordered_map(size_type __n, const allocator_type& __a) - : unordered_map(__n, hasher(), key_equal(), __a) - { } - - unordered_map(size_type __n, const hasher& __hf, - const allocator_type& __a) - : unordered_map(__n, __hf, key_equal(), __a) - { } - - template - unordered_map(_InputIterator __first, _InputIterator __last, - size_type __n, - const allocator_type& __a) - : unordered_map(__first, __last, __n, hasher(), key_equal(), __a) - { } - - template - unordered_map(_InputIterator __first, _InputIterator __last, - size_type __n, const hasher& __hf, - const allocator_type& __a) - : unordered_map(__first, __last, __n, __hf, key_equal(), __a) - { } - - unordered_map(initializer_list __l, - size_type __n, - const allocator_type& __a) - : unordered_map(__l, __n, hasher(), key_equal(), __a) - { } - - unordered_map(initializer_list __l, - size_type __n, const hasher& __hf, - const allocator_type& __a) - : unordered_map(__l, __n, __hf, key_equal(), __a) - { } - - - unordered_map& - operator=(const unordered_map&) = default; - - - unordered_map& - operator=(unordered_map&&) = default; -# 296 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - unordered_map& - operator=(initializer_list __l) - { - _M_h = __l; - return *this; - } - - - allocator_type - get_allocator() const noexcept - { return _M_h.get_allocator(); } - - - - - [[__nodiscard__]] bool - empty() const noexcept - { return _M_h.empty(); } - - - size_type - size() const noexcept - { return _M_h.size(); } - - - size_type - max_size() const noexcept - { return _M_h.max_size(); } - - - - - - - - iterator - begin() noexcept - { return _M_h.begin(); } - - - - - - - const_iterator - begin() const noexcept - { return _M_h.begin(); } - - const_iterator - cbegin() const noexcept - { return _M_h.begin(); } - - - - - - - iterator - end() noexcept - { return _M_h.end(); } - - - - - - - const_iterator - end() const noexcept - { return _M_h.end(); } - - const_iterator - cend() const noexcept - { return _M_h.end(); } -# 393 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - std::pair - emplace(_Args&&... __args) - { return _M_h.emplace(std::forward<_Args>(__args)...); } -# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - iterator - emplace_hint(const_iterator __pos, _Args&&... __args) - { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } - - - - node_type - extract(const_iterator __pos) - { - do { if (std::__is_constant_evaluated() && !bool(__pos != end())) __builtin_unreachable(); } while (false); - return _M_h.extract(__pos); - } - - - node_type - extract(const key_type& __key) - { return _M_h.extract(__key); } - - - insert_return_type - insert(node_type&& __nh) - { return _M_h._M_reinsert_node(std::move(__nh)); } - - - iterator - insert(const_iterator, node_type&& __nh) - { return _M_h._M_reinsert_node(std::move(__nh)).position; } -# 476 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - pair - try_emplace(const key_type& __k, _Args&&... __args) - { - return _M_h.try_emplace(cend(), __k, std::forward<_Args>(__args)...); - } - - - template - pair - try_emplace(key_type&& __k, _Args&&... __args) - { - return _M_h.try_emplace(cend(), std::move(__k), - std::forward<_Args>(__args)...); - } -# 520 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - iterator - try_emplace(const_iterator __hint, const key_type& __k, - _Args&&... __args) - { - return _M_h.try_emplace(__hint, __k, - std::forward<_Args>(__args)...).first; - } - - - template - iterator - try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args) - { - return _M_h.try_emplace(__hint, std::move(__k), - std::forward<_Args>(__args)...).first; - } -# 557 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - std::pair - insert(const value_type& __x) - { return _M_h.insert(__x); } - - - - std::pair - insert(value_type&& __x) - { return _M_h.insert(std::move(__x)); } - - template - __enable_if_t::value, - pair> - insert(_Pair&& __x) - { return _M_h.emplace(std::forward<_Pair>(__x)); } -# 596 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - iterator - insert(const_iterator __hint, const value_type& __x) - { return _M_h.insert(__hint, __x); } - - - - iterator - insert(const_iterator __hint, value_type&& __x) - { return _M_h.insert(__hint, std::move(__x)); } - - template - __enable_if_t::value, iterator> - insert(const_iterator __hint, _Pair&& __x) - { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); } -# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - void - insert(_InputIterator __first, _InputIterator __last) - { _M_h.insert(__first, __last); } -# 633 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - void - insert(initializer_list __l) - { _M_h.insert(__l); } -# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - pair - insert_or_assign(const key_type& __k, _Obj&& __obj) - { - auto __ret = _M_h.try_emplace(cend(), __k, - std::forward<_Obj>(__obj)); - if (!__ret.second) - __ret.first->second = std::forward<_Obj>(__obj); - return __ret; - } - - - template - pair - insert_or_assign(key_type&& __k, _Obj&& __obj) - { - auto __ret = _M_h.try_emplace(cend(), std::move(__k), - std::forward<_Obj>(__obj)); - if (!__ret.second) - __ret.first->second = std::forward<_Obj>(__obj); - return __ret; - } -# 708 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - iterator - insert_or_assign(const_iterator __hint, const key_type& __k, - _Obj&& __obj) - { - auto __ret = _M_h.try_emplace(__hint, __k, std::forward<_Obj>(__obj)); - if (!__ret.second) - __ret.first->second = std::forward<_Obj>(__obj); - return __ret.first; - } - - - template - iterator - insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj) - { - auto __ret = _M_h.try_emplace(__hint, std::move(__k), - std::forward<_Obj>(__obj)); - if (!__ret.second) - __ret.first->second = std::forward<_Obj>(__obj); - return __ret.first; - } -# 746 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - iterator - erase(const_iterator __position) - { return _M_h.erase(__position); } - - - iterator - erase(iterator __position) - { return _M_h.erase(__position); } -# 768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - size_type - erase(const key_type& __x) - { return _M_h.erase(__x); } -# 786 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - iterator - erase(const_iterator __first, const_iterator __last) - { return _M_h.erase(__first, __last); } - - - - - - - - void - clear() noexcept - { _M_h.clear(); } -# 810 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - void - swap(unordered_map& __x) - noexcept( noexcept(_M_h.swap(__x._M_h)) ) - { _M_h.swap(__x._M_h); } - - - template - friend class std::_Hash_merge_helper; - - template - void - merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source) - { - using _Merge_helper = _Hash_merge_helper; - _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); - } - - template - void - merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source) - { merge(__source); } - - template - void - merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source) - { - using _Merge_helper = _Hash_merge_helper; - _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source)); - } - - template - void - merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source) - { merge(__source); } - - - - - - - hasher - hash_function() const - { return _M_h.hash_function(); } - - - - key_equal - key_eq() const - { return _M_h.key_eq(); } -# 874 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - iterator - find(const key_type& __x) - { return _M_h.find(__x); } -# 885 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - const_iterator - find(const key_type& __x) const - { return _M_h.find(__x); } -# 907 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - size_type - count(const key_type& __x) const - { return _M_h.count(__x); } -# 947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - std::pair - equal_range(const key_type& __x) - { return _M_h.equal_range(__x); } -# 959 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - std::pair - equal_range(const key_type& __x) const - { return _M_h.equal_range(__x); } -# 985 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - mapped_type& - operator[](const key_type& __k) - { return _M_h[__k]; } - - mapped_type& - operator[](key_type&& __k) - { return _M_h[std::move(__k)]; } -# 1002 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - mapped_type& - at(const key_type& __k) - { return _M_h.at(__k); } - - const mapped_type& - at(const key_type& __k) const - { return _M_h.at(__k); } - - - - - - size_type - bucket_count() const noexcept - { return _M_h.bucket_count(); } - - - size_type - max_bucket_count() const noexcept - { return _M_h.max_bucket_count(); } - - - - - - - size_type - bucket_size(size_type __n) const - { return _M_h.bucket_size(__n); } - - - - - - - size_type - bucket(const key_type& __key) const - { return _M_h.bucket(__key); } - - - - - - - - local_iterator - begin(size_type __n) - { return _M_h.begin(__n); } -# 1058 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - const_local_iterator - begin(size_type __n) const - { return _M_h.begin(__n); } - - const_local_iterator - cbegin(size_type __n) const - { return _M_h.cbegin(__n); } -# 1073 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - local_iterator - end(size_type __n) - { return _M_h.end(__n); } -# 1084 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - const_local_iterator - end(size_type __n) const - { return _M_h.end(__n); } - - const_local_iterator - cend(size_type __n) const - { return _M_h.cend(__n); } - - - - - - float - load_factor() const noexcept - { return _M_h.load_factor(); } - - - - float - max_load_factor() const noexcept - { return _M_h.max_load_factor(); } - - - - - - void - max_load_factor(float __z) - { _M_h.max_load_factor(__z); } -# 1121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - void - rehash(size_type __n) - { _M_h.rehash(__n); } -# 1132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - void - reserve(size_type __n) - { _M_h.reserve(__n); } - - template - friend bool - operator==(const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&, - const unordered_map<_Key1, _Tp1, _Hash1, _Pred1, _Alloc1>&); - }; - - - - template>, - typename _Pred = equal_to<__iter_key_t<_InputIterator>>, - typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, - typename = _RequireInputIter<_InputIterator>, - typename = _RequireNotAllocatorOrIntegral<_Hash>, - typename = _RequireNotAllocator<_Pred>, - typename = _RequireAllocator<_Allocator>> - unordered_map(_InputIterator, _InputIterator, - typename unordered_map::size_type = {}, - _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) - -> unordered_map<__iter_key_t<_InputIterator>, - __iter_val_t<_InputIterator>, - _Hash, _Pred, _Allocator>; - - template, - typename _Pred = equal_to<_Key>, - typename _Allocator = allocator>, - typename = _RequireNotAllocatorOrIntegral<_Hash>, - typename = _RequireNotAllocator<_Pred>, - typename = _RequireAllocator<_Allocator>> - unordered_map(initializer_list>, - typename unordered_map::size_type = {}, - _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator()) - -> unordered_map<_Key, _Tp, _Hash, _Pred, _Allocator>; - - template, - typename = _RequireAllocator<_Allocator>> - unordered_map(_InputIterator, _InputIterator, - typename unordered_map::size_type, _Allocator) - -> unordered_map<__iter_key_t<_InputIterator>, - __iter_val_t<_InputIterator>, - hash<__iter_key_t<_InputIterator>>, - equal_to<__iter_key_t<_InputIterator>>, - _Allocator>; - - template, - typename = _RequireAllocator<_Allocator>> - unordered_map(_InputIterator, _InputIterator, _Allocator) - -> unordered_map<__iter_key_t<_InputIterator>, - __iter_val_t<_InputIterator>, - hash<__iter_key_t<_InputIterator>>, - equal_to<__iter_key_t<_InputIterator>>, - _Allocator>; - - template, - typename = _RequireNotAllocatorOrIntegral<_Hash>, - typename = _RequireAllocator<_Allocator>> - unordered_map(_InputIterator, _InputIterator, - typename unordered_map::size_type, - _Hash, _Allocator) - -> unordered_map<__iter_key_t<_InputIterator>, - __iter_val_t<_InputIterator>, _Hash, - equal_to<__iter_key_t<_InputIterator>>, _Allocator>; - - template> - unordered_map(initializer_list>, - typename unordered_map::size_type, - _Allocator) - -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; - - template> - unordered_map(initializer_list>, _Allocator) - -> unordered_map<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; - - template, - typename = _RequireAllocator<_Allocator>> - unordered_map(initializer_list>, - typename unordered_map::size_type, - _Hash, _Allocator) - -> unordered_map<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; -# 1250 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template, - typename _Pred = equal_to<_Key>, - typename _Alloc = allocator>> - class unordered_multimap - { - typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable; - _Hashtable _M_h; - - public: - - - - typedef typename _Hashtable::key_type key_type; - typedef typename _Hashtable::value_type value_type; - typedef typename _Hashtable::mapped_type mapped_type; - typedef typename _Hashtable::hasher hasher; - typedef typename _Hashtable::key_equal key_equal; - typedef typename _Hashtable::allocator_type allocator_type; - - - - - typedef typename _Hashtable::pointer pointer; - typedef typename _Hashtable::const_pointer const_pointer; - typedef typename _Hashtable::reference reference; - typedef typename _Hashtable::const_reference const_reference; - typedef typename _Hashtable::iterator iterator; - typedef typename _Hashtable::const_iterator const_iterator; - typedef typename _Hashtable::local_iterator local_iterator; - typedef typename _Hashtable::const_local_iterator const_local_iterator; - typedef typename _Hashtable::size_type size_type; - typedef typename _Hashtable::difference_type difference_type; - - - - using node_type = typename _Hashtable::node_type; - - - - - - unordered_multimap() = default; -# 1301 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - explicit - unordered_multimap(size_type __n, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _M_h(__n, __hf, __eql, __a) - { } -# 1322 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - unordered_multimap(_InputIterator __first, _InputIterator __last, - size_type __n = 0, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _M_h(__first, __last, __n, __hf, __eql, __a) - { } - - - unordered_multimap(const unordered_multimap&) = default; - - - unordered_multimap(unordered_multimap&&) = default; - - - - - - explicit - unordered_multimap(const allocator_type& __a) - : _M_h(__a) - { } - - - - - - - unordered_multimap(const unordered_multimap& __ummap, - const allocator_type& __a) - : _M_h(__ummap._M_h, __a) - { } - - - - - - - unordered_multimap(unordered_multimap&& __ummap, - const allocator_type& __a) - noexcept( noexcept(_Hashtable(std::move(__ummap._M_h), __a)) ) - : _M_h(std::move(__ummap._M_h), __a) - { } -# 1378 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - unordered_multimap(initializer_list __l, - size_type __n = 0, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal(), - const allocator_type& __a = allocator_type()) - : _M_h(__l, __n, __hf, __eql, __a) - { } - - unordered_multimap(size_type __n, const allocator_type& __a) - : unordered_multimap(__n, hasher(), key_equal(), __a) - { } - - unordered_multimap(size_type __n, const hasher& __hf, - const allocator_type& __a) - : unordered_multimap(__n, __hf, key_equal(), __a) - { } - - template - unordered_multimap(_InputIterator __first, _InputIterator __last, - size_type __n, - const allocator_type& __a) - : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a) - { } - - template - unordered_multimap(_InputIterator __first, _InputIterator __last, - size_type __n, const hasher& __hf, - const allocator_type& __a) - : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a) - { } - - unordered_multimap(initializer_list __l, - size_type __n, - const allocator_type& __a) - : unordered_multimap(__l, __n, hasher(), key_equal(), __a) - { } - - unordered_multimap(initializer_list __l, - size_type __n, const hasher& __hf, - const allocator_type& __a) - : unordered_multimap(__l, __n, __hf, key_equal(), __a) - { } - - - unordered_multimap& - operator=(const unordered_multimap&) = default; - - - unordered_multimap& - operator=(unordered_multimap&&) = default; -# 1440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - unordered_multimap& - operator=(initializer_list __l) - { - _M_h = __l; - return *this; - } - - - allocator_type - get_allocator() const noexcept - { return _M_h.get_allocator(); } - - - - - [[__nodiscard__]] bool - empty() const noexcept - { return _M_h.empty(); } - - - size_type - size() const noexcept - { return _M_h.size(); } - - - size_type - max_size() const noexcept - { return _M_h.max_size(); } - - - - - - - - iterator - begin() noexcept - { return _M_h.begin(); } - - - - - - - const_iterator - begin() const noexcept - { return _M_h.begin(); } - - const_iterator - cbegin() const noexcept - { return _M_h.begin(); } - - - - - - - iterator - end() noexcept - { return _M_h.end(); } - - - - - - - const_iterator - end() const noexcept - { return _M_h.end(); } - - const_iterator - cend() const noexcept - { return _M_h.end(); } -# 1532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - iterator - emplace(_Args&&... __args) - { return _M_h.emplace(std::forward<_Args>(__args)...); } -# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - iterator - emplace_hint(const_iterator __pos, _Args&&... __args) - { return _M_h.emplace_hint(__pos, std::forward<_Args>(__args)...); } -# 1574 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - iterator - insert(const value_type& __x) - { return _M_h.insert(__x); } - - iterator - insert(value_type&& __x) - { return _M_h.insert(std::move(__x)); } - - template - __enable_if_t::value, iterator> - insert(_Pair&& __x) - { return _M_h.emplace(std::forward<_Pair>(__x)); } -# 1608 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - iterator - insert(const_iterator __hint, const value_type& __x) - { return _M_h.insert(__hint, __x); } - - - - iterator - insert(const_iterator __hint, value_type&& __x) - { return _M_h.insert(__hint, std::move(__x)); } - - template - __enable_if_t::value, iterator> - insert(const_iterator __hint, _Pair&& __x) - { return _M_h.emplace_hint(__hint, std::forward<_Pair>(__x)); } -# 1633 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - template - void - insert(_InputIterator __first, _InputIterator __last) - { _M_h.insert(__first, __last); } -# 1646 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - void - insert(initializer_list __l) - { _M_h.insert(__l); } - - - - node_type - extract(const_iterator __pos) - { - do { if (std::__is_constant_evaluated() && !bool(__pos != end())) __builtin_unreachable(); } while (false); - return _M_h.extract(__pos); - } - - - node_type - extract(const key_type& __key) - { return _M_h.extract(__key); } - - - iterator - insert(node_type&& __nh) - { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); } - - - iterator - insert(const_iterator __hint, node_type&& __nh) - { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); } -# 1689 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - iterator - erase(const_iterator __position) - { return _M_h.erase(__position); } - - - iterator - erase(iterator __position) - { return _M_h.erase(__position); } -# 1710 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - size_type - erase(const key_type& __x) - { return _M_h.erase(__x); } -# 1729 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - iterator - erase(const_iterator __first, const_iterator __last) - { return _M_h.erase(__first, __last); } - - - - - - - - void - clear() noexcept - { _M_h.clear(); } -# 1753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - void - swap(unordered_multimap& __x) - noexcept( noexcept(_M_h.swap(__x._M_h)) ) - { _M_h.swap(__x._M_h); } - - - template - friend class std::_Hash_merge_helper; - - template - void - merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>& __source) - { - using _Merge_helper - = _Hash_merge_helper; - _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); - } - - template - void - merge(unordered_multimap<_Key, _Tp, _H2, _P2, _Alloc>&& __source) - { merge(__source); } - - template - void - merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>& __source) - { - using _Merge_helper - = _Hash_merge_helper; - _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source)); - } - - template - void - merge(unordered_map<_Key, _Tp, _H2, _P2, _Alloc>&& __source) - { merge(__source); } - - - - - - - hasher - hash_function() const - { return _M_h.hash_function(); } - - - - key_equal - key_eq() const - { return _M_h.key_eq(); } -# 1819 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - iterator - find(const key_type& __x) - { return _M_h.find(__x); } -# 1830 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - const_iterator - find(const key_type& __x) const - { return _M_h.find(__x); } -# 1848 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - size_type - count(const key_type& __x) const - { return _M_h.count(__x); } -# 1886 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - std::pair - equal_range(const key_type& __x) - { return _M_h.equal_range(__x); } -# 1898 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - std::pair - equal_range(const key_type& __x) const - { return _M_h.equal_range(__x); } -# 1914 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - size_type - bucket_count() const noexcept - { return _M_h.bucket_count(); } - - - size_type - max_bucket_count() const noexcept - { return _M_h.max_bucket_count(); } - - - - - - - size_type - bucket_size(size_type __n) const - { return _M_h.bucket_size(__n); } - - - - - - - size_type - bucket(const key_type& __key) const - { return _M_h.bucket(__key); } - - - - - - - - local_iterator - begin(size_type __n) - { return _M_h.begin(__n); } -# 1958 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - const_local_iterator - begin(size_type __n) const - { return _M_h.begin(__n); } - - const_local_iterator - cbegin(size_type __n) const - { return _M_h.cbegin(__n); } -# 1973 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - local_iterator - end(size_type __n) - { return _M_h.end(__n); } -# 1984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - const_local_iterator - end(size_type __n) const - { return _M_h.end(__n); } - - const_local_iterator - cend(size_type __n) const - { return _M_h.cend(__n); } - - - - - - float - load_factor() const noexcept - { return _M_h.load_factor(); } - - - - float - max_load_factor() const noexcept - { return _M_h.max_load_factor(); } - - - - - - void - max_load_factor(float __z) - { _M_h.max_load_factor(__z); } -# 2021 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - void - rehash(size_type __n) - { _M_h.rehash(__n); } -# 2032 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/unordered_map.h" 3 - void - reserve(size_type __n) - { _M_h.reserve(__n); } - - template - friend bool - operator==(const unordered_multimap<_Key1, _Tp1, - _Hash1, _Pred1, _Alloc1>&, - const unordered_multimap<_Key1, _Tp1, - _Hash1, _Pred1, _Alloc1>&); - }; - - - - template>, - typename _Pred = equal_to<__iter_key_t<_InputIterator>>, - typename _Allocator = allocator<__iter_to_alloc_t<_InputIterator>>, - typename = _RequireInputIter<_InputIterator>, - typename = _RequireNotAllocatorOrIntegral<_Hash>, - typename = _RequireNotAllocator<_Pred>, - typename = _RequireAllocator<_Allocator>> - unordered_multimap(_InputIterator, _InputIterator, - unordered_multimap::size_type = {}, - _Hash = _Hash(), _Pred = _Pred(), - _Allocator = _Allocator()) - -> unordered_multimap<__iter_key_t<_InputIterator>, - __iter_val_t<_InputIterator>, _Hash, _Pred, - _Allocator>; - - template, - typename _Pred = equal_to<_Key>, - typename _Allocator = allocator>, - typename = _RequireNotAllocatorOrIntegral<_Hash>, - typename = _RequireNotAllocator<_Pred>, - typename = _RequireAllocator<_Allocator>> - unordered_multimap(initializer_list>, - unordered_multimap::size_type = {}, - _Hash = _Hash(), _Pred = _Pred(), - _Allocator = _Allocator()) - -> unordered_multimap<_Key, _Tp, _Hash, _Pred, _Allocator>; - - template, - typename = _RequireAllocator<_Allocator>> - unordered_multimap(_InputIterator, _InputIterator, - unordered_multimap::size_type, _Allocator) - -> unordered_multimap<__iter_key_t<_InputIterator>, - __iter_val_t<_InputIterator>, - hash<__iter_key_t<_InputIterator>>, - equal_to<__iter_key_t<_InputIterator>>, _Allocator>; - - template, - typename = _RequireAllocator<_Allocator>> - unordered_multimap(_InputIterator, _InputIterator, _Allocator) - -> unordered_multimap<__iter_key_t<_InputIterator>, - __iter_val_t<_InputIterator>, - hash<__iter_key_t<_InputIterator>>, - equal_to<__iter_key_t<_InputIterator>>, _Allocator>; - - template, - typename = _RequireNotAllocatorOrIntegral<_Hash>, - typename = _RequireAllocator<_Allocator>> - unordered_multimap(_InputIterator, _InputIterator, - unordered_multimap::size_type, _Hash, - _Allocator) - -> unordered_multimap<__iter_key_t<_InputIterator>, - __iter_val_t<_InputIterator>, _Hash, - equal_to<__iter_key_t<_InputIterator>>, _Allocator>; - - template> - unordered_multimap(initializer_list>, - unordered_multimap::size_type, - _Allocator) - -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; - - template> - unordered_multimap(initializer_list>, _Allocator) - -> unordered_multimap<_Key, _Tp, hash<_Key>, equal_to<_Key>, _Allocator>; - - template, - typename = _RequireAllocator<_Allocator>> - unordered_multimap(initializer_list>, - unordered_multimap::size_type, - _Hash, _Allocator) - -> unordered_multimap<_Key, _Tp, _Hash, equal_to<_Key>, _Allocator>; - - - - template - inline void - swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, - unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } - - template - inline void - swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, - unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } - - template - inline bool - operator==(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, - const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) - { return __x._M_h._M_equal(__y._M_h); } - - - template - inline bool - operator!=(const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, - const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) - { return !(__x == __y); } - - - template - inline bool - operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, - const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) - { return __x._M_h._M_equal(__y._M_h); } - - - template - inline bool - operator!=(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x, - const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y) - { return !(__x == __y); } - - - - - - - template - struct _Hash_merge_helper< - std::unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>, - _Hash2, _Eq2> - { - private: - template - using unordered_map = std::unordered_map<_Tp...>; - template - using unordered_multimap = std::unordered_multimap<_Tp...>; - - friend unordered_map<_Key, _Val, _Hash1, _Eq1, _Alloc>; - - static auto& - _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) - { return __map._M_h; } - - static auto& - _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) - { return __map._M_h; } - }; - - - template - struct _Hash_merge_helper< - std::unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>, - _Hash2, _Eq2> - { - private: - template - using unordered_map = std::unordered_map<_Tp...>; - template - using unordered_multimap = std::unordered_multimap<_Tp...>; - - friend unordered_multimap<_Key, _Val, _Hash1, _Eq1, _Alloc>; - - static auto& - _S_get_table(unordered_map<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) - { return __map._M_h; } - - static auto& - _S_get_table(unordered_multimap<_Key, _Val, _Hash2, _Eq2, _Alloc>& __map) - { return __map._M_h; } - }; - - - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/unordered_map" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/erase_if.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/erase_if.h" 3 - - - - - -namespace std -{ - - - - - - - namespace __detail - { - template - typename _Container::size_type - __erase_nodes_if(_Container& __cont, _UnsafeContainer& __ucont, - _Predicate __pred) - { - typename _Container::size_type __num = 0; - for (auto __iter = __ucont.begin(), __last = __ucont.end(); - __iter != __last;) - { - if (__pred(*__iter)) - { - __iter = __cont.erase(__iter); - ++__num; - } - else - ++__iter; - } - return __num; - } - } - - -} -# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/unordered_map" 2 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - namespace pmr - { - template, - typename _Pred = std::equal_to<_Key>> - using unordered_map - = std::unordered_map<_Key, _Tp, _Hash, _Pred, - polymorphic_allocator>>; - template, - typename _Pred = std::equal_to<_Key>> - using unordered_multimap - = std::unordered_multimap<_Key, _Tp, _Hash, _Pred, - polymorphic_allocator>>; - } - -} -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/functional" 2 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 1 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 3 - - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 3 - template - - bool - all_of(_IIter, _IIter, _Predicate); - - template - - bool - any_of(_IIter, _IIter, _Predicate); - - - template - - bool - binary_search(_FIter, _FIter, const _Tp&); - - template - - bool - binary_search(_FIter, _FIter, const _Tp&, _Compare); - - - template - constexpr - const _Tp& - clamp(const _Tp&, const _Tp&, const _Tp&); - - template - constexpr - const _Tp& - clamp(const _Tp&, const _Tp&, const _Tp&, _Compare); - - - template - - _OIter - copy(_IIter, _IIter, _OIter); - - template - - _BIter2 - copy_backward(_BIter1, _BIter1, _BIter2); - - - template - - _OIter - copy_if(_IIter, _IIter, _OIter, _Predicate); - - template - - _OIter - copy_n(_IIter, _Size, _OIter); - - - - - - template - - pair<_FIter, _FIter> - equal_range(_FIter, _FIter, const _Tp&); - - template - - pair<_FIter, _FIter> - equal_range(_FIter, _FIter, const _Tp&, _Compare); - - template - - void - fill(_FIter, _FIter, const _Tp&); - - template - - _OIter - fill_n(_OIter, _Size, const _Tp&); - - - - template - - _FIter1 - find_end(_FIter1, _FIter1, _FIter2, _FIter2); - - template - - _FIter1 - find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); - - - - - - template - - _IIter - find_if_not(_IIter, _IIter, _Predicate); - - - - - - - template - - bool - includes(_IIter1, _IIter1, _IIter2, _IIter2); - - template - - bool - includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); - - template - void - inplace_merge(_BIter, _BIter, _BIter); - - template - void - inplace_merge(_BIter, _BIter, _BIter, _Compare); - - - template - - bool - is_heap(_RAIter, _RAIter); - - template - - bool - is_heap(_RAIter, _RAIter, _Compare); - - template - - _RAIter - is_heap_until(_RAIter, _RAIter); - - template - - _RAIter - is_heap_until(_RAIter, _RAIter, _Compare); - - template - - bool - is_partitioned(_IIter, _IIter, _Predicate); - - template - - bool - is_permutation(_FIter1, _FIter1, _FIter2); - - template - - bool - is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate); - - template - - bool - is_sorted(_FIter, _FIter); - - template - - bool - is_sorted(_FIter, _FIter, _Compare); - - template - - _FIter - is_sorted_until(_FIter, _FIter); - - template - - _FIter - is_sorted_until(_FIter, _FIter, _Compare); - - - template - - void - iter_swap(_FIter1, _FIter2); - - template - - _FIter - lower_bound(_FIter, _FIter, const _Tp&); - - template - - _FIter - lower_bound(_FIter, _FIter, const _Tp&, _Compare); - - template - - void - make_heap(_RAIter, _RAIter); - - template - - void - make_heap(_RAIter, _RAIter, _Compare); - - template - constexpr - const _Tp& - max(const _Tp&, const _Tp&); - - template - constexpr - const _Tp& - max(const _Tp&, const _Tp&, _Compare); - - - - - template - constexpr - const _Tp& - min(const _Tp&, const _Tp&); - - template - constexpr - const _Tp& - min(const _Tp&, const _Tp&, _Compare); - - - - - template - constexpr - pair - minmax(const _Tp&, const _Tp&); - - template - constexpr - pair - minmax(const _Tp&, const _Tp&, _Compare); - - template - constexpr - pair<_FIter, _FIter> - minmax_element(_FIter, _FIter); - - template - constexpr - pair<_FIter, _FIter> - minmax_element(_FIter, _FIter, _Compare); - - template - constexpr - _Tp - min(initializer_list<_Tp>); - - template - constexpr - _Tp - min(initializer_list<_Tp>, _Compare); - - template - constexpr - _Tp - max(initializer_list<_Tp>); - - template - constexpr - _Tp - max(initializer_list<_Tp>, _Compare); - - template - constexpr - pair<_Tp, _Tp> - minmax(initializer_list<_Tp>); - - template - constexpr - pair<_Tp, _Tp> - minmax(initializer_list<_Tp>, _Compare); - - - - - template - - bool - next_permutation(_BIter, _BIter); - - template - - bool - next_permutation(_BIter, _BIter, _Compare); - - - template - - bool - none_of(_IIter, _IIter, _Predicate); - - - - - - template - - _RAIter - partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); - - template - - _RAIter - partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); - - - - - template - - pair<_OIter1, _OIter2> - partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); - - template - - _FIter - partition_point(_FIter, _FIter, _Predicate); - - - template - - void - pop_heap(_RAIter, _RAIter); - - template - - void - pop_heap(_RAIter, _RAIter, _Compare); - - template - - bool - prev_permutation(_BIter, _BIter); - - template - - bool - prev_permutation(_BIter, _BIter, _Compare); - - template - - void - push_heap(_RAIter, _RAIter); - - template - - void - push_heap(_RAIter, _RAIter, _Compare); - - - - template - - _FIter - remove(_FIter, _FIter, const _Tp&); - - template - - _FIter - remove_if(_FIter, _FIter, _Predicate); - - template - - _OIter - remove_copy(_IIter, _IIter, _OIter, const _Tp&); - - template - - _OIter - remove_copy_if(_IIter, _IIter, _OIter, _Predicate); - - - - template - - _OIter - replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); - - template - - _OIter - replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); - - - - template - - void - reverse(_BIter, _BIter); - - template - - _OIter - reverse_copy(_BIter, _BIter, _OIter); - -inline namespace _V2 { - - template - - _FIter - rotate(_FIter, _FIter, _FIter); - -} - - template - - _OIter - rotate_copy(_FIter, _FIter, _FIter, _OIter); -# 626 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 3 - template - void - shuffle(_RAIter, _RAIter, _UGenerator&&); - - - template - - void - sort_heap(_RAIter, _RAIter); - - template - - void - sort_heap(_RAIter, _RAIter, _Compare); - - - template - _BIter - stable_partition(_BIter, _BIter, _Predicate); -# 661 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/algorithmfwd.h" 3 - template - - _FIter2 - swap_ranges(_FIter1, _FIter1, _FIter2); - - - - template - - _FIter - unique(_FIter, _FIter); - - template - - _FIter - unique(_FIter, _FIter, _BinaryPredicate); - - - - template - - _FIter - upper_bound(_FIter, _FIter, const _Tp&); - - template - - _FIter - upper_bound(_FIter, _FIter, const _Tp&, _Compare); - - - - template - - _FIter - adjacent_find(_FIter, _FIter); - - template - - _FIter - adjacent_find(_FIter, _FIter, _BinaryPredicate); - - template - - typename iterator_traits<_IIter>::difference_type - count(_IIter, _IIter, const _Tp&); - - template - - typename iterator_traits<_IIter>::difference_type - count_if(_IIter, _IIter, _Predicate); - - template - - bool - equal(_IIter1, _IIter1, _IIter2); - - template - - bool - equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); - - template - - _IIter - find(_IIter, _IIter, const _Tp&); - - template - - _FIter1 - find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); - - template - - _FIter1 - find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); - - template - - _IIter - find_if(_IIter, _IIter, _Predicate); - - template - - _Funct - for_each(_IIter, _IIter, _Funct); - - template - - void - generate(_FIter, _FIter, _Generator); - - template - - _OIter - generate_n(_OIter, _Size, _Generator); - - template - - bool - lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); - - template - - bool - lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); - - template - constexpr - _FIter - max_element(_FIter, _FIter); - - template - constexpr - _FIter - max_element(_FIter, _FIter, _Compare); - - template - - _OIter - merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); - - template - - _OIter - merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); - - template - constexpr - _FIter - min_element(_FIter, _FIter); - - template - constexpr - _FIter - min_element(_FIter, _FIter, _Compare); - - template - - pair<_IIter1, _IIter2> - mismatch(_IIter1, _IIter1, _IIter2); - - template - - pair<_IIter1, _IIter2> - mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); - - template - - void - nth_element(_RAIter, _RAIter, _RAIter); - - template - - void - nth_element(_RAIter, _RAIter, _RAIter, _Compare); - - template - - void - partial_sort(_RAIter, _RAIter, _RAIter); - - template - - void - partial_sort(_RAIter, _RAIter, _RAIter, _Compare); - - template - - _BIter - partition(_BIter, _BIter, _Predicate); - - - template - __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) - void - random_shuffle(_RAIter, _RAIter); - - template - __attribute__ ((__deprecated__ ("use '" "std::shuffle" "' instead"))) - void - random_shuffle(_RAIter, _RAIter, - - _Generator&&); - - - - - - template - - void - replace(_FIter, _FIter, const _Tp&, const _Tp&); - - template - - void - replace_if(_FIter, _FIter, _Predicate, const _Tp&); - - template - - _FIter1 - search(_FIter1, _FIter1, _FIter2, _FIter2); - - template - - _FIter1 - search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); - - template - - _FIter - search_n(_FIter, _FIter, _Size, const _Tp&); - - template - - _FIter - search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); - - template - - _OIter - set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); - - template - - _OIter - set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); - - template - - _OIter - set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); - - template - - _OIter - set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); - - template - - _OIter - set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); - - template - - _OIter - set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, - _OIter, _Compare); - - template - - _OIter - set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); - - template - - _OIter - set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); - - template - - void - sort(_RAIter, _RAIter); - - template - - void - sort(_RAIter, _RAIter, _Compare); - - template - void - stable_sort(_RAIter, _RAIter); - - template - void - stable_sort(_RAIter, _RAIter, _Compare); - - template - - _OIter - transform(_IIter, _IIter, _OIter, _UnaryOperation); - - template - - _OIter - transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); - - template - - _OIter - unique_copy(_IIter, _IIter, _OIter); - - template - - _OIter - unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); - - - -} -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - - _Distance - __is_heap_until(_RandomAccessIterator __first, _Distance __n, - _Compare& __comp) - { - _Distance __parent = 0; - for (_Distance __child = 1; __child < __n; ++__child) - { - if (__comp(__first + __parent, __first + __child)) - return __child; - if ((__child & 1) == 0) - ++__parent; - } - return __n; - } - - - - template - - inline bool - __is_heap(_RandomAccessIterator __first, _Distance __n) - { - __gnu_cxx::__ops::_Iter_less_iter __comp; - return std::__is_heap_until(__first, __n, __comp) == __n; - } - - template - - inline bool - __is_heap(_RandomAccessIterator __first, _Compare __comp, _Distance __n) - { - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); - return std::__is_heap_until(__first, __n, __cmp) == __n; - } - - template - - inline bool - __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) - { return std::__is_heap(__first, std::distance(__first, __last)); } - - template - - inline bool - __is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp) - { - return std::__is_heap(__first, std::move(__comp), - std::distance(__first, __last)); - } - - - - - template - - void - __push_heap(_RandomAccessIterator __first, - _Distance __holeIndex, _Distance __topIndex, _Tp __value, - _Compare& __comp) - { - _Distance __parent = (__holeIndex - 1) / 2; - while (__holeIndex > __topIndex && __comp(__first + __parent, __value)) - { - *(__first + __holeIndex) = std::move(*(__first + __parent)); - __holeIndex = __parent; - __parent = (__holeIndex - 1) / 2; - } - *(__first + __holeIndex) = std::move(__value); - } -# 159 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline void - push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) - { - typedef typename iterator_traits<_RandomAccessIterator>::value_type - _ValueType; - typedef typename iterator_traits<_RandomAccessIterator>::difference_type - _DistanceType; - - - - - - ; - ; - ; - - __gnu_cxx::__ops::_Iter_less_val __comp; - _ValueType __value = std::move(*(__last - 1)); - std::__push_heap(__first, _DistanceType((__last - __first) - 1), - _DistanceType(0), std::move(__value), __comp); - } -# 195 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline void - push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp) - { - typedef typename iterator_traits<_RandomAccessIterator>::value_type - _ValueType; - typedef typename iterator_traits<_RandomAccessIterator>::difference_type - _DistanceType; - - - - - ; - ; - ; - - __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp))) - __cmp(std::move(__comp)); - _ValueType __value = std::move(*(__last - 1)); - std::__push_heap(__first, _DistanceType((__last - __first) - 1), - _DistanceType(0), std::move(__value), __cmp); - } - - template - - void - __adjust_heap(_RandomAccessIterator __first, _Distance __holeIndex, - _Distance __len, _Tp __value, _Compare __comp) - { - const _Distance __topIndex = __holeIndex; - _Distance __secondChild = __holeIndex; - while (__secondChild < (__len - 1) / 2) - { - __secondChild = 2 * (__secondChild + 1); - if (__comp(__first + __secondChild, - __first + (__secondChild - 1))) - __secondChild--; - *(__first + __holeIndex) = std::move(*(__first + __secondChild)); - __holeIndex = __secondChild; - } - if ((__len & 1) == 0 && __secondChild == (__len - 2) / 2) - { - __secondChild = 2 * (__secondChild + 1); - *(__first + __holeIndex) = std::move(*(__first + (__secondChild - 1))); - - __holeIndex = __secondChild - 1; - } - __decltype(__gnu_cxx::__ops::__iter_comp_val(std::move(__comp))) - __cmp(std::move(__comp)); - std::__push_heap(__first, __holeIndex, __topIndex, - std::move(__value), __cmp); - } - - template - - inline void - __pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _RandomAccessIterator __result, _Compare& __comp) - { - typedef typename iterator_traits<_RandomAccessIterator>::value_type - _ValueType; - typedef typename iterator_traits<_RandomAccessIterator>::difference_type - _DistanceType; - - _ValueType __value = std::move(*__result); - *__result = std::move(*__first); - std::__adjust_heap(__first, _DistanceType(0), - _DistanceType(__last - __first), - std::move(__value), __comp); - } -# 280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline void - pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) - { - - - - - - ; - ; - ; - ; - - if (__last - __first > 1) - { - --__last; - __gnu_cxx::__ops::_Iter_less_iter __comp; - std::__pop_heap(__first, __last, __last, __comp); - } - } -# 314 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline void - pop_heap(_RandomAccessIterator __first, - _RandomAccessIterator __last, _Compare __comp) - { - - - - ; - ; - ; - ; - - if (__last - __first > 1) - { - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); - --__last; - std::__pop_heap(__first, __last, __last, __cmp); - } - } - - template - - void - __make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare& __comp) - { - typedef typename iterator_traits<_RandomAccessIterator>::value_type - _ValueType; - typedef typename iterator_traits<_RandomAccessIterator>::difference_type - _DistanceType; - - if (__last - __first < 2) - return; - - const _DistanceType __len = __last - __first; - _DistanceType __parent = (__len - 2) / 2; - while (true) - { - _ValueType __value = std::move(*(__first + __parent)); - std::__adjust_heap(__first, __parent, __len, std::move(__value), - __comp); - if (__parent == 0) - return; - __parent--; - } - } -# 372 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline void - make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) - { - - - - - - ; - ; - - __gnu_cxx::__ops::_Iter_less_iter __comp; - std::__make_heap(__first, __last, __comp); - } -# 399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline void - make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp) - { - - - - ; - ; - - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); - std::__make_heap(__first, __last, __cmp); - } - - template - - void - __sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare& __comp) - { - while (__last - __first > 1) - { - --__last; - std::__pop_heap(__first, __last, __last, __comp); - } - } -# 437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline void - sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) - { - - - - - - ; - ; - ; - - __gnu_cxx::__ops::_Iter_less_iter __comp; - std::__sort_heap(__first, __last, __comp); - } -# 465 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline void - sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp) - { - - - - ; - ; - ; - - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); - std::__sort_heap(__first, __last, __cmp); - } -# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline _RandomAccessIterator - is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last) - { - - - - - - ; - ; - - __gnu_cxx::__ops::_Iter_less_iter __comp; - return __first + - std::__is_heap_until(__first, std::distance(__first, __last), __comp); - } -# 523 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline _RandomAccessIterator - is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp) - { - - - - ; - ; - - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); - return __first - + std::__is_heap_until(__first, std::distance(__first, __last), __cmp); - } -# 548 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline bool - is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last) - { return std::is_heap_until(__first, __last) == __last; } -# 562 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_heap.h" 3 - template - - inline bool - is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Compare __comp) - { - - - - ; - ; - - const auto __dist = std::distance(__first, __last); - typedef __decltype(__comp) _Cmp; - __gnu_cxx::__ops::_Iter_comp_iter<_Cmp> __cmp(std::move(__comp)); - return std::__is_heap_until(__first, __dist, __cmp) == __dist; - } - - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 2 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 1 3 -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 - namespace __detail - { - - - - template - constexpr bool - _Power_of_2(_Tp __x) - { - return ((__x - 1) & __x) == 0; - } - } -# 87 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 - template - class uniform_int_distribution - { - static_assert(std::is_integral<_IntType>::value, - "template argument must be an integral type"); - - public: - - typedef _IntType result_type; - - struct param_type - { - typedef uniform_int_distribution<_IntType> distribution_type; - - param_type() : param_type(0) { } - - explicit - param_type(_IntType __a, - _IntType __b = __gnu_cxx::__int_traits<_IntType>::__max) - : _M_a(__a), _M_b(__b) - { - do { if (std::__is_constant_evaluated() && !bool(_M_a <= _M_b)) __builtin_unreachable(); } while (false); - } - - result_type - a() const - { return _M_a; } - - result_type - b() const - { return _M_b; } - - friend bool - operator==(const param_type& __p1, const param_type& __p2) - { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } - - friend bool - operator!=(const param_type& __p1, const param_type& __p2) - { return !(__p1 == __p2); } - - private: - _IntType _M_a; - _IntType _M_b; - }; - - public: - - - - uniform_int_distribution() : uniform_int_distribution(0) { } - - - - - explicit - uniform_int_distribution(_IntType __a, - _IntType __b - = __gnu_cxx::__int_traits<_IntType>::__max) - : _M_param(__a, __b) - { } - - explicit - uniform_int_distribution(const param_type& __p) - : _M_param(__p) - { } - - - - - - - void - reset() { } - - result_type - a() const - { return _M_param.a(); } - - result_type - b() const - { return _M_param.b(); } - - - - - param_type - param() const - { return _M_param; } - - - - - - void - param(const param_type& __param) - { _M_param = __param; } - - - - - result_type - min() const - { return this->a(); } - - - - - result_type - max() const - { return this->b(); } - - - - - template - result_type - operator()(_UniformRandomBitGenerator& __urng) - { return this->operator()(__urng, _M_param); } - - template - result_type - operator()(_UniformRandomBitGenerator& __urng, - const param_type& __p); - - template - void - __generate(_ForwardIterator __f, _ForwardIterator __t, - _UniformRandomBitGenerator& __urng) - { this->__generate(__f, __t, __urng, _M_param); } - - template - void - __generate(_ForwardIterator __f, _ForwardIterator __t, - _UniformRandomBitGenerator& __urng, - const param_type& __p) - { this->__generate_impl(__f, __t, __urng, __p); } - - template - void - __generate(result_type* __f, result_type* __t, - _UniformRandomBitGenerator& __urng, - const param_type& __p) - { this->__generate_impl(__f, __t, __urng, __p); } - - - - - - friend bool - operator==(const uniform_int_distribution& __d1, - const uniform_int_distribution& __d2) - { return __d1._M_param == __d2._M_param; } - - private: - template - void - __generate_impl(_ForwardIterator __f, _ForwardIterator __t, - _UniformRandomBitGenerator& __urng, - const param_type& __p); - - param_type _M_param; - - - - - template - static _Up - _S_nd(_Urbg& __g, _Up __range) - { - using _Up_traits = __gnu_cxx::__int_traits<_Up>; - using _Wp_traits = __gnu_cxx::__int_traits<_Wp>; - static_assert(!_Up_traits::__is_signed, "U must be unsigned"); - static_assert(!_Wp_traits::__is_signed, "W must be unsigned"); - static_assert(_Wp_traits::__digits == (2 * _Up_traits::__digits), - "W must be twice as wide as U"); - - - - - _Wp __product = _Wp(__g()) * _Wp(__range); - _Up __low = _Up(__product); - if (__low < __range) - { - _Up __threshold = -__range % __range; - while (__low < __threshold) - { - __product = _Wp(__g()) * _Wp(__range); - __low = _Up(__product); - } - } - return __product >> _Up_traits::__digits; - } - }; - - template - template - typename uniform_int_distribution<_IntType>::result_type - uniform_int_distribution<_IntType>:: - operator()(_UniformRandomBitGenerator& __urng, - const param_type& __param) - { - typedef typename _UniformRandomBitGenerator::result_type _Gresult_type; - typedef typename make_unsigned::type __utype; - typedef typename common_type<_Gresult_type, __utype>::type __uctype; - - constexpr __uctype __urngmin = _UniformRandomBitGenerator::min(); - constexpr __uctype __urngmax = _UniformRandomBitGenerator::max(); - static_assert( __urngmin < __urngmax, - "Uniform random bit generator must define min() < max()"); - constexpr __uctype __urngrange = __urngmax - __urngmin; - - const __uctype __urange - = __uctype(__param.b()) - __uctype(__param.a()); - - __uctype __ret; - if (__urngrange > __urange) - { - - - const __uctype __uerange = __urange + 1; - - - - if constexpr (__urngrange == 18446744073709551615UL) - { - - - long unsigned int __u64erange = __uerange; - __ret = __extension__ _S_nd(__urng, - __u64erange); - } - else - - if constexpr (__urngrange == 4294967295U) - { - - - unsigned int __u32erange = __uerange; - __ret = _S_nd(__urng, __u32erange); - } - else - - { - - const __uctype __scaling = __urngrange / __uerange; - const __uctype __past = __uerange * __scaling; - do - __ret = __uctype(__urng()) - __urngmin; - while (__ret >= __past); - __ret /= __scaling; - } - } - else if (__urngrange < __urange) - { -# 359 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 - __uctype __tmp; - do - { - const __uctype __uerngrange = __urngrange + 1; - __tmp = (__uerngrange * operator() - (__urng, param_type(0, __urange / __uerngrange))); - __ret = __tmp + (__uctype(__urng()) - __urngmin); - } - while (__ret > __urange || __ret < __tmp); - } - else - __ret = __uctype(__urng()) - __urngmin; - - return __ret + __param.a(); - } - - - template - template - void - uniform_int_distribution<_IntType>:: - __generate_impl(_ForwardIterator __f, _ForwardIterator __t, - _UniformRandomBitGenerator& __urng, - const param_type& __param) - { - - typedef typename _UniformRandomBitGenerator::result_type _Gresult_type; - typedef typename make_unsigned::type __utype; - typedef typename common_type<_Gresult_type, __utype>::type __uctype; - - static_assert( __urng.min() < __urng.max(), - "Uniform random bit generator must define min() < max()"); - - constexpr __uctype __urngmin = __urng.min(); - constexpr __uctype __urngmax = __urng.max(); - constexpr __uctype __urngrange = __urngmax - __urngmin; - const __uctype __urange - = __uctype(__param.b()) - __uctype(__param.a()); - - __uctype __ret; - - if (__urngrange > __urange) - { - if (__detail::_Power_of_2(__urngrange + 1) - && __detail::_Power_of_2(__urange + 1)) - { - while (__f != __t) - { - __ret = __uctype(__urng()) - __urngmin; - *__f++ = (__ret & __urange) + __param.a(); - } - } - else - { - - const __uctype __uerange = __urange + 1; - const __uctype __scaling = __urngrange / __uerange; - const __uctype __past = __uerange * __scaling; - while (__f != __t) - { - do - __ret = __uctype(__urng()) - __urngmin; - while (__ret >= __past); - *__f++ = __ret / __scaling + __param.a(); - } - } - } - else if (__urngrange < __urange) - { -# 444 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uniform_int_dist.h" 3 - __uctype __tmp; - while (__f != __t) - { - do - { - constexpr __uctype __uerngrange = __urngrange + 1; - __tmp = (__uerngrange * operator() - (__urng, param_type(0, __urange / __uerngrange))); - __ret = __tmp + (__uctype(__urng()) - __urngmin); - } - while (__ret > __urange || __ret < __tmp); - *__f++ = __ret; - } - } - else - while (__f != __t) - *__f++ = __uctype(__urng()) - __urngmin + __param.a(); - } - - - - -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algo.h" 2 3 - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 -# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 -# 1 "/usr/include/stdlib.h" 1 3 4 -# 26 "/usr/include/stdlib.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/stdlib.h" 2 3 4 - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 33 "/usr/include/stdlib.h" 2 3 4 - -extern "C" { - - - - - -# 1 "/usr/include/bits/waitflags.h" 1 3 4 -# 41 "/usr/include/stdlib.h" 2 3 4 -# 1 "/usr/include/bits/waitstatus.h" 1 3 4 -# 42 "/usr/include/stdlib.h" 2 3 4 -# 59 "/usr/include/stdlib.h" 3 4 -typedef struct - { - int quot; - int rem; - } div_t; - - - -typedef struct - { - long int quot; - long int rem; - } ldiv_t; - - - - - -__extension__ typedef struct - { - long long int quot; - long long int rem; - } lldiv_t; -# 98 "/usr/include/stdlib.h" 3 4 -extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; - - - -extern double atof (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - -extern int atoi (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - -extern long int atol (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - -__extension__ extern long long int atoll (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - -extern double strtod (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern float strtof (const char *__restrict __nptr, - char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); - -extern long double strtold (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 141 "/usr/include/stdlib.h" 3 4 -extern _Float32 strtof32 (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern _Float64 strtof64 (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 159 "/usr/include/stdlib.h" 3 4 -extern _Float32x strtof32x (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern _Float64x strtof64x (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 177 "/usr/include/stdlib.h" 3 4 -extern long int strtol (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -extern unsigned long int strtoul (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -__extension__ -extern long long int strtoq (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -__extension__ -extern unsigned long long int strtouq (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -__extension__ -extern long long int strtoll (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -__extension__ -extern unsigned long long int strtoull (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") - - - __attribute__ ((__nonnull__ (1))); -extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") - - - - __attribute__ ((__nonnull__ (1))); - -__extension__ -extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") - - - __attribute__ ((__nonnull__ (1))); -__extension__ -extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") - - - - __attribute__ ((__nonnull__ (1))); - -__extension__ -extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") - - - __attribute__ ((__nonnull__ (1))); -__extension__ -extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") - - - - __attribute__ ((__nonnull__ (1))); -# 278 "/usr/include/stdlib.h" 3 4 -extern int strfromd (char *__dest, size_t __size, const char *__format, - double __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - -extern int strfromf (char *__dest, size_t __size, const char *__format, - float __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - -extern int strfroml (char *__dest, size_t __size, const char *__format, - long double __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 298 "/usr/include/stdlib.h" 3 4 -extern int strfromf32 (char *__dest, size_t __size, const char * __format, - _Float32 __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - - -extern int strfromf64 (char *__dest, size_t __size, const char * __format, - _Float64 __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 316 "/usr/include/stdlib.h" 3 4 -extern int strfromf32x (char *__dest, size_t __size, const char * __format, - _Float32x __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - - -extern int strfromf64x (char *__dest, size_t __size, const char * __format, - _Float64x __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 340 "/usr/include/stdlib.h" 3 4 -extern long int strtol_l (const char *__restrict __nptr, - char **__restrict __endptr, int __base, - locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -extern unsigned long int strtoul_l (const char *__restrict __nptr, - char **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -__extension__ -extern long long int strtoll_l (const char *__restrict __nptr, - char **__restrict __endptr, int __base, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -__extension__ -extern unsigned long long int strtoull_l (const char *__restrict __nptr, - char **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - - - - - -extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") - - - - __attribute__ ((__nonnull__ (1, 4))); -extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -__extension__ -extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -__extension__ -extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -# 415 "/usr/include/stdlib.h" 3 4 -extern double strtod_l (const char *__restrict __nptr, - char **__restrict __endptr, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - -extern float strtof_l (const char *__restrict __nptr, - char **__restrict __endptr, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - -extern long double strtold_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 436 "/usr/include/stdlib.h" 3 4 -extern _Float32 strtof32_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern _Float64 strtof64_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 457 "/usr/include/stdlib.h" 3 4 -extern _Float32x strtof32x_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern _Float64x strtof64x_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 480 "/usr/include/stdlib.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) int - atoi (const char *__nptr) noexcept (true) -{ - return (int) strtol (__nptr, (char **) __null, 10); -} -extern __inline __attribute__ ((__gnu_inline__)) long int - atol (const char *__nptr) noexcept (true) -{ - return strtol (__nptr, (char **) __null, 10); -} - - -__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int - atoll (const char *__nptr) noexcept (true) -{ - return strtoll (__nptr, (char **) __null, 10); -} -# 505 "/usr/include/stdlib.h" 3 4 -extern char *l64a (long int __n) noexcept (true) ; - - -extern long int a64l (const char *__s) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - - -# 1 "/usr/include/sys/types.h" 1 3 4 -# 27 "/usr/include/sys/types.h" 3 4 -extern "C" { - - - - - -typedef __u_char u_char; -typedef __u_short u_short; -typedef __u_int u_int; -typedef __u_long u_long; -typedef __quad_t quad_t; -typedef __u_quad_t u_quad_t; -typedef __fsid_t fsid_t; - - -typedef __loff_t loff_t; - - - - -typedef __ino_t ino_t; - - - - - - -typedef __ino64_t ino64_t; - - - - -typedef __dev_t dev_t; - - - - -typedef __gid_t gid_t; - - - - -typedef __mode_t mode_t; - - - - -typedef __nlink_t nlink_t; - - - - -typedef __uid_t uid_t; - - - - - -typedef __off_t off_t; - - - - - - -typedef __off64_t off64_t; -# 103 "/usr/include/sys/types.h" 3 4 -typedef __id_t id_t; - - - - -typedef __ssize_t ssize_t; - - - - - -typedef __daddr_t daddr_t; -typedef __caddr_t caddr_t; - - - - - -typedef __key_t key_t; -# 134 "/usr/include/sys/types.h" 3 4 -typedef __useconds_t useconds_t; - - - -typedef __suseconds_t suseconds_t; - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 145 "/usr/include/sys/types.h" 2 3 4 - - - -typedef unsigned long int ulong; -typedef unsigned short int ushort; -typedef unsigned int uint; - - - - - - - -typedef __uint8_t u_int8_t; -typedef __uint16_t u_int16_t; -typedef __uint32_t u_int32_t; -typedef __uint64_t u_int64_t; - - -typedef int register_t __attribute__ ((__mode__ (__word__))); -# 176 "/usr/include/sys/types.h" 3 4 -# 1 "/usr/include/endian.h" 1 3 4 -# 35 "/usr/include/endian.h" 3 4 -# 1 "/usr/include/bits/byteswap.h" 1 3 4 -# 33 "/usr/include/bits/byteswap.h" 3 4 -static __inline __uint16_t -__bswap_16 (__uint16_t __bsx) -{ - - - - return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8))); - -} - - - - - - -static __inline __uint32_t -__bswap_32 (__uint32_t __bsx) -{ - - - - return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); - -} -# 69 "/usr/include/bits/byteswap.h" 3 4 -__extension__ static __inline __uint64_t -__bswap_64 (__uint64_t __bsx) -{ - - - - return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56)); - -} -# 36 "/usr/include/endian.h" 2 3 4 -# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 -# 32 "/usr/include/bits/uintn-identity.h" 3 4 -static __inline __uint16_t -__uint16_identity (__uint16_t __x) -{ - return __x; -} - -static __inline __uint32_t -__uint32_identity (__uint32_t __x) -{ - return __x; -} - -static __inline __uint64_t -__uint64_identity (__uint64_t __x) -{ - return __x; -} -# 37 "/usr/include/endian.h" 2 3 4 -# 177 "/usr/include/sys/types.h" 2 3 4 - - -# 1 "/usr/include/sys/select.h" 1 3 4 -# 30 "/usr/include/sys/select.h" 3 4 -# 1 "/usr/include/bits/select.h" 1 3 4 -# 31 "/usr/include/sys/select.h" 2 3 4 - - -# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 - - - - - - -typedef __sigset_t sigset_t; -# 34 "/usr/include/sys/select.h" 2 3 4 -# 49 "/usr/include/sys/select.h" 3 4 -typedef long int __fd_mask; -# 59 "/usr/include/sys/select.h" 3 4 -typedef struct - { - - - - __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; - - - - - - } fd_set; - - - - - - -typedef __fd_mask fd_mask; -# 91 "/usr/include/sys/select.h" 3 4 -extern "C" { -# 102 "/usr/include/sys/select.h" 3 4 -extern int select (int __nfds, fd_set *__restrict __readfds, - fd_set *__restrict __writefds, - fd_set *__restrict __exceptfds, - struct timeval *__restrict __timeout); -# 127 "/usr/include/sys/select.h" 3 4 -extern int pselect (int __nfds, fd_set *__restrict __readfds, - fd_set *__restrict __writefds, - fd_set *__restrict __exceptfds, - const struct timespec *__restrict __timeout, - const __sigset_t *__restrict __sigmask); -# 153 "/usr/include/sys/select.h" 3 4 -} -# 180 "/usr/include/sys/types.h" 2 3 4 - - - - - -typedef __blksize_t blksize_t; - - - - - - -typedef __blkcnt_t blkcnt_t; - - - -typedef __fsblkcnt_t fsblkcnt_t; - - - -typedef __fsfilcnt_t fsfilcnt_t; -# 219 "/usr/include/sys/types.h" 3 4 -typedef __blkcnt64_t blkcnt64_t; -typedef __fsblkcnt64_t fsblkcnt64_t; -typedef __fsfilcnt64_t fsfilcnt64_t; -# 230 "/usr/include/sys/types.h" 3 4 -} -# 515 "/usr/include/stdlib.h" 2 3 4 - - - - - - -extern long int random (void) noexcept (true); - - -extern void srandom (unsigned int __seed) noexcept (true); - - - - - -extern char *initstate (unsigned int __seed, char *__statebuf, - size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - -extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - - -struct random_data - { - int32_t *fptr; - int32_t *rptr; - int32_t *state; - int rand_type; - int rand_deg; - int rand_sep; - int32_t *end_ptr; - }; - -extern int random_r (struct random_data *__restrict __buf, - int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern int srandom_r (unsigned int __seed, struct random_data *__buf) - noexcept (true) __attribute__ ((__nonnull__ (2))); - -extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, - size_t __statelen, - struct random_data *__restrict __buf) - noexcept (true) __attribute__ ((__nonnull__ (2, 4))); - -extern int setstate_r (char *__restrict __statebuf, - struct random_data *__restrict __buf) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - - -extern int rand (void) noexcept (true); - -extern void srand (unsigned int __seed) noexcept (true); - - - -extern int rand_r (unsigned int *__seed) noexcept (true); - - - - - - - -extern double drand48 (void) noexcept (true); -extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern long int lrand48 (void) noexcept (true); -extern long int nrand48 (unsigned short int __xsubi[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern long int mrand48 (void) noexcept (true); -extern long int jrand48 (unsigned short int __xsubi[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern void srand48 (long int __seedval) noexcept (true); -extern unsigned short int *seed48 (unsigned short int __seed16v[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); -extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -struct drand48_data - { - unsigned short int __x[3]; - unsigned short int __old_x[3]; - unsigned short int __c; - unsigned short int __init; - __extension__ unsigned long long int __a; - - }; - - -extern int drand48_r (struct drand48_data *__restrict __buffer, - double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int erand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int lrand48_r (struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int nrand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int mrand48_r (struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int jrand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int srand48_r (long int __seedval, struct drand48_data *__buffer) - noexcept (true) __attribute__ ((__nonnull__ (2))); - -extern int seed48_r (unsigned short int __seed16v[3], - struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern int lcong48_r (unsigned short int __param[7], - struct drand48_data *__buffer) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern __uint32_t arc4random (void) - noexcept (true) ; - - -extern void arc4random_buf (void *__buf, size_t __size) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) - noexcept (true) ; - - - - -extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) - ; - -extern void *calloc (size_t __nmemb, size_t __size) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - - - -extern void *realloc (void *__ptr, size_t __size) - noexcept (true) __attribute__ ((__warn_unused_result__)) ; - - -extern void free (void *__ptr) noexcept (true); - - - - - - - -extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) - noexcept (true) __attribute__ ((__warn_unused_result__)) - - ; - - -extern void *reallocarray (void *__ptr, size_t __nmemb, s \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/__cpp_text_pipeline.cpp-cd270745.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/__cpp_text_pipeline.cpp-cd270745.cpp.tmp deleted file mode 100644 index 3a96fde..0000000 --- a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/__cpp_text_pipeline.cpp-cd270745.cpp.tmp +++ /dev/null @@ -1,37918 +0,0 @@ -# 1 "src/renderer/text_pipeline.cpp" -# 1 "" 1 -# 1 "" 3 -# 433 "" 3 -# 1 "" 1 -# 1 "" 2 -# 1 "src/renderer/text_pipeline.cpp" 2 -# 14 "src/renderer/text_pipeline.cpp" -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 -# 31 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 -# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - typedef long unsigned int size_t; - typedef long int ptrdiff_t; - - - typedef decltype(nullptr) nullptr_t; - - -#pragma GCC visibility push(default) - - - extern "C++" __attribute__ ((__noreturn__, __always_inline__)) - inline void __terminate() noexcept - { - void terminate() noexcept __attribute__ ((__noreturn__)); - terminate(); - } -#pragma GCC visibility pop -} -# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -namespace __gnu_cxx -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ -#pragma GCC visibility push(default) - - - - - constexpr inline bool - __is_constant_evaluated() noexcept - { - - - - - - return __builtin_is_constant_evaluated(); - - - - } -#pragma GCC visibility pop -} -# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 3 -# 1 "/usr/include/features.h" 1 3 4 -# 394 "/usr/include/features.h" 3 4 -# 1 "/usr/include/features-time64.h" 1 3 4 -# 20 "/usr/include/features-time64.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 21 "/usr/include/features-time64.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 22 "/usr/include/features-time64.h" 2 3 4 -# 395 "/usr/include/features.h" 2 3 4 -# 481 "/usr/include/features.h" 3 4 -# 1 "/usr/include/stdc-predef.h" 1 3 4 -# 482 "/usr/include/features.h" 2 3 4 -# 503 "/usr/include/features.h" 3 4 -# 1 "/usr/include/sys/cdefs.h" 1 3 4 -# 576 "/usr/include/sys/cdefs.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 577 "/usr/include/sys/cdefs.h" 2 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 578 "/usr/include/sys/cdefs.h" 2 3 4 -# 504 "/usr/include/features.h" 2 3 4 -# 527 "/usr/include/features.h" 3 4 -# 1 "/usr/include/gnu/stubs.h" 1 3 4 -# 10 "/usr/include/gnu/stubs.h" 3 4 -# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 -# 11 "/usr/include/gnu/stubs.h" 2 3 4 -# 528 "/usr/include/features.h" 2 3 4 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3 -# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 -# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 2 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 1 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 - template - class allocator; - - template<> - class allocator; - - - - - template - struct uses_allocator; - - template - struct allocator_traits; - - - - - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 - template - struct char_traits; - - template<> struct char_traits; - - template<> struct char_traits; - - - - - - - template<> struct char_traits; - template<> struct char_traits; - - -namespace __cxx11 { - - template, - typename _Alloc = allocator<_CharT> > - class basic_string; - -} - - - typedef basic_string string; - - - typedef basic_string wstring; -# 89 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stringfwd.h" 3 - typedef basic_string u16string; - - - typedef basic_string u32string; - - - - - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 - - - - -# 1 "/usr/include/wchar.h" 1 3 4 -# 27 "/usr/include/wchar.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/include/bits/floatn.h" 1 3 4 -# 119 "/usr/include/bits/floatn.h" 3 4 -# 1 "/usr/include/bits/floatn-common.h" 1 3 4 -# 24 "/usr/include/bits/floatn-common.h" 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 25 "/usr/include/bits/floatn-common.h" 2 3 4 -# 214 "/usr/include/bits/floatn-common.h" 3 4 -typedef float _Float32; -# 251 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float64; -# 268 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float32x; -# 285 "/usr/include/bits/floatn-common.h" 3 4 -typedef long double _Float64x; -# 120 "/usr/include/bits/floatn.h" 2 3 4 -# 31 "/usr/include/wchar.h" 2 3 4 - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 -typedef long unsigned int size_t; -# 36 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 -# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 -typedef __builtin_va_list __gnuc_va_list; -# 39 "/usr/include/wchar.h" 2 3 4 - - - - -typedef __gnuc_va_list va_list; - - - - - - - -# 1 "/usr/include/bits/wchar.h" 1 3 4 -# 52 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 -# 20 "/usr/include/bits/types/wint_t.h" 3 4 -typedef unsigned int wint_t; -# 53 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 - - - -# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 -# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 -typedef struct -{ - int __count; - union - { - unsigned int __wch; - char __wchb[4]; - } __value; -} __mbstate_t; -# 5 "/usr/include/bits/types/mbstate_t.h" 2 3 4 - -typedef __mbstate_t mbstate_t; -# 54 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 - - - -struct _IO_FILE; -typedef struct _IO_FILE __FILE; -# 55 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/include/bits/types/FILE.h" 1 3 4 - - - -struct _IO_FILE; - - -typedef struct _IO_FILE FILE; -# 58 "/usr/include/wchar.h" 2 3 4 - - -# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 -# 22 "/usr/include/bits/types/locale_t.h" 3 4 -# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 -# 27 "/usr/include/bits/types/__locale_t.h" 3 4 -struct __locale_struct -{ - - struct __locale_data *__locales[13]; - - - const unsigned short int *__ctype_b; - const int *__ctype_tolower; - const int *__ctype_toupper; - - - const char *__names[13]; -}; - -typedef struct __locale_struct *__locale_t; -# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 - -typedef __locale_t locale_t; -# 61 "/usr/include/wchar.h" 2 3 4 -# 90 "/usr/include/wchar.h" 3 4 -extern "C" { - - - -struct tm; - - - -extern wchar_t *wcscpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern wchar_t *wcsncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern size_t wcslcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern size_t wcslcat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern wchar_t *wcscat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern wchar_t *wcsncat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - -extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - -extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, - size_t __n) noexcept (true); - - - -extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - -extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - - - -extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - - -extern size_t wcsxfrm (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - - - - - -extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - - - - -extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - -extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) - __attribute__ ((__malloc__)) ; -# 189 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); -# 199 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - -extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) - noexcept (true) __attribute__ ((__pure__)); - - -extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 226 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 237 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - -extern wchar_t *wcstok (wchar_t *__restrict __s, - const wchar_t *__restrict __delim, - wchar_t **__restrict __ptr) noexcept (true); - - -extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); -# 258 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) - noexcept (true) __attribute__ ((__pure__)); -# 278 "/usr/include/wchar.h" 3 4 -extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - - -extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - -extern wchar_t *wmemcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - -extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true); - - -extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); - - - - -extern wchar_t *wmempcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) - noexcept (true); - - - - - -extern wint_t btowc (int __c) noexcept (true); - - - -extern int wctob (wint_t __c) noexcept (true); - - - -extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); - - - -extern size_t mbrtowc (wchar_t *__restrict __pwc, - const char *__restrict __s, size_t __n, - mbstate_t *__restrict __p) noexcept (true); - - -extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, - mbstate_t *__restrict __ps) noexcept (true); - - -extern size_t __mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); -extern size_t mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - - -extern wint_t __btowc_alias (int __c) __asm ("btowc"); -extern __inline __attribute__ ((__gnu_inline__)) wint_t - btowc (int __c) noexcept (true) -{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' - ? (wint_t) __c : __btowc_alias (__c)); } - -extern int __wctob_alias (wint_t __c) __asm ("wctob"); -extern __inline __attribute__ ((__gnu_inline__)) int - wctob (wint_t __wc) noexcept (true) -{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' - ? (int) __wc : __wctob_alias (__wc)); } - -extern __inline __attribute__ ((__gnu_inline__)) size_t - mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) - -{ return (__ps != __null - ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } - - - - -extern size_t mbsrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - -extern size_t mbsnrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __nmc, - size_t __len, mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsnrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, - size_t __nwc, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - -extern int wcwidth (wchar_t __c) noexcept (true); - - - -extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); - - - - - -extern double wcstod (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern float wcstof (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -extern long double wcstold (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 422 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 437 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 455 "/usr/include/wchar.h" 3 4 -extern long int wcstol (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) noexcept (true); - - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - - -extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); -# 561 "/usr/include/wchar.h" 3 4 -extern long int wcstol_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base, - locale_t __loc) noexcept (true); - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true); - - - - - -extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); - - - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); - - - - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); - - - - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); -# 630 "/usr/include/wchar.h" 3 4 -extern double wcstod_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern float wcstof_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern long double wcstold_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 649 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 667 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 689 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcpcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) noexcept (true); - - - -extern wchar_t *wcpncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true); -# 718 "/usr/include/wchar.h" 3 4 -extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern int fwide (__FILE *__fp, int __mode) noexcept (true); - - - - - - -extern int fwprintf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wprintf (const wchar_t *__restrict __format, ...) - ; - -extern int swprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, ...) - noexcept (true) ; - - - - - -extern int vfwprintf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwprintf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - -extern int vswprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; - - - - - - -extern int fwscanf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wscanf (const wchar_t *__restrict __format, ...) - ; - -extern int swscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, ...) - noexcept (true) ; -# 795 "/usr/include/wchar.h" 3 4 -extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") - - - ; -extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") - - ; -extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") - - - ; -# 851 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwscanf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - -extern int vswscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; -# 875 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") - - - ; -extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") - - ; -extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") - - - ; -# 935 "/usr/include/wchar.h" 3 4 -extern wint_t fgetwc (__FILE *__stream); -extern wint_t getwc (__FILE *__stream); - - - - - -extern wint_t getwchar (void); - - - - - - -extern wint_t fputwc (wchar_t __wc, __FILE *__stream); -extern wint_t putwc (wchar_t __wc, __FILE *__stream); - - - - - -extern wint_t putwchar (wchar_t __wc); - - - - - - - -extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - -extern int fputws (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern wint_t ungetwc (wint_t __wc, __FILE *__stream); -# 990 "/usr/include/wchar.h" 3 4 -extern wint_t getwc_unlocked (__FILE *__stream); -extern wint_t getwchar_unlocked (void); - - - - - - - -extern wint_t fgetwc_unlocked (__FILE *__stream); - - - - - - - -extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); -# 1016 "/usr/include/wchar.h" 3 4 -extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); -extern wint_t putwchar_unlocked (wchar_t __wc); -# 1026 "/usr/include/wchar.h" 3 4 -extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - - - -extern int fputws_unlocked (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp) noexcept (true); - - - - -extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp, - locale_t __loc) noexcept (true); -# 1073 "/usr/include/wchar.h" 3 4 -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 2 3 -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -namespace std -{ - using ::mbstate_t; -} -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::wint_t; - - using ::btowc; - using ::fgetwc; - using ::fgetws; - using ::fputwc; - using ::fputws; - using ::fwide; - using ::fwprintf; - using ::fwscanf; - using ::getwc; - using ::getwchar; - using ::mbrlen; - using ::mbrtowc; - using ::mbsinit; - using ::mbsrtowcs; - using ::putwc; - using ::putwchar; - - using ::swprintf; - - using ::swscanf; - using ::ungetwc; - using ::vfwprintf; - - using ::vfwscanf; - - - using ::vswprintf; - - - using ::vswscanf; - - using ::vwprintf; - - using ::vwscanf; - - using ::wcrtomb; - using ::wcscat; - using ::wcscmp; - using ::wcscoll; - using ::wcscpy; - using ::wcscspn; - using ::wcsftime; - using ::wcslen; - using ::wcsncat; - using ::wcsncmp; - using ::wcsncpy; - using ::wcsrtombs; - using ::wcsspn; - using ::wcstod; - - using ::wcstof; - - using ::wcstok; - using ::wcstol; - using ::wcstoul; - using ::wcsxfrm; - using ::wctob; - using ::wmemcmp; - using ::wmemcpy; - using ::wmemmove; - using ::wmemset; - using ::wprintf; - using ::wscanf; - using ::wcschr; - using ::wcspbrk; - using ::wcsrchr; - using ::wcsstr; - using ::wmemchr; - - - inline wchar_t* - wcschr(wchar_t* __p, wchar_t __c) - { return wcschr(const_cast(__p), __c); } - - inline wchar_t* - wcspbrk(wchar_t* __s1, const wchar_t* __s2) - { return wcspbrk(const_cast(__s1), __s2); } - - inline wchar_t* - wcsrchr(wchar_t* __p, wchar_t __c) - { return wcsrchr(const_cast(__p), __c); } - - inline wchar_t* - wcsstr(wchar_t* __s1, const wchar_t* __s2) - { return wcsstr(const_cast(__s1), __s2); } - - inline wchar_t* - wmemchr(wchar_t* __p, wchar_t __c, size_t __n) - { return wmemchr(const_cast(__p), __c, __n); } - - - -} -} - - - - - - - -namespace __gnu_cxx -{ - - - - - - using ::wcstold; -# 260 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 - using ::wcstoll; - using ::wcstoull; - -} - -namespace std -{ - using ::__gnu_cxx::wcstold; - using ::__gnu_cxx::wcstoll; - using ::__gnu_cxx::wcstoull; -} -# 280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -namespace std -{ - - using std::wcstof; - - - using std::vfwscanf; - - - using std::vswscanf; - - - using std::vwscanf; - - - - using std::wcstold; - using std::wcstoll; - using std::wcstoull; - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - typedef long int streamoff; - - - - - - typedef ptrdiff_t streamsize; -# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - template - class fpos - { - private: - streamoff _M_off; - _StateT _M_state; - - public: - - - - - fpos() - : _M_off(0), _M_state() { } -# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - fpos(streamoff __off) - : _M_off(__off), _M_state() { } - - - fpos(const fpos&) = default; - fpos& operator=(const fpos&) = default; - ~fpos() = default; - - - - operator streamoff() const { return _M_off; } - - - void - state(_StateT __st) - { _M_state = __st; } - - - _StateT - state() const - { return _M_state; } - - - - - - fpos& - operator+=(streamoff __off) - { - _M_off += __off; - return *this; - } - - - - - - fpos& - operator-=(streamoff __off) - { - _M_off -= __off; - return *this; - } - - - - - - - - fpos - operator+(streamoff __off) const - { - fpos __pos(*this); - __pos += __off; - return __pos; - } - - - - - - - - fpos - operator-(streamoff __off) const - { - fpos __pos(*this); - __pos -= __off; - return __pos; - } - - - - - - - streamoff - operator-(const fpos& __other) const - { return _M_off - __other._M_off; } - }; - - - - - - - template - inline bool - operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) - { return streamoff(__lhs) == streamoff(__rhs); } - - template - inline bool - operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) - { return streamoff(__lhs) != streamoff(__rhs); } - - - - - - typedef fpos streampos; - - typedef fpos wstreampos; -# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/postypes.h" 3 - typedef fpos u16streampos; - - typedef fpos u32streampos; - - - -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 76 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 - class ios_base; - - template > - class basic_ios; - - template > - class basic_streambuf; - - template > - class basic_istream; - - template > - class basic_ostream; - - template > - class basic_iostream; - - -namespace __cxx11 { - - template, - typename _Alloc = allocator<_CharT> > - class basic_stringbuf; - - template, - typename _Alloc = allocator<_CharT> > - class basic_istringstream; - - template, - typename _Alloc = allocator<_CharT> > - class basic_ostringstream; - - template, - typename _Alloc = allocator<_CharT> > - class basic_stringstream; - -} - - template > - class basic_filebuf; - - template > - class basic_ifstream; - - template > - class basic_ofstream; - - template > - class basic_fstream; - - template > - class istreambuf_iterator; - - template > - class ostreambuf_iterator; - - - - typedef basic_ios ios; - - - typedef basic_streambuf streambuf; - - - typedef basic_istream istream; - - - typedef basic_ostream ostream; - - - typedef basic_iostream iostream; - - - typedef basic_stringbuf stringbuf; - - - typedef basic_istringstream istringstream; - - - typedef basic_ostringstream ostringstream; - - - typedef basic_stringstream stringstream; - - - typedef basic_filebuf filebuf; - - - typedef basic_ifstream ifstream; - - - typedef basic_ofstream ofstream; - - - typedef basic_fstream fstream; - - - - typedef basic_ios wios; - - - typedef basic_streambuf wstreambuf; - - - typedef basic_istream wistream; - - - typedef basic_ostream wostream; - - - typedef basic_iostream wiostream; - - - typedef basic_stringbuf wstringbuf; - - - typedef basic_istringstream wistringstream; - - - typedef basic_ostringstream wostringstream; - - - typedef basic_stringstream wstringstream; - - - typedef basic_filebuf wfilebuf; - - - typedef basic_ifstream wifstream; - - - typedef basic_ofstream wofstream; - - - typedef basic_fstream wfstream; -# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/iosfwd" 3 -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 - - - -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 - class exception - { - public: - exception() noexcept { } - virtual ~exception() noexcept; - - exception(const exception&) = default; - exception& operator=(const exception&) = default; - exception(exception&&) = default; - exception& operator=(exception&&) = default; - - - - - virtual const char* - what() const noexcept; - }; - - - -} - -} -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 - -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - class bad_exception : public exception - { - public: - bad_exception() noexcept { } - - - - virtual ~bad_exception() noexcept; - - - virtual const char* - what() const noexcept; - }; - - - typedef void (*terminate_handler) (); - - - terminate_handler set_terminate(terminate_handler) noexcept; - - - - terminate_handler get_terminate() noexcept; - - - - - void terminate() noexcept __attribute__ ((__noreturn__)); - - - - typedef void (*__attribute__ ((__deprecated__)) unexpected_handler) (); - - - - - - __attribute__ ((__deprecated__)) - unexpected_handler set_unexpected(unexpected_handler) noexcept; - - - - - - - - __attribute__ ((__deprecated__)) - unexpected_handler get_unexpected() noexcept; - - - - - - - - __attribute__ ((__deprecated__)) - void unexpected() __attribute__ ((__noreturn__)); -# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - __attribute__ ((__deprecated__ ("use '" "std::uncaught_exceptions()" "' instead"))) - bool uncaught_exception() noexcept __attribute__ ((__pure__)); - - - - - - - - int uncaught_exceptions() noexcept __attribute__ ((__pure__)); - - - -} - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 3 - void __verbose_terminate_handler(); - - -} - -} - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 - -#pragma GCC visibility push(default) - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 -# 35 "/usr/lib/clang/16/include/stddef.h" 3 -typedef long int ptrdiff_t; -# 109 "/usr/lib/clang/16/include/stddef.h" 3 -# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 -# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 -typedef struct { - long long __clang_max_align_nonce1 - __attribute__((__aligned__(__alignof__(long long)))); - long double __clang_max_align_nonce2 - __attribute__((__aligned__(__alignof__(long double)))); -} max_align_t; -# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 2 3 -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_init_exception.h" 3 -namespace std -{ - class type_info; -} - -namespace __cxxabiv1 -{ - struct __cxa_refcounted_exception; - - extern "C" - { - - void* - __cxa_allocate_exception(size_t) noexcept; - - void - __cxa_free_exception(void*) noexcept; - - - __cxa_refcounted_exception* - __cxa_init_primary_exception(void *__object, std::type_info *__tinfo, - void ( *__dest) (void *)) - noexcept; - - } -} - - - -#pragma GCC visibility pop -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hash_bytes.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 2 3 - - -#pragma GCC visibility push(default) - - - - - -extern "C++" { - -namespace __cxxabiv1 -{ - class __class_type_info; -} -# 84 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 -namespace std -{ - - - - - - - class type_info - { - public: - - - - - virtual ~type_info(); - - - - const char* name() const noexcept - { return __name[0] == '*' ? __name + 1 : __name; } - - - - bool before(const type_info& __arg) const noexcept; - - - bool operator==(const type_info& __arg) const noexcept; - - - 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&) = delete; - type_info(const type_info&) = delete; -# 167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - }; - - - inline bool - type_info::before(const type_info& __arg) const noexcept - { - - - - - if (__name[0] != '*' || __arg.__name[0] != '*') - return __builtin_strcmp (__name, __arg.__name) < 0; -# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - return __name < __arg.__name; - } - - - - inline bool - type_info::operator==(const type_info& __arg) const noexcept - { - if (std::__is_constant_evaluated()) - return this == &__arg; - - if (__name == __arg.__name) - return true; - - - - - - - return __name[0] != '*' && __builtin_strcmp (__name, __arg.name()) == 0; - - - - } -# 220 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/typeinfo" 3 - class bad_cast : public exception - { - public: - bad_cast() noexcept { } - - - - virtual ~bad_cast() noexcept; - - - virtual const char* what() const noexcept; - }; - - - - - - class bad_typeid : public exception - { - public: - bad_typeid () noexcept { } - - - - virtual ~bad_typeid() noexcept; - - - virtual const char* what() const noexcept; - }; -} - -} - -#pragma GCC visibility pop -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 - - - - -#pragma GCC visibility push(default) - -extern "C++" { - -namespace std -{ - - - - - - - class bad_alloc : public exception - { - public: - bad_alloc() throw() { } - - - bad_alloc(const bad_alloc&) = default; - bad_alloc& operator=(const bad_alloc&) = default; - - - - - virtual ~bad_alloc() throw(); - - - virtual const char* what() const throw(); - }; - - - class bad_array_new_length : public bad_alloc - { - public: - bad_array_new_length() throw() { } - - - - virtual ~bad_array_new_length() throw(); - - - virtual const char* what() const throw(); - }; - - - - enum class align_val_t: size_t {}; - - - struct nothrow_t - { - - explicit nothrow_t() = default; - - }; - - extern const nothrow_t nothrow; - - - - typedef void (*new_handler)(); - - - - new_handler set_new_handler(new_handler) throw(); - - - - new_handler get_new_handler() noexcept; - -} -# 126 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -[[__nodiscard__]] void* operator new(std::size_t) - __attribute__((__externally_visible__)); -[[__nodiscard__]] void* operator new[](std::size_t) - __attribute__((__externally_visible__)); -void operator delete(void*) noexcept - __attribute__((__externally_visible__)); -void operator delete[](void*) noexcept - __attribute__((__externally_visible__)); - - - - - - -[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete(void*, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__)); -void operator delete[](void*, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__)); - -[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete(void*, std::align_val_t) - noexcept __attribute__((__externally_visible__)); -void operator delete(void*, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__)); -[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete[](void*, std::align_val_t) - noexcept __attribute__((__externally_visible__)); -void operator delete[](void*, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__)); -# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept -{ return __p; } -[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept -{ return __p; } - - -inline void operator delete (void*, void*) noexcept { } -inline void operator delete[](void*, void*) noexcept { } - -} - - -namespace std -{ - - - - template - [[nodiscard]] constexpr _Tp* - launder(_Tp* __p) noexcept - { return __builtin_launder(__p); } - - - - - template - void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; - template - void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; - - void launder(void*) = delete; - void launder(const void*) = delete; - void launder(volatile void*) = delete; - void launder(const volatile void*) = delete; - - - - - - - -} -# 236 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -#pragma GCC visibility pop -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - class reference_wrapper; -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } - - }; - - - - - - - - using true_type = integral_constant; - - - using false_type = integral_constant; - - - - template - using __bool_constant = integral_constant; - - - - - - - template - using bool_constant = integral_constant; - - - - - - - template - struct enable_if - { }; - - - template - struct enable_if - { typedef _Tp type; }; - - - template - using __enable_if_t = typename enable_if<_Cond, _Tp>::type; - - template - struct __conditional - { - template - using type = _Tp; - }; - - template<> - struct __conditional - { - template - using type = _Up; - }; - - - template - using __conditional_t - = typename __conditional<_Cond>::template type<_If, _Else>; - - - template - struct __type_identity - { using type = _Type; }; - - template - using __type_identity_t = typename __type_identity<_Tp>::type; - - namespace __detail - { - - template - using __first_t = _Tp; - - - template - auto __or_fn(int) -> __first_t...>; - - template - auto __or_fn(...) -> true_type; - - template - auto __and_fn(int) -> __first_t...>; - - template - auto __and_fn(...) -> false_type; - } - - - - - template - struct __or_ - : decltype(__detail::__or_fn<_Bn...>(0)) - { }; - - template - struct __and_ - : decltype(__detail::__and_fn<_Bn...>(0)) - { }; - - template - struct __not_ - : __bool_constant - { }; - - - - - - template - inline constexpr bool __or_v = __or_<_Bn...>::value; - template - inline constexpr bool __and_v = __and_<_Bn...>::value; - - namespace __detail - { - template - struct __disjunction_impl - { using type = _B1; }; - - template - struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __disjunction_impl::type; }; - - template - struct __conjunction_impl - { using type = _B1; }; - - template - struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __conjunction_impl::type; }; - } - - - - - template - struct conjunction - : __detail::__conjunction_impl::type - { }; - - template<> - struct conjunction<> - : true_type - { }; - - template - struct disjunction - : __detail::__disjunction_impl::type - { }; - - template<> - struct disjunction<> - : false_type - { }; - - template - struct negation - : __not_<_Pp>::type - { }; - - - - - template - inline constexpr bool conjunction_v = conjunction<_Bn...>::value; - - template - inline constexpr bool disjunction_v = disjunction<_Bn...>::value; - - template - inline constexpr bool negation_v = negation<_Pp>::value; - - - - - - template - struct is_reference; - template - struct is_function; - template - struct is_void; - template - struct remove_cv; - template - struct is_const; - - - template - struct __is_array_unknown_bounds; - - - - - template - constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) - { return {}; } - - template - constexpr typename __or_< - is_reference<_NestedType>, - is_function<_NestedType>, - is_void<_NestedType>, - __is_array_unknown_bounds<_NestedType> - >::type __is_complete_or_unbounded(_TypeIdentity) - { return {}; } - - - template - using __remove_cv_t = typename remove_cv<_Tp>::type; - - - - - - template - struct is_void - : public false_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - - template - struct __is_integral_helper - : public false_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; -# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_integral - : public __is_integral_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct __is_floating_point_helper - : public false_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; -# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_floating_point - : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_array - : public false_type { }; - - template - struct is_array<_Tp[_Size]> - : public true_type { }; - - template - struct is_array<_Tp[]> - : public true_type { }; - - template - struct __is_pointer_helper - : public false_type { }; - - template - struct __is_pointer_helper<_Tp*> - : public true_type { }; - - - template - struct is_pointer - : public __is_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_lvalue_reference - : public false_type { }; - - template - struct is_lvalue_reference<_Tp&> - : public true_type { }; - - - template - struct is_rvalue_reference - : public false_type { }; - - template - struct is_rvalue_reference<_Tp&&> - : public true_type { }; - - template - struct __is_member_object_pointer_helper - : public false_type { }; - - template - struct __is_member_object_pointer_helper<_Tp _Cp::*> - : public __not_>::type { }; - - - template - struct is_member_object_pointer - : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct __is_member_function_pointer_helper - : public false_type { }; - - template - struct __is_member_function_pointer_helper<_Tp _Cp::*> - : public is_function<_Tp>::type { }; - - - template - struct is_member_function_pointer - : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_enum - : public integral_constant - { }; - - - template - struct is_union - : public integral_constant - { }; - - - template - struct is_class - : public integral_constant - { }; - - - template - struct is_function - : public __bool_constant::value> { }; - - template - struct is_function<_Tp&> - : public false_type { }; - - template - struct is_function<_Tp&&> - : public false_type { }; - - - - - template - struct is_null_pointer - : public false_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - - - template - struct __is_nullptr_t - : public is_null_pointer<_Tp> - { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); - - - - - template - struct is_reference - : public false_type - { }; - - template - struct is_reference<_Tp&> - : public true_type - { }; - - template - struct is_reference<_Tp&&> - : public true_type - { }; - - - template - struct is_arithmetic - : public __or_, is_floating_point<_Tp>>::type - { }; - - - template - struct is_fundamental - : public __or_, is_void<_Tp>, - is_null_pointer<_Tp>>::type - { }; - - - template - struct is_object - : public __not_<__or_, is_reference<_Tp>, - is_void<_Tp>>>::type - { }; - - template - struct is_member_pointer; - - - template - struct is_scalar - : public __or_, is_enum<_Tp>, is_pointer<_Tp>, - is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type - { }; - - - template - struct is_compound - : public __not_>::type { }; - - - template - struct __is_member_pointer_helper - : public false_type { }; - - template - struct __is_member_pointer_helper<_Tp _Cp::*> - : public true_type { }; - - - - template - struct is_member_pointer - : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct is_same; - - - template - using __is_one_of = __or_...>; - - - __extension__ - template - using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, - signed char, signed short, signed int, signed long, - signed long long -# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - __extension__ - template - using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, - unsigned char, unsigned short, unsigned int, unsigned long, - unsigned long long -# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - template - using __is_standard_integer - = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; - - - template using __void_t = void; - - - - - - template - struct is_const - : public false_type { }; - - template - struct is_const<_Tp const> - : public true_type { }; - - - template - struct is_volatile - : public false_type { }; - - template - struct is_volatile<_Tp volatile> - : public true_type { }; - - - template - struct is_trivial - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copyable - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_standard_layout - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - template - struct - - is_pod - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct - [[__deprecated__]] - is_literal_type - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_empty - : public integral_constant - { }; - - - template - struct is_polymorphic - : public integral_constant - { }; - - - - - - template - struct is_final - : public integral_constant - { }; - - - - template - struct is_abstract - : public integral_constant - { }; - - - template::value> - struct __is_signed_helper - : public false_type { }; - - template - struct __is_signed_helper<_Tp, true> - : public integral_constant - { }; - - - - template - struct is_signed - : public __is_signed_helper<_Tp>::type - { }; - - - template - struct is_unsigned - : public __and_, __not_>>::type - { }; - - - template - _Up - __declval(int); - - template - _Tp - __declval(long); - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)); - - template - struct remove_all_extents; - - - template - struct __is_array_known_bounds - : public false_type - { }; - - template - struct __is_array_known_bounds<_Tp[_Size]> - : public true_type - { }; - - template - struct __is_array_unknown_bounds - : public false_type - { }; - - template - struct __is_array_unknown_bounds<_Tp[]> - : public true_type - { }; -# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - struct __do_is_destructible_impl - { - template().~_Tp())> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_destructible_impl - : public __do_is_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_destructible_safe; - - template - struct __is_destructible_safe<_Tp, false, false> - : public __is_destructible_impl::type>::type - { }; - - template - struct __is_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_destructible - : public __is_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - - struct __do_is_nt_destructible_impl - { - template - static __bool_constant().~_Tp())> - __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_nt_destructible_impl - : public __do_is_nt_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_nt_destructible_safe; - - template - struct __is_nt_destructible_safe<_Tp, false, false> - : public __is_nt_destructible_impl::type>::type - { }; - - template - struct __is_nt_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_nt_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_nothrow_destructible - : public __is_nt_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_constructible_impl - = __bool_constant<__is_constructible(_Tp, _Args...)>; - - - - template - struct is_constructible - : public __is_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_default_constructible - : public __is_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_lvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> - { using type = _Tp&; }; - - template - using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; - - - - template - struct is_copy_constructible - : public __is_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_rvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> - { using type = _Tp&&; }; - - template - using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; - - - - template - struct is_move_constructible - : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_constructible_impl - = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; - - - - template - struct is_nothrow_constructible - : public __is_nothrow_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_default_constructible - : public __is_nothrow_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; - - - - template - struct is_assignable - : public __is_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_copy_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_move_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_assignable_impl - = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; - - - - template - struct is_nothrow_assignable - : public __is_nothrow_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_constructible_impl - = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; - - - - template - struct is_trivially_constructible - : public __is_trivially_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_default_constructible - : public __is_trivially_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - struct __do_is_implicitly_default_constructible_impl - { - template - static void __helper(const _Tp&); - - template - static true_type __test(const _Tp&, - decltype(__helper({}))* = 0); - - static false_type __test(...); - }; - - template - struct __is_implicitly_default_constructible_impl - : public __do_is_implicitly_default_constructible_impl - { - typedef decltype(__test(declval<_Tp>())) type; - }; - - template - struct __is_implicitly_default_constructible_safe - : public __is_implicitly_default_constructible_impl<_Tp>::type - { }; - - template - struct __is_implicitly_default_constructible - : public __and_<__is_constructible_impl<_Tp>, - __is_implicitly_default_constructible_safe<_Tp>>::type - { }; - - - template - struct is_trivially_copy_constructible - : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_constructible - : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_assignable_impl - = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; - - - - template - struct is_trivially_assignable - : public __is_trivially_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copy_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_destructible - : public __and_<__is_destructible_safe<_Tp>, - __bool_constant<__has_trivial_destructor(_Tp)>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - struct has_virtual_destructor - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct alignment_of - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct rank - : public integral_constant { }; - - template - struct rank<_Tp[_Size]> - : public integral_constant::value> { }; - - template - struct rank<_Tp[]> - : public integral_constant::value> { }; - - - template - struct extent - : public integral_constant { }; - - template - struct extent<_Tp[_Size], 0> - : public integral_constant { }; - - template - struct extent<_Tp[_Size], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - template - struct extent<_Tp[], 0> - : public integral_constant { }; - - template - struct extent<_Tp[], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - - - - - template - struct is_same - - : public integral_constant - - - - { }; -# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_base_of - : public integral_constant - { }; - - - template - struct is_convertible - : public __bool_constant<__is_convertible(_From, _To)> - { }; -# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - using __is_array_convertible - = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; -# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_const - { typedef _Tp type; }; - - template - struct remove_const<_Tp const> - { typedef _Tp type; }; - - - template - struct remove_volatile - { typedef _Tp type; }; - - template - struct remove_volatile<_Tp volatile> - { typedef _Tp type; }; - - - - template - struct remove_cv - { using type = __remove_cv(_Tp); }; -# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct add_const - { using type = _Tp const; }; - - - template - struct add_volatile - { using type = _Tp volatile; }; - - - template - struct add_cv - { using type = _Tp const volatile; }; - - - - - - - template - using remove_const_t = typename remove_const<_Tp>::type; - - - template - using remove_volatile_t = typename remove_volatile<_Tp>::type; - - - template - using remove_cv_t = typename remove_cv<_Tp>::type; - - - template - using add_const_t = typename add_const<_Tp>::type; - - - template - using add_volatile_t = typename add_volatile<_Tp>::type; - - - template - using add_cv_t = typename add_cv<_Tp>::type; -# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_reference - { using type = _Tp; }; - - template - struct remove_reference<_Tp&> - { using type = _Tp; }; - - template - struct remove_reference<_Tp&&> - { using type = _Tp; }; - - - - template - struct add_lvalue_reference - { using type = __add_lval_ref_t<_Tp>; }; - - - template - struct add_rvalue_reference - { using type = __add_rval_ref_t<_Tp>; }; - - - - template - using remove_reference_t = typename remove_reference<_Tp>::type; - - - template - using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; - - - template - using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; - - - - - - - - template - struct __cv_selector; - - template - struct __cv_selector<_Unqualified, false, false> - { 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; }; -# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_unsigned_selector; - - template - class __make_unsigned_selector<_Tp, true, false> - { - using __unsigned_type - = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - class __make_unsigned_selector_base - { - protected: - template struct _List { }; - - template - struct _List<_Tp, _Up...> : _List<_Up...> - { static constexpr size_t __size = sizeof(_Tp); }; - - template - struct __select; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, true> - { using __type = _Uint; }; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, false> - : __select<_Sz, _List<_UInts...>> - { }; - }; - - - template - class __make_unsigned_selector<_Tp, false, true> - : __make_unsigned_selector_base - { - - using _UInts = _List; - - using __unsigned_type = typename __select::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - - - - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; -# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - - - - - - template - struct make_unsigned - { typedef typename __make_unsigned_selector<_Tp>::__type type; }; - - - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - - - - - template - struct __make_signed - { typedef _Tp __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed short __type; }; - - template<> - struct __make_signed - { typedef signed int __type; }; - - template<> - struct __make_signed - { typedef signed long __type; }; - - template<> - struct __make_signed - { typedef signed long long __type; }; -# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_signed_selector; - - template - class __make_signed_selector<_Tp, true, false> - { - using __signed_type - = typename __make_signed<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; - }; - - - template - class __make_signed_selector<_Tp, false, true> - { - typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; - - public: - typedef typename __make_signed_selector<__unsigned_type>::__type __type; - }; - - - - - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; -# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - - - - - - template - struct make_signed - { typedef typename __make_signed_selector<_Tp>::__type type; }; - - - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - - - - template - using make_signed_t = typename make_signed<_Tp>::type; - - - template - using make_unsigned_t = typename make_unsigned<_Tp>::type; - - - - - - template - struct remove_extent - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[_Size]> - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[]> - { typedef _Tp type; }; - - - template - struct remove_all_extents - { typedef _Tp type; }; - - template - struct remove_all_extents<_Tp[_Size]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - template - struct remove_all_extents<_Tp[]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - - - template - using remove_extent_t = typename remove_extent<_Tp>::type; - - - template - using remove_all_extents_t = typename remove_all_extents<_Tp>::type; - - - - - template - struct __remove_pointer_helper - { typedef _Tp type; }; - - template - struct __remove_pointer_helper<_Tp, _Up*> - { typedef _Up type; }; - - - template - struct remove_pointer - : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> - { }; - - template - struct __add_pointer_helper - { using type = _Tp; }; - - template - struct __add_pointer_helper<_Tp, __void_t<_Tp*>> - { using type = _Tp*; }; - - - template - struct add_pointer - : public __add_pointer_helper<_Tp> - { }; - - template - struct add_pointer<_Tp&> - { using type = _Tp*; }; - - template - struct add_pointer<_Tp&&> - { using type = _Tp*; }; - - - - template - using remove_pointer_t = typename remove_pointer<_Tp>::type; - - - template - using add_pointer_t = typename add_pointer<_Tp>::type; - - - template - struct __aligned_storage_msa - { - union __type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__)) { } __align; - }; - }; -# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::__type)> - struct - - aligned_storage - { - union type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__((_Align)))) { } __align; - }; - }; - - template - struct __strictest_alignment - { - static const size_t _S_alignment = 0; - static const size_t _S_size = 0; - }; - - template - struct __strictest_alignment<_Tp, _Types...> - { - static const size_t _S_alignment = - alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment - ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; - static const size_t _S_size = - sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size - ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -#pragma GCC diagnostic pop - - - - - - template - struct __decay_selector - : __conditional_t::value, - remove_cv<_Up>, - add_pointer<_Up>> - { }; - - template - struct __decay_selector<_Up[_Nm]> - { using type = _Up*; }; - - template - struct __decay_selector<_Up[]> - { using type = _Up*; }; - - - - - template - struct decay - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&> - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&&> - { using type = typename __decay_selector<_Tp>::type; }; - - - - - template - struct __strip_reference_wrapper - { - typedef _Tp __type; - }; - - template - struct __strip_reference_wrapper > - { - typedef _Tp& __type; - }; - - - template - using __decay_t = typename decay<_Tp>::type; - - template - using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; - - - - - - template - using _Require = __enable_if_t<__and_<_Cond...>::value>; - - - template - using __remove_cvref_t - = typename remove_cv::type>::type; - - - - - template - struct conditional - { typedef _Iftrue type; }; - - - template - struct conditional - { typedef _Iffalse type; }; - - - template - struct common_type; -# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __success_type - { typedef _Tp type; }; - - struct __failure_type - { }; - - struct __do_common_type_impl - { - template - using __cond_t - = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); - - - - template - static __success_type<__decay_t<__cond_t<_Tp, _Up>>> - _S_test(int); -# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - static __failure_type - _S_test_2(...); - - template - static decltype(_S_test_2<_Tp, _Up>(0)) - _S_test(...); - }; - - - template<> - struct common_type<> - { }; - - - template - struct common_type<_Tp0> - : public common_type<_Tp0, _Tp0> - { }; - - - template, typename _Dp2 = __decay_t<_Tp2>> - struct __common_type_impl - { - - - using type = common_type<_Dp1, _Dp2>; - }; - - template - struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> - : private __do_common_type_impl - { - - - using type = decltype(_S_test<_Tp1, _Tp2>(0)); - }; - - - template - struct common_type<_Tp1, _Tp2> - : public __common_type_impl<_Tp1, _Tp2>::type - { }; - - template - struct __common_type_pack - { }; - - template - struct __common_type_fold; - - - template - struct common_type<_Tp1, _Tp2, _Rp...> - : public __common_type_fold, - __common_type_pack<_Rp...>> - { }; - - - - - template - struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, - __void_t> - : public common_type - { }; - - - template - struct __common_type_fold<_CTp, _Rp, void> - { }; - - template::value> - struct __underlying_type_impl - { - using type = __underlying_type(_Tp); - }; - - template - struct __underlying_type_impl<_Tp, false> - { }; - - - - template - struct underlying_type - : public __underlying_type_impl<_Tp> - { }; - - - template - struct __declval_protector - { - static const bool __stop = false; - }; - - - - - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)) - { - static_assert(__declval_protector<_Tp>::__stop, - "declval() must not be used!"); - return __declval<_Tp>(0); - } - - - template - struct result_of; - - - - - - - struct __invoke_memfun_ref { }; - struct __invoke_memfun_deref { }; - struct __invoke_memobj_ref { }; - struct __invoke_memobj_deref { }; - struct __invoke_other { }; - - - template - struct __result_of_success : __success_type<_Tp> - { using __invoke_type = _Tag; }; - - - struct __result_of_memfun_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_ref - : private __result_of_memfun_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memfun_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_deref - : private __result_of_memfun_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memobj_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>() - ), __invoke_memobj_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_ref - : private __result_of_memobj_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - - struct __result_of_memobj_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>() - ), __invoke_memobj_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_deref - : private __result_of_memobj_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - template - struct __result_of_memobj; - - template - struct __result_of_memobj<_Res _Class::*, _Arg> - { - typedef __remove_cvref_t<_Arg> _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t<__or_, - is_base_of<_Class, _Argval>>::value, - __result_of_memobj_ref<_MemPtr, _Arg>, - __result_of_memobj_deref<_MemPtr, _Arg> - >::type type; - }; - - template - struct __result_of_memfun; - - template - struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> - { - typedef typename remove_reference<_Arg>::type _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t::value, - __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, - __result_of_memfun_deref<_MemPtr, _Arg, _Args...> - >::type type; - }; - - - - - - - template> - struct __inv_unwrap - { - using type = _Tp; - }; - - template - struct __inv_unwrap<_Tp, reference_wrapper<_Up>> - { - using type = _Up&; - }; - - template - struct __result_of_impl - { - typedef __failure_type type; - }; - - template - struct __result_of_impl - : public __result_of_memobj<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type> - { }; - - template - struct __result_of_impl - : public __result_of_memfun<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type, _Args...> - { }; - - - struct __result_of_other_impl - { - template - static __result_of_success()(std::declval<_Args>()...) - ), __invoke_other> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_impl - : private __result_of_other_impl - { - typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; - }; - - - template - struct __invoke_result - : public __result_of_impl< - is_member_object_pointer< - typename remove_reference<_Functor>::type - >::value, - is_member_function_pointer< - typename remove_reference<_Functor>::type - >::value, - _Functor, _ArgTypes... - >::type - { }; - - - template - struct result_of<_Functor(_ArgTypes...)> - : public __invoke_result<_Functor, _ArgTypes...> - { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template::__type)> - using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; - - template - using aligned_union_t = typename aligned_union<_Len, _Types...>::type; -#pragma GCC diagnostic pop - - - template - using decay_t = typename decay<_Tp>::type; - - - template - using enable_if_t = typename enable_if<_Cond, _Tp>::type; - - - template - using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; - - - template - using common_type_t = typename common_type<_Tp...>::type; - - - template - using underlying_type_t = typename underlying_type<_Tp>::type; - - - template - using result_of_t = typename result_of<_Tp>::type; - - - - - - template using void_t = void; -# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template class _Op, typename... _Args> - struct __detector - { - using type = _Default; - using __is_detected = false_type; - }; - - - template class _Op, - typename... _Args> - struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> - { - using type = _Op<_Args...>; - using __is_detected = true_type; - }; - - template class _Op, - typename... _Args> - using __detected_or = __detector<_Default, void, _Op, _Args...>; - - - - template class _Op, - typename... _Args> - using __detected_or_t - = typename __detected_or<_Default, _Op, _Args...>::type; -# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __is_swappable; - - template - struct __is_nothrow_swappable; - - template - struct __is_tuple_like_impl : false_type - { }; - - - template - struct __is_tuple_like - : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type - { }; - - - template - - inline - _Require<__not_<__is_tuple_like<_Tp>>, - is_move_constructible<_Tp>, - is_move_assignable<_Tp>> - swap(_Tp&, _Tp&) - noexcept(__and_, - is_nothrow_move_assignable<_Tp>>::value); - - template - - inline - __enable_if_t<__is_swappable<_Tp>::value> - swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(__is_nothrow_swappable<_Tp>::value); - - - namespace __swappable_details { - using std::swap; - - struct __do_is_swappable_impl - { - template(), std::declval<_Tp&>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_impl - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_nothrow_swappable_impl - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_swappable - : public __is_swappable_impl<_Tp>::type - { }; - - template - struct __is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { }; - - - - - - - - template - struct is_swappable - : public __is_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_v = - is_swappable<_Tp>::value; - - - template - inline constexpr bool is_nothrow_swappable_v = - is_nothrow_swappable<_Tp>::value; - - - - namespace __swappable_with_details { - using std::swap; - - struct __do_is_swappable_with_impl - { - template(), std::declval<_Up>())), - typename - = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_with_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) - && - noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_with_impl - : public __swappable_with_details::__do_is_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - template - struct __is_nothrow_swappable_with_impl - : public __swappable_with_details::__do_is_nothrow_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - - - template - struct is_swappable_with - : public __is_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable_with - : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_with_v = - is_swappable_with<_Tp, _Up>::value; - - - template - inline constexpr bool is_nothrow_swappable_with_v = - is_nothrow_swappable_with<_Tp, _Up>::value; -# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, typename = void> - struct __is_invocable_impl - : false_type - { - using __nothrow_conv = false_type; - }; - - - template - struct __is_invocable_impl<_Result, _Ret, - true, - __void_t> - : true_type - { - using __nothrow_conv = true_type; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - - template - struct __is_invocable_impl<_Result, _Ret, - false, - __void_t> - { - private: - - using _Res_t = typename _Result::type; - - - - static _Res_t _S_get() noexcept; - - - template - static void _S_conv(__type_identity_t<_Tp>) noexcept; - - - template(_S_get())), - typename = decltype(_S_conv<_Tp>(_S_get())), - - - - bool _Dangle = false - - > - static __bool_constant<_Nothrow && !_Dangle> - _S_test(int); - - template - static false_type - _S_test(...); - - public: - - using type = decltype(_S_test<_Ret, true>(1)); - - - using __nothrow_conv = decltype(_S_test<_Ret>(1)); - }; -#pragma GCC diagnostic pop - - template - struct __is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { }; - - template - constexpr bool __call_is_nt(__invoke_memfun_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept((std::declval<_Up>().*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memfun_deref) - { - return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept(std::declval<_Up>().*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_deref) - { - return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_other) - { - return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); - } - - template - struct __call_is_nothrow - : __bool_constant< - std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) - > - { }; - - template - using __call_is_nothrow_ - = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; - - - template - struct __is_nothrow_invocable - : __and_<__is_invocable<_Fn, _Args...>, - __call_is_nothrow_<_Fn, _Args...>>::type - { }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - struct __nonesuchbase {}; - struct __nonesuch : private __nonesuchbase { - ~__nonesuch() = delete; - __nonesuch(__nonesuch const&) = delete; - void operator=(__nonesuch const&) = delete; - }; -#pragma GCC diagnostic pop - - - - - - - template - struct invoke_result - : public __invoke_result<_Functor, _ArgTypes...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), - "_Functor must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; - - - template - struct is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - struct is_invocable_r - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_invocable - : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - - - - template - using __is_nt_invocable_impl - = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; - - - - template - struct is_nothrow_invocable_r - : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; -# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -template - inline constexpr bool is_void_v = is_void<_Tp>::value; -template - inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; -template - inline constexpr bool is_integral_v = is_integral<_Tp>::value; -template - inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; - -template - inline constexpr bool is_array_v = false; -template - inline constexpr bool is_array_v<_Tp[]> = true; -template - inline constexpr bool is_array_v<_Tp[_Num]> = true; - -template - inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; -template - inline constexpr bool is_lvalue_reference_v = false; -template - inline constexpr bool is_lvalue_reference_v<_Tp&> = true; -template - inline constexpr bool is_rvalue_reference_v = false; -template - inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; -template - inline constexpr bool is_member_object_pointer_v = - is_member_object_pointer<_Tp>::value; -template - inline constexpr bool is_member_function_pointer_v = - is_member_function_pointer<_Tp>::value; -template - inline constexpr bool is_enum_v = __is_enum(_Tp); -template - inline constexpr bool is_union_v = __is_union(_Tp); -template - inline constexpr bool is_class_v = __is_class(_Tp); -template - inline constexpr bool is_function_v = is_function<_Tp>::value; -template - inline constexpr bool is_reference_v = false; -template - inline constexpr bool is_reference_v<_Tp&> = true; -template - inline constexpr bool is_reference_v<_Tp&&> = true; -template - inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; -template - inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; -template - inline constexpr bool is_object_v = is_object<_Tp>::value; -template - inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; -template - inline constexpr bool is_compound_v = is_compound<_Tp>::value; -template - inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; -template - inline constexpr bool is_const_v = false; -template - inline constexpr bool is_const_v = true; -template - inline constexpr bool is_volatile_v = false; -template - inline constexpr bool is_volatile_v = true; - -template - inline constexpr bool is_trivial_v = __is_trivial(_Tp); -template - inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); -template - inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); -template - - inline constexpr bool is_pod_v = __is_pod(_Tp); -template - [[__deprecated__]] - inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); -template - inline constexpr bool is_empty_v = __is_empty(_Tp); -template - inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); -template - inline constexpr bool is_abstract_v = __is_abstract(_Tp); -template - inline constexpr bool is_final_v = __is_final(_Tp); - -template - inline constexpr bool is_signed_v = is_signed<_Tp>::value; -template - inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; - -template - inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); -template - inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); -template - inline constexpr bool is_copy_constructible_v - = __is_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_move_constructible_v - = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); -template - inline constexpr bool is_copy_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); -template - inline constexpr bool is_move_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; - -template - inline constexpr bool is_trivially_constructible_v - = __is_trivially_constructible(_Tp, _Args...); -template - inline constexpr bool is_trivially_default_constructible_v - = __is_trivially_constructible(_Tp); -template - inline constexpr bool is_trivially_copy_constructible_v - = __is_trivially_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_constructible_v - = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_trivially_assignable_v - = __is_trivially_assignable(_Tp, _Up); -template - inline constexpr bool is_trivially_copy_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>); -template - inline constexpr bool is_trivially_destructible_v = - is_trivially_destructible<_Tp>::value; -template - inline constexpr bool is_nothrow_constructible_v - = __is_nothrow_constructible(_Tp, _Args...); -template - inline constexpr bool is_nothrow_default_constructible_v - = __is_nothrow_constructible(_Tp); -template - inline constexpr bool is_nothrow_copy_constructible_v - = __is_nothrow_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_constructible_v - = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_assignable_v - = __is_nothrow_assignable(_Tp, _Up); -template - inline constexpr bool is_nothrow_copy_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_destructible_v = - is_nothrow_destructible<_Tp>::value; - -template - inline constexpr bool has_virtual_destructor_v - = __has_virtual_destructor(_Tp); - -template - inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; - -template - inline constexpr size_t rank_v = 0; -template - inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; -template - inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; - -template - inline constexpr size_t extent_v = 0; -template - inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; -template - inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; -template - inline constexpr size_t extent_v<_Tp[], 0> = 0; -template - inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; - - -template - inline constexpr bool is_same_v = __is_same(_Tp, _Up); - - - - - - -template - inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); -template - inline constexpr bool is_convertible_v = __is_convertible(_From, _To); -template - inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_v - = is_nothrow_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_invocable_r_v - = is_invocable_r<_Ret, _Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_r_v - = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; - - - - - - - template - struct has_unique_object_representations - : bool_constant<__has_unique_object_representations( - remove_cv_t> - )> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - inline constexpr bool has_unique_object_representations_v - = has_unique_object_representations<_Tp>::value; - - - - - - - template - struct is_aggregate - : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> - { }; - - - - - - template - inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); -# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -} -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - inline constexpr _Tp* - __addressof(_Tp& __r) noexcept - { return __builtin_addressof(__r); } -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type& __t) noexcept - { return static_cast<_Tp&&>(__t); } - - - - - - - - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type&& __t) noexcept - { - static_assert(!std::is_lvalue_reference<_Tp>::value, - "std::forward must not be used to convert an rvalue to an lvalue"); - return static_cast<_Tp&&>(__t); - } - - - - - - - template - [[__nodiscard__]] - constexpr typename std::remove_reference<_Tp>::type&& - move(_Tp&& __t) noexcept - { return static_cast::type&&>(__t); } - - - template - struct __move_if_noexcept_cond - : public __and_<__not_>, - is_copy_constructible<_Tp>>::type { }; -# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr - __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> - move_if_noexcept(_Tp& __x) noexcept - { return std::move(__x); } -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - inline constexpr _Tp* - addressof(_Tp& __r) noexcept - { return std::__addressof(__r); } - - - - template - const _Tp* addressof(const _Tp&&) = delete; - - - template - - inline _Tp - __exchange(_Tp& __obj, _Up&& __new_val) - { - _Tp __old_val = std::move(__obj); - __obj = std::forward<_Up>(__new_val); - return __old_val; - } -# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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]); - } - - - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 2 3 - - - - - - - - -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - class type_info; - - - - - - - namespace __exception_ptr - { - class exception_ptr; - } - - using __exception_ptr::exception_ptr; -# 75 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - exception_ptr current_exception() noexcept; - - template - exception_ptr make_exception_ptr(_Ex) noexcept; - - - void rethrow_exception(exception_ptr) __attribute__ ((__noreturn__)); - - namespace __exception_ptr - { - using std::rethrow_exception; -# 97 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - class exception_ptr - { - void* _M_exception_object; - - explicit exception_ptr(void* __e) noexcept; - - void _M_addref() noexcept; - void _M_release() noexcept; - - void *_M_get() const noexcept __attribute__ ((__pure__)); - - friend exception_ptr std::current_exception() noexcept; - friend void std::rethrow_exception(exception_ptr); - template - friend exception_ptr std::make_exception_ptr(_Ex) noexcept; - - public: - exception_ptr() noexcept; - - exception_ptr(const exception_ptr&) noexcept; - - - exception_ptr(nullptr_t) noexcept - : _M_exception_object(nullptr) - { } - - exception_ptr(exception_ptr&& __o) noexcept - : _M_exception_object(__o._M_exception_object) - { __o._M_exception_object = nullptr; } -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -# 162 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - explicit operator bool() const noexcept - { return _M_exception_object; } - - - - - - - - friend bool - operator==(const exception_ptr& __x, const exception_ptr& __y) - noexcept - { return __x._M_exception_object == __y._M_exception_object; } - - friend bool - operator!=(const exception_ptr& __x, const exception_ptr& __y) - noexcept - { return __x._M_exception_object != __y._M_exception_object; } - - - const class std::type_info* - __cxa_exception_type() const noexcept - __attribute__ ((__pure__)); - }; - - - inline - exception_ptr::exception_ptr() noexcept - : _M_exception_object(0) - { } - - - inline - exception_ptr::exception_ptr(const exception_ptr& __other) - noexcept - : _M_exception_object(__other._M_exception_object) - { - if (_M_exception_object) - _M_addref(); - } - - - inline - exception_ptr::~exception_ptr() noexcept - { - if (_M_exception_object) - _M_release(); - } - - - inline exception_ptr& - exception_ptr::operator=(const exception_ptr& __other) noexcept - { - exception_ptr(__other).swap(*this); - return *this; - } - - - inline void - exception_ptr::swap(exception_ptr &__other) noexcept - { - void *__tmp = _M_exception_object; - _M_exception_object = __other._M_exception_object; - __other._M_exception_object = __tmp; - } - - - inline void - swap(exception_ptr& __lhs, exception_ptr& __rhs) - { __lhs.swap(__rhs); } - - - template - - inline void - __dest_thunk(void* __x) - { static_cast<_Ex*>(__x)->~_Ex(); } - - - } - - using __exception_ptr::swap; - - - - template - exception_ptr - make_exception_ptr(_Ex __ex) noexcept - { - - using _Ex2 = typename decay<_Ex>::type; - void* __e = __cxxabiv1::__cxa_allocate_exception(sizeof(_Ex)); - (void) __cxxabiv1::__cxa_init_primary_exception( - __e, const_cast(&typeid(_Ex)), - __exception_ptr::__dest_thunk<_Ex2>); - try - { - ::new (__e) _Ex2(__ex); - return exception_ptr(__e); - } - catch(...) - { - __cxxabiv1::__cxa_free_exception(__e); - return current_exception(); - } -# 277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 - } -# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_ptr.h" 3 -} - -} -# 165 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - class nested_exception - { - exception_ptr _M_ptr; - - public: - - nested_exception() noexcept : _M_ptr(current_exception()) { } - - nested_exception(const nested_exception&) noexcept = 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)) - { } - }; -# 145 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - 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"); - - - if constexpr (is_class_v<_Up>) - if constexpr (!is_final_v<_Up>) - if constexpr (!is_base_of_v) - throw _Nested_exception<_Up>{std::forward<_Tp>(__t)}; - throw std::forward<_Tp>(__t); - - - - - - } -# 203 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - template - - - - inline void - rethrow_if_nested(const _Ex& __ex) - { - const _Ex* __ptr = __builtin_addressof(__ex); -# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/nested_exception.h" 3 - if constexpr (!is_polymorphic_v<_Ex>) - return; - else if constexpr (is_base_of_v - && !is_convertible_v<_Ex*, nested_exception*>) - return; - - - - - else if (auto __ne_ptr = dynamic_cast(__ptr)) - __ne_ptr->rethrow_nested(); - - } - - -} - -} -# 166 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/exception" 2 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 - - - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 2 3 -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - -#pragma GCC diagnostic push - - -#pragma GCC diagnostic ignored "-Warray-bounds" -# 83 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 - template - struct _Char_types - { - typedef unsigned long int_type; - - typedef std::streampos pos_type; - typedef std::streamoff off_type; - typedef std::mbstate_t state_type; - - }; -# 110 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 - template - struct char_traits - { - typedef _CharT char_type; - typedef typename _Char_types<_CharT>::int_type int_type; - - typedef typename _Char_types<_CharT>::pos_type pos_type; - typedef typename _Char_types<_CharT>::off_type off_type; - typedef typename _Char_types<_CharT>::state_type state_type; - - - - - - static constexpr void - assign(char_type& __c1, const char_type& __c2) - { - - - - - - __c1 = __c2; - } - - static constexpr bool - eq(const char_type& __c1, const char_type& __c2) - { return __c1 == __c2; } - - static constexpr bool - lt(const char_type& __c1, const char_type& __c2) - { return __c1 < __c2; } - - static constexpr int - compare(const char_type* __s1, const char_type* __s2, std::size_t __n); - - static constexpr std::size_t - length(const char_type* __s); - - static constexpr const char_type* - find(const char_type* __s, std::size_t __n, const char_type& __a); - - static char_type* - move(char_type* __s1, const char_type* __s2, std::size_t __n); - - static char_type* - copy(char_type* __s1, const char_type* __s2, std::size_t __n); - - static char_type* - assign(char_type* __s, std::size_t __n, char_type __a); - - static constexpr char_type - to_char_type(const int_type& __c) - { return static_cast(__c); } - - static constexpr int_type - to_int_type(const char_type& __c) - { return static_cast(__c); } - - static constexpr bool - eq_int_type(const int_type& __c1, const int_type& __c2) - { return __c1 == __c2; } - - - static constexpr int_type - eof() - { return static_cast(-1); } - - static constexpr int_type - not_eof(const int_type& __c) - { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } - - }; - - template - constexpr int - char_traits<_CharT>:: - compare(const char_type* __s1, const char_type* __s2, std::size_t __n) - { - for (std::size_t __i = 0; __i < __n; ++__i) - if (lt(__s1[__i], __s2[__i])) - return -1; - else if (lt(__s2[__i], __s1[__i])) - return 1; - return 0; - } - - template - constexpr std::size_t - char_traits<_CharT>:: - length(const char_type* __p) - { - std::size_t __i = 0; - while (!eq(__p[__i], char_type())) - ++__i; - return __i; - } - - template - constexpr const typename char_traits<_CharT>::char_type* - char_traits<_CharT>:: - find(const char_type* __s, std::size_t __n, const char_type& __a) - { - for (std::size_t __i = 0; __i < __n; ++__i) - if (eq(__s[__i], __a)) - return __s + __i; - return 0; - } - - template - - typename char_traits<_CharT>::char_type* - char_traits<_CharT>:: - move(char_type* __s1, const char_type* __s2, std::size_t __n) - { - if (__n == 0) - return __s1; -# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 - __builtin_memmove(__s1, __s2, __n * sizeof(char_type)); - return __s1; - } - - template - - typename char_traits<_CharT>::char_type* - char_traits<_CharT>:: - copy(char_type* __s1, const char_type* __s2, std::size_t __n) - { - if (__n == 0) - return __s1; -# 276 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 - __builtin_memcpy(__s1, __s2, __n * sizeof(char_type)); - return __s1; - } - - template - - typename char_traits<_CharT>::char_type* - char_traits<_CharT>:: - assign(char_type* __s, std::size_t __n, char_type __a) - { -# 295 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 - if constexpr (sizeof(_CharT) == 1 && __is_trivial(_CharT)) - { - if (__n) - { - unsigned char __c; - __builtin_memcpy(&__c, __builtin_addressof(__a), 1); - __builtin_memset(__s, __c, __n); - } - } - else - { - for (std::size_t __i = 0; __i < __n; ++__i) - __s[__i] = __a; - } - return __s; - } - - -} - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 - template - struct char_traits : public __gnu_cxx::char_traits<_CharT> - { }; - - - - template<> - struct char_traits - { - typedef char char_type; - typedef int int_type; - - typedef streampos pos_type; - typedef streamoff off_type; - typedef mbstate_t state_type; - - - - - - static constexpr void - assign(char_type& __c1, const char_type& __c2) noexcept - { - - - - - - __c1 = __c2; - } - - static constexpr bool - eq(const char_type& __c1, const char_type& __c2) noexcept - { return __c1 == __c2; } - - static constexpr bool - lt(const char_type& __c1, const char_type& __c2) noexcept - { - - return (static_cast(__c1) - < static_cast(__c2)); - } - - static constexpr int - compare(const char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return 0; - - if (std::__is_constant_evaluated()) - { - for (size_t __i = 0; __i < __n; ++__i) - if (lt(__s1[__i], __s2[__i])) - return -1; - else if (lt(__s2[__i], __s1[__i])) - return 1; - return 0; - } - - return __builtin_memcmp(__s1, __s2, __n); - } - - static constexpr size_t - length(const char_type* __s) - { - - if (std::__is_constant_evaluated()) - return __gnu_cxx::char_traits::length(__s); - - return __builtin_strlen(__s); - } - - static constexpr const char_type* - find(const char_type* __s, size_t __n, const char_type& __a) - { - if (__n == 0) - return 0; - - if (std::__is_constant_evaluated()) - return __gnu_cxx::char_traits::find(__s, __n, __a); - - return static_cast(__builtin_memchr(__s, __a, __n)); - } - - static char_type* - move(char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return __s1; - - - - - return static_cast(__builtin_memmove(__s1, __s2, __n)); - } - - static char_type* - copy(char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return __s1; - - - - - return static_cast(__builtin_memcpy(__s1, __s2, __n)); - } - - static char_type* - assign(char_type* __s, size_t __n, char_type __a) - { - if (__n == 0) - return __s; - - - - - return static_cast(__builtin_memset(__s, __a, __n)); - } - - static constexpr char_type - to_char_type(const int_type& __c) noexcept - { return static_cast(__c); } - - - - static constexpr int_type - to_int_type(const char_type& __c) noexcept - { return static_cast(static_cast(__c)); } - - static constexpr bool - eq_int_type(const int_type& __c1, const int_type& __c2) noexcept - { return __c1 == __c2; } - - - static constexpr int_type - eof() noexcept - { return static_cast(-1); } - - static constexpr int_type - not_eof(const int_type& __c) noexcept - { return (__c == eof()) ? 0 : __c; } - - }; - - - - - template<> - struct char_traits - { - typedef wchar_t char_type; - typedef wint_t int_type; - - typedef streamoff off_type; - typedef wstreampos pos_type; - typedef mbstate_t state_type; - - - - - - static constexpr void - assign(char_type& __c1, const char_type& __c2) noexcept - { - - - - - - __c1 = __c2; - } - - static constexpr bool - eq(const char_type& __c1, const char_type& __c2) noexcept - { return __c1 == __c2; } - - static constexpr bool - lt(const char_type& __c1, const char_type& __c2) noexcept - { return __c1 < __c2; } - - static constexpr int - compare(const char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return 0; - - if (std::__is_constant_evaluated()) - return __gnu_cxx::char_traits::compare(__s1, __s2, __n); - - return wmemcmp(__s1, __s2, __n); - } - - static constexpr size_t - length(const char_type* __s) - { - - if (std::__is_constant_evaluated()) - return __gnu_cxx::char_traits::length(__s); - - return wcslen(__s); - } - - static constexpr const char_type* - find(const char_type* __s, size_t __n, const char_type& __a) - { - if (__n == 0) - return 0; - - if (std::__is_constant_evaluated()) - return __gnu_cxx::char_traits::find(__s, __n, __a); - - return wmemchr(__s, __a, __n); - } - - static char_type* - move(char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return __s1; - - - - - return wmemmove(__s1, __s2, __n); - } - - static char_type* - copy(char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return __s1; - - - - - return wmemcpy(__s1, __s2, __n); - } - - static char_type* - assign(char_type* __s, size_t __n, char_type __a) - { - if (__n == 0) - return __s; - - - - - return wmemset(__s, __a, __n); - } - - static constexpr char_type - to_char_type(const int_type& __c) noexcept - { return char_type(__c); } - - static constexpr int_type - to_int_type(const char_type& __c) noexcept - { return int_type(__c); } - - static constexpr bool - eq_int_type(const int_type& __c1, const int_type& __c2) noexcept - { return __c1 == __c2; } - - - static constexpr int_type - eof() noexcept - { return static_cast((0xffffffffu)); } - - static constexpr int_type - not_eof(const int_type& __c) noexcept - { return eq_int_type(__c, eof()) ? 0 : __c; } - - }; -# 751 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 -} - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template<> - struct char_traits - { - typedef char16_t char_type; - - typedef unsigned short int_type; - - - - - - - typedef streamoff off_type; - typedef u16streampos pos_type; - typedef mbstate_t state_type; - - - - - - static constexpr void - assign(char_type& __c1, const char_type& __c2) noexcept - { - - - - - - __c1 = __c2; - } - - static constexpr bool - eq(const char_type& __c1, const char_type& __c2) noexcept - { return __c1 == __c2; } - - static constexpr bool - lt(const char_type& __c1, const char_type& __c2) noexcept - { return __c1 < __c2; } - - static constexpr int - compare(const char_type* __s1, const char_type* __s2, size_t __n) - { - for (size_t __i = 0; __i < __n; ++__i) - if (lt(__s1[__i], __s2[__i])) - return -1; - else if (lt(__s2[__i], __s1[__i])) - return 1; - return 0; - } - - static constexpr size_t - length(const char_type* __s) - { - size_t __i = 0; - while (!eq(__s[__i], char_type())) - ++__i; - return __i; - } - - static constexpr const char_type* - find(const char_type* __s, size_t __n, const char_type& __a) - { - for (size_t __i = 0; __i < __n; ++__i) - if (eq(__s[__i], __a)) - return __s + __i; - return 0; - } - - static char_type* - move(char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return __s1; - - - - - return (static_cast - (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); - } - - static char_type* - copy(char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return __s1; - - - - - return (static_cast - (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); - } - - static char_type* - assign(char_type* __s, size_t __n, char_type __a) - { - for (size_t __i = 0; __i < __n; ++__i) - assign(__s[__i], __a); - return __s; - } - - static constexpr char_type - to_char_type(const int_type& __c) noexcept - { return char_type(__c); } - - static constexpr bool - eq_int_type(const int_type& __c1, const int_type& __c2) noexcept - { return __c1 == __c2; } - - - static constexpr int_type - to_int_type(const char_type& __c) noexcept - { return __c == eof() ? int_type(0xfffd) : int_type(__c); } - - static constexpr int_type - eof() noexcept - { return static_cast(-1); } - - static constexpr int_type - not_eof(const int_type& __c) noexcept - { return eq_int_type(__c, eof()) ? 0 : __c; } - - - - - - }; - - template<> - struct char_traits - { - typedef char32_t char_type; - - typedef unsigned int int_type; - - - - - - - typedef streamoff off_type; - typedef u32streampos pos_type; - typedef mbstate_t state_type; - - - - - - static constexpr void - assign(char_type& __c1, const char_type& __c2) noexcept - { - - - - - - __c1 = __c2; - } - - static constexpr bool - eq(const char_type& __c1, const char_type& __c2) noexcept - { return __c1 == __c2; } - - static constexpr bool - lt(const char_type& __c1, const char_type& __c2) noexcept - { return __c1 < __c2; } - - static constexpr int - compare(const char_type* __s1, const char_type* __s2, size_t __n) - { - for (size_t __i = 0; __i < __n; ++__i) - if (lt(__s1[__i], __s2[__i])) - return -1; - else if (lt(__s2[__i], __s1[__i])) - return 1; - return 0; - } - - static constexpr size_t - length(const char_type* __s) - { - size_t __i = 0; - while (!eq(__s[__i], char_type())) - ++__i; - return __i; - } - - static constexpr const char_type* - find(const char_type* __s, size_t __n, const char_type& __a) - { - for (size_t __i = 0; __i < __n; ++__i) - if (eq(__s[__i], __a)) - return __s + __i; - return 0; - } - - static char_type* - move(char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return __s1; - - - - - return (static_cast - (__builtin_memmove(__s1, __s2, __n * sizeof(char_type)))); - } - - static char_type* - copy(char_type* __s1, const char_type* __s2, size_t __n) - { - if (__n == 0) - return __s1; - - - - - return (static_cast - (__builtin_memcpy(__s1, __s2, __n * sizeof(char_type)))); - } - - static char_type* - assign(char_type* __s, size_t __n, char_type __a) - { - for (size_t __i = 0; __i < __n; ++__i) - assign(__s[__i], __a); - return __s; - } - - static constexpr char_type - to_char_type(const int_type& __c) noexcept - { return char_type(__c); } - - static constexpr int_type - to_int_type(const char_type& __c) noexcept - { return int_type(__c); } - - static constexpr bool - eq_int_type(const int_type& __c1, const int_type& __c2) noexcept - { return __c1 == __c2; } - - - static constexpr int_type - eof() noexcept - { return static_cast(-1); } - - static constexpr int_type - not_eof(const int_type& __c) noexcept - { return eq_int_type(__c, eof()) ? 0 : __c; } - - }; -# 1032 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/char_traits.h" 3 -#pragma GCC diagnostic pop - - -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/clocale" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/clocale" 3 - - -# 1 "/usr/include/locale.h" 1 3 4 -# 28 "/usr/include/locale.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 29 "/usr/include/locale.h" 2 3 4 -# 1 "/usr/include/bits/locale.h" 1 3 4 -# 30 "/usr/include/locale.h" 2 3 4 - -extern "C" { -# 51 "/usr/include/locale.h" 3 4 -struct lconv -{ - - - char *decimal_point; - char *thousands_sep; - - - - - - char *grouping; - - - - - - char *int_curr_symbol; - char *currency_symbol; - char *mon_decimal_point; - char *mon_thousands_sep; - char *mon_grouping; - char *positive_sign; - char *negative_sign; - char int_frac_digits; - char frac_digits; - - char p_cs_precedes; - - char p_sep_by_space; - - char n_cs_precedes; - - char n_sep_by_space; - - - - - - - char p_sign_posn; - char n_sign_posn; - - - char int_p_cs_precedes; - - char int_p_sep_by_space; - - char int_n_cs_precedes; - - char int_n_sep_by_space; - - - - - - - char int_p_sign_posn; - char int_n_sign_posn; -# 118 "/usr/include/locale.h" 3 4 -}; - - - -extern char *setlocale (int __category, const char *__locale) noexcept (true); - - -extern struct lconv *localeconv (void) noexcept (true); -# 141 "/usr/include/locale.h" 3 4 -extern locale_t newlocale (int __category_mask, const char *__locale, - locale_t __base) noexcept (true); -# 176 "/usr/include/locale.h" 3 4 -extern locale_t duplocale (locale_t __dataset) noexcept (true); - - - -extern void freelocale (locale_t __dataset) noexcept (true); - - - - - - -extern locale_t uselocale (locale_t __dataset) noexcept (true); - - - - - - - -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/clocale" 2 3 - - - - - - - - -namespace std -{ - using ::lconv; - using ::setlocale; - using ::localeconv; -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 2 3 - - - - - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - extern "C" __typeof(uselocale) __uselocale; - - -} - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - typedef __locale_t __c_locale; -# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 3 - inline int - __convert_from_v(const __c_locale& __cloc __attribute__ ((__unused__)), - char* __out, - const int __size __attribute__ ((__unused__)), - const char* __fmt, ...) - { - - __c_locale __old = __gnu_cxx::__uselocale(__cloc); -# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++locale.h" 3 - __builtin_va_list __args; - __builtin_va_start(__args, __fmt); - - - const int __ret = __builtin_vsnprintf(__out, __size, __fmt, __args); - - - - - __builtin_va_end(__args); - - - __gnu_cxx::__uselocale(__old); - - - - - - - - return __ret; - } - - - - - - - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 3 - - -# 1 "/usr/include/ctype.h" 1 3 4 -# 26 "/usr/include/ctype.h" 3 4 -# 1 "/usr/include/bits/types.h" 1 3 4 -# 27 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 28 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 29 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned char __u_char; -typedef unsigned short int __u_short; -typedef unsigned int __u_int; -typedef unsigned long int __u_long; - - -typedef signed char __int8_t; -typedef unsigned char __uint8_t; -typedef signed short int __int16_t; -typedef unsigned short int __uint16_t; -typedef signed int __int32_t; -typedef unsigned int __uint32_t; - -typedef signed long int __int64_t; -typedef unsigned long int __uint64_t; - - - - - - -typedef __int8_t __int_least8_t; -typedef __uint8_t __uint_least8_t; -typedef __int16_t __int_least16_t; -typedef __uint16_t __uint_least16_t; -typedef __int32_t __int_least32_t; -typedef __uint32_t __uint_least32_t; -typedef __int64_t __int_least64_t; -typedef __uint64_t __uint_least64_t; - - - -typedef long int __quad_t; -typedef unsigned long int __u_quad_t; - - - - - - - -typedef long int __intmax_t; -typedef unsigned long int __uintmax_t; -# 141 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/typesizes.h" 1 3 4 -# 142 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/time64.h" 1 3 4 -# 143 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned long int __dev_t; -typedef unsigned int __uid_t; -typedef unsigned int __gid_t; -typedef unsigned long int __ino_t; -typedef unsigned long int __ino64_t; -typedef unsigned int __mode_t; -typedef unsigned long int __nlink_t; -typedef long int __off_t; -typedef long int __off64_t; -typedef int __pid_t; -typedef struct { int __val[2]; } __fsid_t; -typedef long int __clock_t; -typedef unsigned long int __rlim_t; -typedef unsigned long int __rlim64_t; -typedef unsigned int __id_t; -typedef long int __time_t; -typedef unsigned int __useconds_t; -typedef long int __suseconds_t; -typedef long int __suseconds64_t; - -typedef int __daddr_t; -typedef int __key_t; - - -typedef int __clockid_t; - - -typedef void * __timer_t; - - -typedef long int __blksize_t; - - - - -typedef long int __blkcnt_t; -typedef long int __blkcnt64_t; - - -typedef unsigned long int __fsblkcnt_t; -typedef unsigned long int __fsblkcnt64_t; - - -typedef unsigned long int __fsfilcnt_t; -typedef unsigned long int __fsfilcnt64_t; - - -typedef long int __fsword_t; - -typedef long int __ssize_t; - - -typedef long int __syscall_slong_t; - -typedef unsigned long int __syscall_ulong_t; - - - -typedef __off64_t __loff_t; -typedef char *__caddr_t; - - -typedef long int __intptr_t; - - -typedef unsigned int __socklen_t; - - - - -typedef int __sig_atomic_t; -# 27 "/usr/include/ctype.h" 2 3 4 - -extern "C" { -# 39 "/usr/include/ctype.h" 3 4 -# 1 "/usr/include/bits/endian.h" 1 3 4 -# 35 "/usr/include/bits/endian.h" 3 4 -# 1 "/usr/include/bits/endianness.h" 1 3 4 -# 36 "/usr/include/bits/endian.h" 2 3 4 -# 40 "/usr/include/ctype.h" 2 3 4 - - - - - - -enum -{ - _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), - _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), - _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), - _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), - _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), - _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), - _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), - _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), - _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), - _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), - _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), - _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) -}; -# 79 "/usr/include/ctype.h" 3 4 -extern const unsigned short int **__ctype_b_loc (void) - noexcept (true) __attribute__ ((__const__)); -extern const __int32_t **__ctype_tolower_loc (void) - noexcept (true) __attribute__ ((__const__)); -extern const __int32_t **__ctype_toupper_loc (void) - noexcept (true) __attribute__ ((__const__)); -# 108 "/usr/include/ctype.h" 3 4 -extern int isalnum (int) noexcept (true); -extern int isalpha (int) noexcept (true); -extern int iscntrl (int) noexcept (true); -extern int isdigit (int) noexcept (true); -extern int islower (int) noexcept (true); -extern int isgraph (int) noexcept (true); -extern int isprint (int) noexcept (true); -extern int ispunct (int) noexcept (true); -extern int isspace (int) noexcept (true); -extern int isupper (int) noexcept (true); -extern int isxdigit (int) noexcept (true); - - - -extern int tolower (int __c) noexcept (true); - - -extern int toupper (int __c) noexcept (true); - - - - -extern int isblank (int) noexcept (true); - - - - -extern int isctype (int __c, int __mask) noexcept (true); - - - - - - -extern int isascii (int __c) noexcept (true); - - - -extern int toascii (int __c) noexcept (true); - - - -extern int _toupper (int) noexcept (true); -extern int _tolower (int) noexcept (true); -# 251 "/usr/include/ctype.h" 3 4 -extern int isalnum_l (int, locale_t) noexcept (true); -extern int isalpha_l (int, locale_t) noexcept (true); -extern int iscntrl_l (int, locale_t) noexcept (true); -extern int isdigit_l (int, locale_t) noexcept (true); -extern int islower_l (int, locale_t) noexcept (true); -extern int isgraph_l (int, locale_t) noexcept (true); -extern int isprint_l (int, locale_t) noexcept (true); -extern int ispunct_l (int, locale_t) noexcept (true); -extern int isspace_l (int, locale_t) noexcept (true); -extern int isupper_l (int, locale_t) noexcept (true); -extern int isxdigit_l (int, locale_t) noexcept (true); - -extern int isblank_l (int, locale_t) noexcept (true); - - - -extern int __tolower_l (int __c, locale_t __l) noexcept (true); -extern int tolower_l (int __c, locale_t __l) noexcept (true); - - -extern int __toupper_l (int __c, locale_t __l) noexcept (true); -extern int toupper_l (int __c, locale_t __l) noexcept (true); -# 327 "/usr/include/ctype.h" 3 4 -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 2 3 -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 3 -namespace std -{ - using ::isalnum; - using ::isalpha; - using ::iscntrl; - using ::isdigit; - using ::isgraph; - using ::islower; - using ::isprint; - using ::ispunct; - using ::isspace; - using ::isupper; - using ::isxdigit; - using ::tolower; - using ::toupper; -} - - - - - - - -namespace std -{ - using ::isblank; -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/localefwd.h" 3 - class locale; - - template - bool - has_facet(const locale&) throw(); - - template - const _Facet& - use_facet(const locale&); - - - template - bool - isspace(_CharT, const locale&); - - template - bool - isprint(_CharT, const locale&); - - template - bool - iscntrl(_CharT, const locale&); - - template - bool - isupper(_CharT, const locale&); - - template - bool - islower(_CharT, const locale&); - - template - bool - isalpha(_CharT, const locale&); - - template - bool - isdigit(_CharT, const locale&); - - template - bool - ispunct(_CharT, const locale&); - - template - bool - isxdigit(_CharT, const locale&); - - template - bool - isalnum(_CharT, const locale&); - - template - bool - isgraph(_CharT, const locale&); - - - template - bool - isblank(_CharT, const locale&); - - - template - _CharT - toupper(_CharT, const locale&); - - template - _CharT - tolower(_CharT, const locale&); - - - struct ctype_base; - template - class ctype; - template<> class ctype; - - template<> class ctype; - - template - class ctype_byname; - - - class codecvt_base; - template - class codecvt; - template<> class codecvt; - - template<> class codecvt; - - - template<> class codecvt; - template<> class codecvt; - - - - - - template - class codecvt_byname; - - - - template > - class num_get; - template > - class num_put; - -namespace __cxx11 { - template class numpunct; - template class numpunct_byname; -} - -namespace __cxx11 { - - template - class collate; - template - class collate_byname; -} - - - class time_base; -namespace __cxx11 { - template > - class time_get; - template > - class time_get_byname; -} - template > - class time_put; - template > - class time_put_byname; - - - class money_base; -namespace __cxx11 { - template > - class money_get; - template > - class money_put; -} -namespace __cxx11 { - template - class moneypunct; - template - class moneypunct_byname; -} - - - struct messages_base; -namespace __cxx11 { - template - class messages; - template - class messages_byname; -} - - -} -# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 1 3 -# 30 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 -#pragma GCC visibility push(default) -# 148 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -# 1 "/usr/include/pthread.h" 1 3 4 -# 22 "/usr/include/pthread.h" 3 4 -# 1 "/usr/include/sched.h" 1 3 4 -# 29 "/usr/include/sched.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 30 "/usr/include/sched.h" 2 3 4 - -# 1 "/usr/include/bits/types/time_t.h" 1 3 4 -# 10 "/usr/include/bits/types/time_t.h" 3 4 -typedef __time_t time_t; -# 32 "/usr/include/sched.h" 2 3 4 -# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 -# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 -struct timespec -{ - - - - __time_t tv_sec; - - - - - __syscall_slong_t tv_nsec; -# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 -}; -# 33 "/usr/include/sched.h" 2 3 4 - - - - - -typedef __pid_t pid_t; - - - - -# 1 "/usr/include/bits/sched.h" 1 3 4 -# 80 "/usr/include/bits/sched.h" 3 4 -# 1 "/usr/include/bits/types/struct_sched_param.h" 1 3 4 -# 23 "/usr/include/bits/types/struct_sched_param.h" 3 4 -struct sched_param -{ - int sched_priority; -}; -# 81 "/usr/include/bits/sched.h" 2 3 4 - -extern "C" { - - - -extern int clone (int (*__fn) (void *__arg), void *__child_stack, - int __flags, void *__arg, ...) noexcept (true); - - -extern int unshare (int __flags) noexcept (true); - - -extern int sched_getcpu (void) noexcept (true); - - -extern int getcpu (unsigned int *, unsigned int *) noexcept (true); - - -extern int setns (int __fd, int __nstype) noexcept (true); - - -} -# 44 "/usr/include/sched.h" 2 3 4 -# 1 "/usr/include/bits/cpu-set.h" 1 3 4 -# 32 "/usr/include/bits/cpu-set.h" 3 4 -typedef unsigned long int __cpu_mask; - - - - - - -typedef struct -{ - __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; -} cpu_set_t; -# 115 "/usr/include/bits/cpu-set.h" 3 4 -extern "C" { - -extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp) - noexcept (true); -extern cpu_set_t *__sched_cpualloc (size_t __count) noexcept (true) ; -extern void __sched_cpufree (cpu_set_t *__set) noexcept (true); - -} -# 45 "/usr/include/sched.h" 2 3 4 - - - - - - -extern "C" { - - -extern int sched_setparam (__pid_t __pid, const struct sched_param *__param) - noexcept (true); - - -extern int sched_getparam (__pid_t __pid, struct sched_param *__param) noexcept (true); - - -extern int sched_setscheduler (__pid_t __pid, int __policy, - const struct sched_param *__param) noexcept (true); - - -extern int sched_getscheduler (__pid_t __pid) noexcept (true); - - -extern int sched_yield (void) noexcept (true); - - -extern int sched_get_priority_max (int __algorithm) noexcept (true); - - -extern int sched_get_priority_min (int __algorithm) noexcept (true); - - - -extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) noexcept (true); -# 130 "/usr/include/sched.h" 3 4 -extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, - const cpu_set_t *__cpuset) noexcept (true); - - -extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, - cpu_set_t *__cpuset) noexcept (true); - - -} -# 23 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/time.h" 1 3 4 -# 29 "/usr/include/time.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 30 "/usr/include/time.h" 2 3 4 - - - -# 1 "/usr/include/bits/time.h" 1 3 4 -# 73 "/usr/include/bits/time.h" 3 4 -# 1 "/usr/include/bits/timex.h" 1 3 4 -# 22 "/usr/include/bits/timex.h" 3 4 -# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 - - - - - - - -struct timeval -{ - - - - - __time_t tv_sec; - __suseconds_t tv_usec; - -}; -# 23 "/usr/include/bits/timex.h" 2 3 4 - - - -struct timex -{ -# 58 "/usr/include/bits/timex.h" 3 4 - unsigned int modes; - __syscall_slong_t offset; - __syscall_slong_t freq; - __syscall_slong_t maxerror; - __syscall_slong_t esterror; - int status; - __syscall_slong_t constant; - __syscall_slong_t precision; - __syscall_slong_t tolerance; - struct timeval time; - __syscall_slong_t tick; - __syscall_slong_t ppsfreq; - __syscall_slong_t jitter; - int shift; - __syscall_slong_t stabil; - __syscall_slong_t jitcnt; - __syscall_slong_t calcnt; - __syscall_slong_t errcnt; - __syscall_slong_t stbcnt; - - int tai; - - - int :32; int :32; int :32; int :32; - int :32; int :32; int :32; int :32; - int :32; int :32; int :32; - -}; -# 74 "/usr/include/bits/time.h" 2 3 4 - -extern "C" { - - -extern int clock_adjtime (__clockid_t __clock_id, struct timex *__utx) noexcept (true) __attribute__ ((__nonnull__ (2))); -# 90 "/usr/include/bits/time.h" 3 4 -} -# 34 "/usr/include/time.h" 2 3 4 - - - -# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 - - - - - - -typedef __clock_t clock_t; -# 38 "/usr/include/time.h" 2 3 4 - -# 1 "/usr/include/bits/types/struct_tm.h" 1 3 4 - - - - - - -struct tm -{ - int tm_sec; - int tm_min; - int tm_hour; - int tm_mday; - int tm_mon; - int tm_year; - int tm_wday; - int tm_yday; - int tm_isdst; - - - long int tm_gmtoff; - const char *tm_zone; - - - - -}; -# 40 "/usr/include/time.h" 2 3 4 - - - - - - -# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 - - - - - - -typedef __clockid_t clockid_t; -# 47 "/usr/include/time.h" 2 3 4 -# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 - - - - - - -typedef __timer_t timer_t; -# 48 "/usr/include/time.h" 2 3 4 -# 1 "/usr/include/bits/types/struct_itimerspec.h" 1 3 4 - - - - - - - -struct itimerspec - { - struct timespec it_interval; - struct timespec it_value; - }; -# 49 "/usr/include/time.h" 2 3 4 -struct sigevent; -# 68 "/usr/include/time.h" 3 4 -extern "C" { - - - -extern clock_t clock (void) noexcept (true); - - - -extern time_t time (time_t *__timer) noexcept (true); - - -extern double difftime (time_t __time1, time_t __time0) - noexcept (true) __attribute__ ((__const__)); - - -extern time_t mktime (struct tm *__tp) noexcept (true); -# 100 "/usr/include/time.h" 3 4 -extern size_t strftime (char *__restrict __s, size_t __maxsize, - const char *__restrict __format, - const struct tm *__restrict __tp) - noexcept (true) __attribute__ ((__nonnull__ (1, 3, 4))); - - - - -extern char *strptime (const char *__restrict __s, - const char *__restrict __fmt, struct tm *__tp) - noexcept (true); - - - - - - -extern size_t strftime_l (char *__restrict __s, size_t __maxsize, - const char *__restrict __format, - const struct tm *__restrict __tp, - locale_t __loc) noexcept (true); - - - -extern char *strptime_l (const char *__restrict __s, - const char *__restrict __fmt, struct tm *__tp, - locale_t __loc) noexcept (true); - - - - - - -extern struct tm *gmtime (const time_t *__timer) noexcept (true); - - - -extern struct tm *localtime (const time_t *__timer) noexcept (true); -# 155 "/usr/include/time.h" 3 4 -extern struct tm *gmtime_r (const time_t *__restrict __timer, - struct tm *__restrict __tp) noexcept (true); - - - -extern struct tm *localtime_r (const time_t *__restrict __timer, - struct tm *__restrict __tp) noexcept (true); -# 180 "/usr/include/time.h" 3 4 -extern char *asctime (const struct tm *__tp) noexcept (true); - - - -extern char *ctime (const time_t *__timer) noexcept (true); -# 198 "/usr/include/time.h" 3 4 -extern char *asctime_r (const struct tm *__restrict __tp, - char *__restrict __buf) noexcept (true); - - - -extern char *ctime_r (const time_t *__restrict __timer, - char *__restrict __buf) noexcept (true); -# 218 "/usr/include/time.h" 3 4 -extern char *__tzname[2]; -extern int __daylight; -extern long int __timezone; - - - - -extern char *tzname[2]; - - - -extern void tzset (void) noexcept (true); - - - -extern int daylight; -extern long int timezone; -# 247 "/usr/include/time.h" 3 4 -extern time_t timegm (struct tm *__tp) noexcept (true); -# 264 "/usr/include/time.h" 3 4 -extern time_t timelocal (struct tm *__tp) noexcept (true); - - - - - - - -extern int dysize (int __year) noexcept (true) __attribute__ ((__const__)); -# 282 "/usr/include/time.h" 3 4 -extern int nanosleep (const struct timespec *__requested_time, - struct timespec *__remaining); - - -extern int clock_getres (clockid_t __clock_id, struct timespec *__res) noexcept (true); - - -extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - -extern int clock_settime (clockid_t __clock_id, const struct timespec *__tp) - noexcept (true) __attribute__ ((__nonnull__ (2))); -# 324 "/usr/include/time.h" 3 4 -extern int clock_nanosleep (clockid_t __clock_id, int __flags, - const struct timespec *__req, - struct timespec *__rem); -# 339 "/usr/include/time.h" 3 4 -extern int clock_getcpuclockid (pid_t __pid, clockid_t *__clock_id) noexcept (true); - - - - -extern int timer_create (clockid_t __clock_id, - struct sigevent *__restrict __evp, - timer_t *__restrict __timerid) noexcept (true); - - -extern int timer_delete (timer_t __timerid) noexcept (true); - - - -extern int timer_settime (timer_t __timerid, int __flags, - const struct itimerspec *__restrict __value, - struct itimerspec *__restrict __ovalue) noexcept (true); - - -extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) - noexcept (true); -# 377 "/usr/include/time.h" 3 4 -extern int timer_getoverrun (timer_t __timerid) noexcept (true); - - - - - - -extern int timespec_get (struct timespec *__ts, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 400 "/usr/include/time.h" 3 4 -extern int timespec_getres (struct timespec *__ts, int __base) - noexcept (true); -# 426 "/usr/include/time.h" 3 4 -extern int getdate_err; -# 435 "/usr/include/time.h" 3 4 -extern struct tm *getdate (const char *__string); -# 449 "/usr/include/time.h" 3 4 -extern int getdate_r (const char *__restrict __string, - struct tm *__restrict __resbufp); - - -} -# 24 "/usr/include/pthread.h" 2 3 4 - - -# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 -# 23 "/usr/include/bits/pthreadtypes.h" 3 4 -# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 -# 44 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 -# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 -# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 - -# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 -# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 -typedef union -{ - __extension__ unsigned long long int __value64; - struct - { - unsigned int __low; - unsigned int __high; - } __value32; -} __atomic_wide_counter; -# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -typedef struct __pthread_internal_list -{ - struct __pthread_internal_list *__prev; - struct __pthread_internal_list *__next; -} __pthread_list_t; - -typedef struct __pthread_internal_slist -{ - struct __pthread_internal_slist *__next; -} __pthread_slist_t; -# 76 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 -# 22 "/usr/include/bits/struct_mutex.h" 3 4 -struct __pthread_mutex_s -{ - int __lock; - unsigned int __count; - int __owner; - - unsigned int __nusers; - - - - int __kind; - - short __spins; - short __elision; - __pthread_list_t __list; -# 53 "/usr/include/bits/struct_mutex.h" 3 4 -}; -# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 -# 89 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 -# 23 "/usr/include/bits/struct_rwlock.h" 3 4 -struct __pthread_rwlock_arch_t -{ - unsigned int __readers; - unsigned int __writers; - unsigned int __wrphase_futex; - unsigned int __writers_futex; - unsigned int __pad3; - unsigned int __pad4; - - int __cur_writer; - int __shared; - signed char __rwelision; - - - - - unsigned char __pad1[7]; - - - unsigned long int __pad2; - - - unsigned int __flags; -# 55 "/usr/include/bits/struct_rwlock.h" 3 4 -}; -# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -struct __pthread_cond_s -{ - __atomic_wide_counter __wseq; - __atomic_wide_counter __g1_start; - unsigned int __g_refs[2] ; - unsigned int __g_size[2]; - unsigned int __g1_orig_size; - unsigned int __wrefs; - unsigned int __g_signals[2]; -}; - -typedef unsigned int __tss_t; -typedef unsigned long int __thrd_t; - -typedef struct -{ - int __data ; -} __once_flag; -# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 - - - -typedef unsigned long int pthread_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_mutexattr_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_condattr_t; - - - -typedef unsigned int pthread_key_t; - - - -typedef int pthread_once_t; - - -union pthread_attr_t -{ - char __size[56]; - long int __align; -}; - -typedef union pthread_attr_t pthread_attr_t; - - - - -typedef union -{ - struct __pthread_mutex_s __data; - char __size[40]; - long int __align; -} pthread_mutex_t; - - -typedef union -{ - struct __pthread_cond_s __data; - char __size[48]; - __extension__ long long int __align; -} pthread_cond_t; - - - - - -typedef union -{ - struct __pthread_rwlock_arch_t __data; - char __size[56]; - long int __align; -} pthread_rwlock_t; - -typedef union -{ - char __size[8]; - long int __align; -} pthread_rwlockattr_t; - - - - - -typedef volatile int pthread_spinlock_t; - - - - -typedef union -{ - char __size[32]; - long int __align; -} pthread_barrier_t; - -typedef union -{ - char __size[4]; - int __align; -} pthread_barrierattr_t; -# 27 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/bits/setjmp.h" 1 3 4 -# 26 "/usr/include/bits/setjmp.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 27 "/usr/include/bits/setjmp.h" 2 3 4 - - - - -typedef long int __jmp_buf[8]; -# 28 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 29 "/usr/include/pthread.h" 2 3 4 - -# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 - - - - -typedef struct -{ - unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; -} __sigset_t; -# 31 "/usr/include/pthread.h" 2 3 4 -# 1 "/usr/include/bits/types/struct___jmp_buf_tag.h" 1 3 4 -# 26 "/usr/include/bits/types/struct___jmp_buf_tag.h" 3 4 -struct __jmp_buf_tag - { - - - - - __jmp_buf __jmpbuf; - int __mask_was_saved; - __sigset_t __saved_mask; - }; -# 32 "/usr/include/pthread.h" 2 3 4 - -# 1 "/usr/include/bits/pthread_stack_min-dynamic.h" 1 3 4 -# 23 "/usr/include/bits/pthread_stack_min-dynamic.h" 3 4 -extern "C" { -extern long int __sysconf (int __name) noexcept (true); -} -# 34 "/usr/include/pthread.h" 2 3 4 - - - -enum -{ - PTHREAD_CREATE_JOINABLE, - - PTHREAD_CREATE_DETACHED - -}; - - - -enum -{ - PTHREAD_MUTEX_TIMED_NP, - PTHREAD_MUTEX_RECURSIVE_NP, - PTHREAD_MUTEX_ERRORCHECK_NP, - PTHREAD_MUTEX_ADAPTIVE_NP - - , - PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP, - PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, - PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, - PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL - - - - , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_TIMED_NP - -}; - - - - -enum -{ - PTHREAD_MUTEX_STALLED, - PTHREAD_MUTEX_STALLED_NP = PTHREAD_MUTEX_STALLED, - PTHREAD_MUTEX_ROBUST, - PTHREAD_MUTEX_ROBUST_NP = PTHREAD_MUTEX_ROBUST -}; - - - - - -enum -{ - PTHREAD_PRIO_NONE, - PTHREAD_PRIO_INHERIT, - PTHREAD_PRIO_PROTECT -}; -# 104 "/usr/include/pthread.h" 3 4 -enum -{ - PTHREAD_RWLOCK_PREFER_READER_NP, - PTHREAD_RWLOCK_PREFER_WRITER_NP, - PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, - PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_READER_NP -}; -# 124 "/usr/include/pthread.h" 3 4 -enum -{ - PTHREAD_INHERIT_SCHED, - - PTHREAD_EXPLICIT_SCHED - -}; - - - -enum -{ - PTHREAD_SCOPE_SYSTEM, - - PTHREAD_SCOPE_PROCESS - -}; - - - -enum -{ - PTHREAD_PROCESS_PRIVATE, - - PTHREAD_PROCESS_SHARED - -}; -# 159 "/usr/include/pthread.h" 3 4 -struct _pthread_cleanup_buffer -{ - void (*__routine) (void *); - void *__arg; - int __canceltype; - struct _pthread_cleanup_buffer *__prev; -}; - - -enum -{ - PTHREAD_CANCEL_ENABLE, - - PTHREAD_CANCEL_DISABLE - -}; -enum -{ - PTHREAD_CANCEL_DEFERRED, - - PTHREAD_CANCEL_ASYNCHRONOUS - -}; -# 197 "/usr/include/pthread.h" 3 4 -extern "C" { - - - - -extern int pthread_create (pthread_t *__restrict __newthread, - const pthread_attr_t *__restrict __attr, - void *(*__start_routine) (void *), - void *__restrict __arg) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - - - -extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); - - - - - - - -extern int pthread_join (pthread_t __th, void **__thread_return); - - - - -extern int pthread_tryjoin_np (pthread_t __th, void **__thread_return) noexcept (true); -# 233 "/usr/include/pthread.h" 3 4 -extern int pthread_timedjoin_np (pthread_t __th, void **__thread_return, - const struct timespec *__abstime); -# 243 "/usr/include/pthread.h" 3 4 -extern int pthread_clockjoin_np (pthread_t __th, void **__thread_return, - clockid_t __clockid, - const struct timespec *__abstime); -# 269 "/usr/include/pthread.h" 3 4 -extern int pthread_detach (pthread_t __th) noexcept (true); - - - -extern pthread_t pthread_self (void) noexcept (true) __attribute__ ((__const__)); - - -extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) - noexcept (true) __attribute__ ((__const__)); - - - - - - - -extern int pthread_attr_init (pthread_attr_t *__attr) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_destroy (pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_getdetachstate (const pthread_attr_t *__attr, - int *__detachstate) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, - int __detachstate) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getguardsize (const pthread_attr_t *__attr, - size_t *__guardsize) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setguardsize (pthread_attr_t *__attr, - size_t __guardsize) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getschedparam (const pthread_attr_t *__restrict __attr, - struct sched_param *__restrict __param) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, - const struct sched_param *__restrict - __param) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_getschedpolicy (const pthread_attr_t *__restrict - __attr, int *__restrict __policy) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_getinheritsched (const pthread_attr_t *__restrict - __attr, int *__restrict __inherit) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, - int __inherit) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getscope (const pthread_attr_t *__restrict __attr, - int *__restrict __scope) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_getstackaddr (const pthread_attr_t *__restrict - __attr, void **__restrict __stackaddr) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) __attribute__ ((__deprecated__)); - - - - - -extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, - void *__stackaddr) - noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__deprecated__)); - - -extern int pthread_attr_getstacksize (const pthread_attr_t *__restrict - __attr, size_t *__restrict __stacksize) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern int pthread_attr_setstacksize (pthread_attr_t *__attr, - size_t __stacksize) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_attr_getstack (const pthread_attr_t *__restrict __attr, - void **__restrict __stackaddr, - size_t *__restrict __stacksize) - noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))); - - - - -extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, - size_t __stacksize) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern int pthread_attr_setaffinity_np (pthread_attr_t *__attr, - size_t __cpusetsize, - const cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern int pthread_attr_getaffinity_np (const pthread_attr_t *__attr, - size_t __cpusetsize, - cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - -extern int pthread_getattr_default_np (pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_attr_setsigmask_np (pthread_attr_t *__attr, - const __sigset_t *sigmask); - - - - -extern int pthread_attr_getsigmask_np (const pthread_attr_t *__attr, - __sigset_t *sigmask); - - - - - - - -extern int pthread_setattr_default_np (const pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_getattr_np (pthread_t __th, pthread_attr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - - - - -extern int pthread_setschedparam (pthread_t __target_thread, int __policy, - const struct sched_param *__param) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - -extern int pthread_getschedparam (pthread_t __target_thread, - int *__restrict __policy, - struct sched_param *__restrict __param) - noexcept (true) __attribute__ ((__nonnull__ (2, 3))); - - -extern int pthread_setschedprio (pthread_t __target_thread, int __prio) - noexcept (true); - - - - -extern int pthread_getname_np (pthread_t __target_thread, char *__buf, - size_t __buflen) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - -extern int pthread_setname_np (pthread_t __target_thread, const char *__name) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - - -extern int pthread_getconcurrency (void) noexcept (true); - - -extern int pthread_setconcurrency (int __level) noexcept (true); - - - -extern int pthread_yield (void) noexcept (true); - -extern int pthread_yield (void) noexcept (true) __asm__ ("" "sched_yield") - __attribute__ ((__deprecated__ ("pthread_yield is deprecated, use sched_yield instead"))); -# 489 "/usr/include/pthread.h" 3 4 -extern int pthread_setaffinity_np (pthread_t __th, size_t __cpusetsize, - const cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - -extern int pthread_getaffinity_np (pthread_t __th, size_t __cpusetsize, - cpu_set_t *__cpuset) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 509 "/usr/include/pthread.h" 3 4 -extern int pthread_once (pthread_once_t *__once_control, - void (*__init_routine) (void)) __attribute__ ((__nonnull__ (1, 2))); -# 521 "/usr/include/pthread.h" 3 4 -extern int pthread_setcancelstate (int __state, int *__oldstate); - - - -extern int pthread_setcanceltype (int __type, int *__oldtype); - - -extern int pthread_cancel (pthread_t __th); - - - - -extern void pthread_testcancel (void); - - - - -struct __cancel_jmp_buf_tag -{ - __jmp_buf __cancel_jmp_buf; - int __mask_was_saved; -}; - -typedef struct -{ - struct __cancel_jmp_buf_tag __cancel_jmp_buf[1]; - void *__pad[4]; -} __pthread_unwind_buf_t __attribute__ ((__aligned__)); -# 557 "/usr/include/pthread.h" 3 4 -struct __pthread_cleanup_frame -{ - void (*__cancel_routine) (void *); - void *__cancel_arg; - int __do_it; - int __cancel_type; -}; - - - - -class __pthread_cleanup_class -{ - void (*__cancel_routine) (void *); - void *__cancel_arg; - int __do_it; - int __cancel_type; - - public: - __pthread_cleanup_class (void (*__fct) (void *), void *__arg) - : __cancel_routine (__fct), __cancel_arg (__arg), __do_it (1) { } - ~__pthread_cleanup_class () { if (__do_it) __cancel_routine (__cancel_arg); } - void __setdoit (int __newval) { __do_it = __newval; } - void __defer () { pthread_setcanceltype (PTHREAD_CANCEL_DEFERRED, - &__cancel_type); } - void __restore () const { pthread_setcanceltype (__cancel_type, 0); } -}; -# 773 "/usr/include/pthread.h" 3 4 -extern int __sigsetjmp (struct __jmp_buf_tag __env[1], - int __savemask) noexcept (true); - - - - - - -extern int pthread_mutex_init (pthread_mutex_t *__mutex, - const pthread_mutexattr_t *__mutexattr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_lock (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -# 817 "/usr/include/pthread.h" 3 4 -extern int pthread_mutex_clocklock (pthread_mutex_t *__restrict __mutex, - clockid_t __clockid, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 835 "/usr/include/pthread.h" 3 4 -extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutex_getprioceiling (const pthread_mutex_t * - __restrict __mutex, - int *__restrict __prioceiling) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int pthread_mutex_setprioceiling (pthread_mutex_t *__restrict __mutex, - int __prioceiling, - int *__restrict __old_ceiling) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - - -extern int pthread_mutex_consistent (pthread_mutex_t *__mutex) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutex_consistent_np (pthread_mutex_t *) noexcept (true) __asm__ ("" "pthread_mutex_consistent") __attribute__ ((__nonnull__ (1))) - - __attribute__ ((__deprecated__ ("pthread_mutex_consistent_np is deprecated, use pthread_mutex_consistent"))); -# 874 "/usr/include/pthread.h" 3 4 -extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_getpshared (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, - int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutexattr_gettype (const pthread_mutexattr_t *__restrict - __attr, int *__restrict __kind) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutexattr_getprotocol (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __protocol) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int pthread_mutexattr_setprotocol (pthread_mutexattr_t *__attr, - int __protocol) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_getprioceiling (const pthread_mutexattr_t * - __restrict __attr, - int *__restrict __prioceiling) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_mutexattr_setprioceiling (pthread_mutexattr_t *__attr, - int __prioceiling) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_mutexattr_getrobust (const pthread_mutexattr_t *__attr, - int *__robustness) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_mutexattr_getrobust_np (pthread_mutexattr_t *, int *) noexcept (true) __asm__ ("" "pthread_mutexattr_getrobust") __attribute__ ((__nonnull__ (1))) - - - __attribute__ ((__deprecated__ ("pthread_mutexattr_getrobust_np is deprecated, use pthread_mutexattr_getrobust"))); - - - - - - - -extern int pthread_mutexattr_setrobust (pthread_mutexattr_t *__attr, - int __robustness) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_mutexattr_setrobust_np (pthread_mutexattr_t *, int) noexcept (true) __asm__ ("" "pthread_mutexattr_setrobust") __attribute__ ((__nonnull__ (1))) - - - __attribute__ ((__deprecated__ ("pthread_mutexattr_setrobust_np is deprecated, use pthread_mutexattr_setrobust"))); -# 967 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, - const pthread_rwlockattr_t *__restrict - __attr) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -# 1004 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_clockrdlock (pthread_rwlock_t *__restrict __rwlock, - clockid_t __clockid, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 1023 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -# 1051 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_clockwrlock (pthread_rwlock_t *__restrict __rwlock, - clockid_t __clockid, - const struct timespec *__restrict - __abstime) noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 1071 "/usr/include/pthread.h" 3 4 -extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, - int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t * - __restrict __attr, - int *__restrict __pref) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, - int __pref) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - - -extern int pthread_cond_init (pthread_cond_t *__restrict __cond, - const pthread_condattr_t *__restrict __cond_attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_cond_destroy (pthread_cond_t *__cond) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_cond_signal (pthread_cond_t *__cond) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_cond_broadcast (pthread_cond_t *__cond) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex) - __attribute__ ((__nonnull__ (1, 2))); -# 1145 "/usr/include/pthread.h" 3 4 -extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex, - const struct timespec *__restrict __abstime) - __attribute__ ((__nonnull__ (1, 2, 3))); -# 1171 "/usr/include/pthread.h" 3 4 -extern int pthread_cond_clockwait (pthread_cond_t *__restrict __cond, - pthread_mutex_t *__restrict __mutex, - __clockid_t __clock_id, - const struct timespec *__restrict __abstime) - __attribute__ ((__nonnull__ (1, 2, 4))); -# 1194 "/usr/include/pthread.h" 3 4 -extern int pthread_condattr_init (pthread_condattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_condattr_destroy (pthread_condattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_condattr_getpshared (const pthread_condattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, - int __pshared) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_condattr_getclock (const pthread_condattr_t * - __restrict __attr, - __clockid_t *__restrict __clock_id) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_condattr_setclock (pthread_condattr_t *__attr, - __clockid_t __clock_id) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 1230 "/usr/include/pthread.h" 3 4 -extern int pthread_spin_init (pthread_spinlock_t *__lock, int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_destroy (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_lock (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_trylock (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_spin_unlock (pthread_spinlock_t *__lock) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int pthread_barrier_init (pthread_barrier_t *__restrict __barrier, - const pthread_barrierattr_t *__restrict - __attr, unsigned int __count) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrier_destroy (pthread_barrier_t *__barrier) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrier_wait (pthread_barrier_t *__barrier) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern int pthread_barrierattr_init (pthread_barrierattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrierattr_destroy (pthread_barrierattr_t *__attr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_barrierattr_getpshared (const pthread_barrierattr_t * - __restrict __attr, - int *__restrict __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int pthread_barrierattr_setpshared (pthread_barrierattr_t *__attr, - int __pshared) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 1297 "/usr/include/pthread.h" 3 4 -extern int pthread_key_create (pthread_key_t *__key, - void (*__destr_function) (void *)) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int pthread_key_delete (pthread_key_t __key) noexcept (true); - - -extern void *pthread_getspecific (pthread_key_t __key) noexcept (true); - - -extern int pthread_setspecific (pthread_key_t __key, - const void *__pointer) - noexcept (true) ; - - - - -extern int pthread_getcpuclockid (pthread_t __thread_id, - __clockid_t *__clock_id) - noexcept (true) __attribute__ ((__nonnull__ (2))); -# 1332 "/usr/include/pthread.h" 3 4 -extern int pthread_atfork (void (*__prepare) (void), - void (*__parent) (void), - void (*__child) (void)) noexcept (true); - - - - -extern __inline __attribute__ ((__gnu_inline__)) int - pthread_equal (pthread_t __thread1, pthread_t __thread2) noexcept (true) -{ - return __thread1 == __thread2; -} - - -} -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 2 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -typedef pthread_t __gthread_t; -typedef pthread_key_t __gthread_key_t; -typedef pthread_once_t __gthread_once_t; -typedef pthread_mutex_t __gthread_mutex_t; -typedef pthread_mutex_t __gthread_recursive_mutex_t; -typedef pthread_cond_t __gthread_cond_t; -typedef struct timespec __gthread_time_t; -# 299 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_active_p (void) -{ - return 1; -} -# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_create (__gthread_t *__threadid, void *(*__func) (void*), - void *__args) -{ - return pthread_create (__threadid, __null, __func, __args); -} - -static inline int -__gthread_join (__gthread_t __threadid, void **__value_ptr) -{ - return pthread_join (__threadid, __value_ptr); -} - -static inline int -__gthread_detach (__gthread_t __threadid) -{ - return pthread_detach (__threadid); -} - -static inline int -__gthread_equal (__gthread_t __t1, __gthread_t __t2) -{ - return pthread_equal (__t1, __t2); -} - -static inline __gthread_t -__gthread_self (void) -{ - return pthread_self (); -} - -static inline int -__gthread_yield (void) -{ - return sched_yield (); -} - -static inline int -__gthread_once (__gthread_once_t *__once, void (*__func) (void)) -{ - if (__gthread_active_p ()) - return pthread_once (__once, __func); - else - return -1; -} - -static inline int -__gthread_key_create (__gthread_key_t *__key, void (*__dtor) (void *)) -{ - return pthread_key_create (__key, __dtor); -} - -static inline int -__gthread_key_delete (__gthread_key_t __key) -{ - return pthread_key_delete (__key); -} - -static inline void * -__gthread_getspecific (__gthread_key_t __key) -{ - return pthread_getspecific (__key); -} - -static inline int -__gthread_setspecific (__gthread_key_t __key, const void *__ptr) -{ - return pthread_setspecific (__key, __ptr); -} - -static inline void -__gthread_mutex_init_function (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - pthread_mutex_init (__mutex, __null); -} - -static inline int -__gthread_mutex_destroy (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_destroy (__mutex); - else - return 0; -} - -static inline int -__gthread_mutex_lock (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_lock (__mutex); - else - return 0; -} - -static inline int -__gthread_mutex_trylock (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_trylock (__mutex); - else - return 0; -} - - -static inline int -__gthread_mutex_timedlock (__gthread_mutex_t *__mutex, - const __gthread_time_t *__abs_timeout) -{ - if (__gthread_active_p ()) - return pthread_mutex_timedlock (__mutex, __abs_timeout); - else - return 0; -} - - -static inline int -__gthread_mutex_unlock (__gthread_mutex_t *__mutex) -{ - if (__gthread_active_p ()) - return pthread_mutex_unlock (__mutex); - else - return 0; -} -# 808 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_lock (__mutex); -} - -static inline int -__gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_trylock (__mutex); -} - - -static inline int -__gthread_recursive_mutex_timedlock (__gthread_recursive_mutex_t *__mutex, - const __gthread_time_t *__abs_timeout) -{ - return __gthread_mutex_timedlock (__mutex, __abs_timeout); -} - - -static inline int -__gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_unlock (__mutex); -} - -static inline int -__gthread_recursive_mutex_destroy (__gthread_recursive_mutex_t *__mutex) -{ - return __gthread_mutex_destroy (__mutex); -} -# 850 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr-default.h" 3 -static inline int -__gthread_cond_broadcast (__gthread_cond_t *__cond) -{ - return pthread_cond_broadcast (__cond); -} - -static inline int -__gthread_cond_signal (__gthread_cond_t *__cond) -{ - return pthread_cond_signal (__cond); -} - -static inline int -__gthread_cond_wait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex) -{ - return pthread_cond_wait (__cond, __mutex); -} - -static inline int -__gthread_cond_timedwait (__gthread_cond_t *__cond, __gthread_mutex_t *__mutex, - const __gthread_time_t *__abs_timeout) -{ - return pthread_cond_timedwait (__cond, __mutex, __abs_timeout); -} - -static inline int -__gthread_cond_wait_recursive (__gthread_cond_t *__cond, - __gthread_recursive_mutex_t *__mutex) -{ - return __gthread_cond_wait (__cond, __mutex); -} - -static inline int -__gthread_cond_destroy (__gthread_cond_t* __cond) -{ - return pthread_cond_destroy (__cond); -} -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/gthr.h" 2 3 - - -#pragma GCC visibility pop -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 1 3 -# 32 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/atomic_word.h" 3 -typedef int _Atomic_word; -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 - -# 1 "/usr/include/sys/single_threaded.h" 1 3 4 -# 24 "/usr/include/sys/single_threaded.h" 3 4 -extern "C" { - - - - -extern char __libc_single_threaded; - -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 2 3 - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - __attribute__((__always_inline__)) - inline bool - __is_single_threaded() noexcept - { - - - - return ::__libc_single_threaded; - - - - } - - - - - - - inline _Atomic_word - __attribute__((__always_inline__)) - __exchange_and_add(volatile _Atomic_word* __mem, int __val) - { return __atomic_fetch_add(__mem, __val, 4); } - - inline void - __attribute__((__always_inline__)) - __atomic_add(volatile _Atomic_word* __mem, int __val) - { __atomic_fetch_add(__mem, __val, 4); } -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/atomicity.h" 3 - inline _Atomic_word - __attribute__((__always_inline__)) - __exchange_and_add_single(_Atomic_word* __mem, int __val) - { - _Atomic_word __result = *__mem; - *__mem += __val; - return __result; - } - - inline void - __attribute__((__always_inline__)) - __atomic_add_single(_Atomic_word* __mem, int __val) - { *__mem += __val; } - - inline _Atomic_word - __attribute__ ((__always_inline__)) - __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) - { - if (__is_single_threaded()) - return __exchange_and_add_single(__mem, __val); - else - return __exchange_and_add(__mem, __val); - } - - inline void - __attribute__ ((__always_inline__)) - __atomic_add_dispatch(_Atomic_word* __mem, int __val) - { - if (__is_single_threaded()) - __atomic_add_single(__mem, __val); - else - __atomic_add(__mem, __val); - } - - -} -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 3 - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 1 3 -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - void - __throw_bad_exception(void) __attribute__((__noreturn__)); - - - void - __throw_bad_alloc(void) __attribute__((__noreturn__)); - - void - __throw_bad_array_new_length(void) __attribute__((__noreturn__)); - - - void - __throw_bad_cast(void) __attribute__((__noreturn__)); - - void - __throw_bad_typeid(void) __attribute__((__noreturn__)); - - - void - __throw_logic_error(const char*) __attribute__((__noreturn__)); - - void - __throw_domain_error(const char*) __attribute__((__noreturn__)); - - void - __throw_invalid_argument(const char*) __attribute__((__noreturn__)); - - void - __throw_length_error(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) - __attribute__((__format__(__gnu_printf__, 1, 2))); - - void - __throw_runtime_error(const char*) __attribute__((__noreturn__)); - - void - __throw_range_error(const char*) __attribute__((__noreturn__)); - - void - __throw_overflow_error(const char*) __attribute__((__noreturn__)); - - void - __throw_underflow_error(const char*) __attribute__((__noreturn__)); - - - void - __throw_ios_failure(const char*) __attribute__((__noreturn__)); - - void - __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); - - - void - __throw_system_error(int) __attribute__((__noreturn__)); - - - void - __throw_future_error(int) __attribute__((__noreturn__)); - - - void - __throw_bad_function_call() __attribute__((__noreturn__)); -# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -} -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 2 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - template - class __new_allocator - { - public: - typedef _Tp value_type; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - - template - struct rebind - { typedef __new_allocator<_Tp1> other; }; - - - - - - typedef std::true_type propagate_on_container_move_assignment; - - - __attribute__((__always_inline__)) - - __new_allocator() noexcept { } - - __attribute__((__always_inline__)) - - __new_allocator(const __new_allocator&) noexcept { } - - template - __attribute__((__always_inline__)) - - __new_allocator(const __new_allocator<_Tp1>&) noexcept { } - - - ~__new_allocator() noexcept { } - - pointer - address(reference __x) const noexcept - { return std::__addressof(__x); } - - const_pointer - address(const_reference __x) const noexcept - { return std::__addressof(__x); } -# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - [[__nodiscard__]] _Tp* - allocate(size_type __n, const void* = static_cast(0)) - { - - - - static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); - - - if (__builtin_expect(__n > this->_M_max_size(), false)) - { - - - if (__n > (std::size_t(-1) / sizeof(_Tp))) - std::__throw_bad_array_new_length(); - std::__throw_bad_alloc(); - } - - - if (alignof(_Tp) > 16UL) - { - std::align_val_t __al = std::align_val_t(alignof(_Tp)); - return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp), - __al)); - } - - return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp))); - } - - - void - deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) - { - - - - - - - - if (alignof(_Tp) > 16UL) - { - __builtin_operator_delete((__p), - std::align_val_t(alignof(_Tp))); - return; - } - - __builtin_operator_delete((__p)); - } - - - - - - - __attribute__((__always_inline__)) - size_type - max_size() const noexcept - { return _M_max_size(); } - - - template - __attribute__((__always_inline__)) - void - construct(_Up* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } - - template - __attribute__((__always_inline__)) - void - destroy(_Up* __p) - noexcept(std::is_nothrow_destructible<_Up>::value) - { __p->~_Up(); } -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - template - friend __attribute__((__always_inline__)) bool - operator==(const __new_allocator&, const __new_allocator<_Up>&) - noexcept - { return true; } - - - template - friend __attribute__((__always_inline__)) bool - operator!=(const __new_allocator&, const __new_allocator<_Up>&) - noexcept - { return false; } - - - private: - __attribute__((__always_inline__)) - constexpr size_type - _M_max_size() const noexcept - { - - return std::size_t(9223372036854775807L) / sizeof(_Tp); - - - - } - }; - - -} -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3 - - -namespace std -{ -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 - template - using __allocator_base = __new_allocator<_Tp>; -} -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - template<> - class allocator - { - public: - typedef void value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - - - typedef void* pointer; - typedef const void* const_pointer; - - template - struct rebind - { typedef allocator<_Tp1> other; }; - - - - - - using propagate_on_container_move_assignment = true_type; - - using is_always_equal - - = true_type; -# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - }; -# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - template - class allocator : public __allocator_base<_Tp> - { - public: - typedef _Tp value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - - - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - - template - struct rebind - { typedef allocator<_Tp1> other; }; - - - - - - using propagate_on_container_move_assignment = true_type; - - using is_always_equal - - = true_type; - - - - - __attribute__((__always_inline__)) - - allocator() noexcept { } - - __attribute__((__always_inline__)) - - allocator(const allocator& __a) noexcept - : __allocator_base<_Tp>(__a) { } - - - - allocator& operator=(const allocator&) = default; - - - template - __attribute__((__always_inline__)) - - allocator(const allocator<_Tp1>&) noexcept { } - - __attribute__((__always_inline__)) - - - - ~allocator() noexcept { } -# 214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - friend __attribute__((__always_inline__)) - bool - operator==(const allocator&, const allocator&) noexcept - { return true; } - - - friend __attribute__((__always_inline__)) - bool - operator!=(const allocator&, const allocator&) noexcept - { return false; } - - - - }; - - - - - - - template - __attribute__((__always_inline__)) - inline bool - operator==(const allocator<_T1>&, const allocator<_T2>&) - noexcept - { return true; } - - - template - __attribute__((__always_inline__)) - inline bool - operator!=(const allocator<_T1>&, const allocator<_T2>&) - noexcept - { return false; } - - - - - - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - - - - - - - extern template class allocator; - extern template class allocator; - - - - - - -} -# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - struct __true_type { }; - struct __false_type { }; - - template - struct __truth_type - { typedef __false_type __type; }; - - template<> - struct __truth_type - { typedef __true_type __type; }; - - - - template - struct __traitor - { - enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; - typedef typename __truth_type<__value>::__type __type; - }; - - - template - struct __are_same - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __are_same<_Tp, _Tp> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_void - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_void - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_integer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; - }; -# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template - struct __is_pointer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __is_pointer<_Tp*> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_arithmetic - : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > - { }; - - - - - template - struct __is_scalar - : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > - { }; - - - - - template - struct __is_char - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_byte - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - enum class byte : unsigned char; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template struct iterator_traits; - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = __is_trivially_copyable(_Tp) }; - }; - - - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = 0 }; - }; - - - template - struct __memcpyable - { - enum { __value = 0 }; - }; - - template - struct __memcpyable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcpyable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - template - struct __memcmpable - { - enum { __value = 0 }; - }; - - - template - struct __memcmpable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - - template::__value - - > - struct __is_memcmp_ordered - { - static const bool __value = _Tp(-1) > _Tp(1); - }; - - template - struct __is_memcmp_ordered<_Tp, false> - { - static const bool __value = false; - }; - - - template - struct __is_memcmp_ordered_with - { - static const bool __value = __is_memcmp_ordered<_Tp>::__value - && __is_memcmp_ordered<_Up>::__value; - }; - - template - struct __is_memcmp_ordered_with<_Tp, _Up, false> - { - static const bool __value = false; - }; -# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_memcmp_ordered_with - { static constexpr bool __value = true; }; - - template - struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> - { static constexpr bool __value = false; }; - - template - struct __is_memcmp_ordered_with - { static constexpr bool __value = false; }; - - - - - - template - struct __is_move_iterator - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - template - - inline _Iterator - __miter_base(_Iterator __it) - { return __it; } - - -} -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream_insert.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream_insert.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_forced.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cxxabi_forced.h" 3 - -#pragma GCC visibility push(default) - - -namespace __cxxabiv1 -{ - - - - - - - - class __forced_unwind - { - virtual ~__forced_unwind() throw(); - - - virtual void __pure_dummy() = 0; - }; -} - - -#pragma GCC visibility pop -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream_insert.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template - inline void - __ostream_write(basic_ostream<_CharT, _Traits>& __out, - const _CharT* __s, streamsize __n) - { - typedef basic_ostream<_CharT, _Traits> __ostream_type; - typedef typename __ostream_type::ios_base __ios_base; - - const streamsize __put = __out.rdbuf()->sputn(__s, __n); - if (__put != __n) - __out.setstate(__ios_base::badbit); - } - - template - inline void - __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n) - { - typedef basic_ostream<_CharT, _Traits> __ostream_type; - typedef typename __ostream_type::ios_base __ios_base; - - const _CharT __c = __out.fill(); - for (; __n > 0; --__n) - { - const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c); - if (_Traits::eq_int_type(__put, _Traits::eof())) - { - __out.setstate(__ios_base::badbit); - break; - } - } - } - - template - basic_ostream<_CharT, _Traits>& - __ostream_insert(basic_ostream<_CharT, _Traits>& __out, - const _CharT* __s, streamsize __n) - { - typedef basic_ostream<_CharT, _Traits> __ostream_type; - typedef typename __ostream_type::ios_base __ios_base; - - typename __ostream_type::sentry __cerb(__out); - if (__cerb) - { - try - { - const streamsize __w = __out.width(); - if (__w > __n) - { - const bool __left = ((__out.flags() - & __ios_base::adjustfield) - == __ios_base::left); - if (!__left) - __ostream_fill(__out, __w - __n); - if (__out.good()) - __ostream_write(__out, __s, __n); - if (__left && __out.good()) - __ostream_fill(__out, __w - __n); - } - else - __ostream_write(__out, __s, __n); - __out.width(0); - } - catch(__cxxabiv1::__forced_unwind&) - { - __out._M_setstate(__ios_base::badbit); - throw; - } - catch(...) - { __out._M_setstate(__ios_base::badbit); } - } - return __out; - } - - - - - extern template ostream& __ostream_insert(ostream&, const char*, streamsize); - - - extern template wostream& __ostream_insert(wostream&, const wchar_t*, - streamsize); - - - - - - -} -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - struct input_iterator_tag { }; - - - struct output_iterator_tag { }; - - - struct forward_iterator_tag : public input_iterator_tag { }; - - - - struct bidirectional_iterator_tag : public forward_iterator_tag { }; - - - - struct random_access_iterator_tag : public bidirectional_iterator_tag { }; -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct [[__deprecated__]] iterator - { - - typedef _Category iterator_category; - - typedef _Tp value_type; - - typedef _Distance difference_type; - - typedef _Pointer pointer; - - typedef _Reference reference; - }; -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits; - - - - - template> - struct __iterator_traits { }; - - - - template - struct __iterator_traits<_Iterator, - __void_t> - { - typedef typename _Iterator::iterator_category iterator_category; - typedef typename _Iterator::value_type value_type; - typedef typename _Iterator::difference_type difference_type; - typedef typename _Iterator::pointer pointer; - typedef typename _Iterator::reference reference; - }; - - - template - struct iterator_traits - : public __iterator_traits<_Iterator> { }; -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits<_Tp*> - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; - }; - - - template - struct iterator_traits - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; - }; - - - - - - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_Iter>::iterator_category - __iterator_category(const _Iter&) - { return typename iterator_traits<_Iter>::iterator_category(); } - - - - - template - using __iterator_category_t - = typename iterator_traits<_Iter>::iterator_category; - - template - using _RequireInputIter = - __enable_if_t, - input_iterator_tag>::value>; - - template> - struct __is_random_access_iter - : is_base_of - { - typedef is_base_of _Base; - enum { __value = _Base::value }; - }; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template struct _List_iterator; - template struct _List_const_iterator; - - - template - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - __distance(_InputIterator __first, _InputIterator __last, - input_iterator_tag) - { - - - - typename iterator_traits<_InputIterator>::difference_type __n = 0; - while (__first != __last) - { - ++__first; - ++__n; - } - return __n; - } - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_RandomAccessIterator>::difference_type - __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, - random_access_iterator_tag) - { - - - - return __last - __first; - } - - - - template - ptrdiff_t - __distance(std::_List_iterator<_Tp>, - std::_List_iterator<_Tp>, - input_iterator_tag); - - template - ptrdiff_t - __distance(std::_List_const_iterator<_Tp>, - std::_List_const_iterator<_Tp>, - input_iterator_tag); - - - - - template - void - __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; -# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - [[__nodiscard__]] __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - distance(_InputIterator __first, _InputIterator __last) - { - - return std::__distance(__first, __last, - std::__iterator_category(__first)); - } - - template - inline constexpr void - __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) - { - - - do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); - while (__n--) - ++__i; - } - - template - inline constexpr void - __advance(_BidirectionalIterator& __i, _Distance __n, - bidirectional_iterator_tag) - { - - - - if (__n > 0) - while (__n--) - ++__i; - else - while (__n++) - --__i; - } - - template - inline constexpr void - __advance(_RandomAccessIterator& __i, _Distance __n, - random_access_iterator_tag) - { - - - - if (__builtin_constant_p(__n) && __n == 1) - ++__i; - else if (__builtin_constant_p(__n) && __n == -1) - --__i; - else - __i += __n; - } - - - - template - void - __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; -# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - __attribute__((__always_inline__)) - inline constexpr void - advance(_InputIterator& __i, _Distance __n) - { - - typename iterator_traits<_InputIterator>::difference_type __d = __n; - std::__advance(__i, __d, std::__iterator_category(__i)); - } - - - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _InputIterator - next(_InputIterator __x, typename - iterator_traits<_InputIterator>::difference_type __n = 1) - { - - - std::advance(__x, __n); - return __x; - } - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _BidirectionalIterator - prev(_BidirectionalIterator __x, typename - iterator_traits<_BidirectionalIterator>::difference_type __n = 1) - { - - - - std::advance(__x, -__n); - return __x; - } - - - - -} -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - - - - -extern "C++" { - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct __enable_if - { }; - - template - struct __enable_if - { typedef _Tp __type; }; - - - - template - struct __conditional_type - { typedef _Iftrue __type; }; - - template - struct __conditional_type - { typedef _Iffalse __type; }; - - - - template - struct __add_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned short __type; }; - - template<> - struct __add_unsigned - { typedef unsigned int __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long long __type; }; - - - template<> - struct __add_unsigned; - - template<> - struct __add_unsigned; - - - - template - struct __remove_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef short __type; }; - - template<> - struct __remove_unsigned - { typedef int __type; }; - - template<> - struct __remove_unsigned - { typedef long __type; }; - - template<> - struct __remove_unsigned - { typedef long long __type; }; - - - template<> - struct __remove_unsigned; - - template<> - struct __remove_unsigned; - - - - template - constexpr - inline bool - __is_null_pointer(_Type* __ptr) - { return __ptr == 0; } - - template - constexpr - inline bool - __is_null_pointer(_Type) - { return false; } - - - constexpr bool - __is_null_pointer(std::nullptr_t) - { return true; } - - - - - template::__value> - struct __promote - { typedef double __type; }; - - - - - template - struct __promote<_Tp, false> - { }; - - template<> - struct __promote - { typedef long double __type; }; - - template<> - struct __promote - { typedef double __type; }; - - template<> - struct __promote - { typedef float __type; }; -# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - template - using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); - - - - template - using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; - - template - using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; - - template - using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 -} -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 -# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - class __undefined; - - - - template - struct __get_first_arg - { using type = __undefined; }; - - template class _SomeTemplate, typename _Tp, - typename... _Types> - struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> - { using type = _Tp; }; - - - - template - struct __replace_first_arg - { }; - - template class _SomeTemplate, typename _Up, - typename _Tp, typename... _Types> - struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> - { using type = _SomeTemplate<_Up, _Types...>; }; - - - template - struct __ptr_traits_elem : __get_first_arg<_Ptr> - { }; - - - - - - - - template - struct __ptr_traits_elem<_Ptr, __void_t> - { using type = typename _Ptr::element_type; }; - - - template - using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; - - - - - template::value> - struct __ptr_traits_ptr_to - { - using pointer = _Ptr; - using element_type = _Elt; - - - - - - - - static pointer - pointer_to(element_type& __r) - - - - - - { return pointer::pointer_to(__r); } - }; - - - template - struct __ptr_traits_ptr_to<_Ptr, _Elt, true> - { }; - - - template - struct __ptr_traits_ptr_to<_Tp*, _Tp, false> - { - using pointer = _Tp*; - using element_type = _Tp; - - - - - - - static pointer - pointer_to(element_type& __r) noexcept - { return std::addressof(__r); } - }; - - template - struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> - { - private: - template - using __diff_t = typename _Tp::difference_type; - - template - using __rebind = __type_identity>; - - public: - - using pointer = _Ptr; - - - using element_type = _Elt; - - - using difference_type = __detected_or_t; - - - template - using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, - __rebind, _Ptr, _Up>::type; - }; - - - - template - struct __ptr_traits_impl<_Ptr, __undefined> - { }; - - - - - - - - template - struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> - { }; - - - - - - - - template - struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> - { - - typedef _Tp* pointer; - - typedef _Tp element_type; - - typedef ptrdiff_t difference_type; - - template using rebind = _Up*; - }; - - - template - using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; - - template - constexpr _Tp* - __to_address(_Tp* __ptr) noexcept - { - static_assert(!std::is_function<_Tp>::value, "not a function pointer"); - return __ptr; - } - - - template - constexpr typename std::pointer_traits<_Ptr>::element_type* - __to_address(const _Ptr& __ptr) - { return std::__to_address(__ptr.operator->()); } -# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 -# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class reverse_iterator - : public iterator::iterator_category, - typename iterator_traits<_Iterator>::value_type, - typename iterator_traits<_Iterator>::difference_type, - typename iterator_traits<_Iterator>::pointer, - typename iterator_traits<_Iterator>::reference> - { - template - friend class reverse_iterator; -# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - protected: - _Iterator current; - - typedef iterator_traits<_Iterator> __traits_type; - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::pointer pointer; - - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - constexpr - reverse_iterator() - noexcept(noexcept(_Iterator())) - : current() - { } - - - - - explicit constexpr - reverse_iterator(iterator_type __x) - noexcept(noexcept(_Iterator(__x))) - : current(__x) - { } - - - - - constexpr - reverse_iterator(const reverse_iterator& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - reverse_iterator& operator=(const reverse_iterator&) = default; - - - - - - - template - - - - constexpr - reverse_iterator(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - template - - - - - constexpr - reverse_iterator& - operator=(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(current = __x.current)) - { - current = __x.current; - return *this; - } - - - - - - [[__nodiscard__]] - constexpr iterator_type - base() const - noexcept(noexcept(_Iterator(current))) - { return current; } -# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - { - _Iterator __tmp = current; - return *--__tmp; - } - - - - - - - [[__nodiscard__]] - constexpr pointer - operator->() const - - - - - { - - - _Iterator __tmp = current; - --__tmp; - return _S_to_pointer(__tmp); - } - - - - - - - constexpr reverse_iterator& - operator++() - { - --current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator++(int) - { - reverse_iterator __tmp = *this; - --current; - return __tmp; - } - - - - - - - constexpr reverse_iterator& - operator--() - { - ++current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator--(int) - { - reverse_iterator __tmp = *this; - ++current; - return __tmp; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator+(difference_type __n) const - { return reverse_iterator(current - __n); } - - - - - - - - constexpr reverse_iterator& - operator+=(difference_type __n) - { - current -= __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator-(difference_type __n) const - { return reverse_iterator(current + __n); } - - - - - - - - constexpr reverse_iterator& - operator-=(difference_type __n) - { - current += __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - { return *(*this + __n); } -# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - private: - template - static constexpr _Tp* - _S_to_pointer(_Tp* __p) - { return __p; } - - template - static constexpr pointer - _S_to_pointer(_Tp __t) - { return __t.operator->(); } - }; -# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y.base() < __x.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() > __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() != __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() < __y.base(); } - - template - inline constexpr bool - operator<=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() >= __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() <= __y.base(); } -# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr auto - operator-(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - -> decltype(__y.base() - __x.base()) - { return __y.base() - __x.base(); } - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - operator+(typename reverse_iterator<_Iterator>::difference_type __n, - const reverse_iterator<_Iterator>& __x) - { return reverse_iterator<_Iterator>(__x.base() - __n); } - - - - template - inline constexpr reverse_iterator<_Iterator> - __make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } - - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } -# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) - { return __make_reverse_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - : __is_move_iterator<_Iterator> - { }; - - template - - auto - __miter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) - { return __make_reverse_iterator(__miter_base(__it.base())); } -# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class back_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - back_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - back_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_back(__value); - return *this; - } - - - back_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_back(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - back_insert_iterator& - operator*() - { return *this; } - - - - back_insert_iterator& - operator++() - { return *this; } - - - - back_insert_iterator - operator++(int) - { return *this; } - }; -# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline back_insert_iterator<_Container> - back_inserter(_Container& __x) - { return back_insert_iterator<_Container>(__x); } -# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class front_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - front_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - front_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_front(__value); - return *this; - } - - - front_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_front(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - front_insert_iterator& - operator*() - { return *this; } - - - - front_insert_iterator& - operator++() - { return *this; } - - - - front_insert_iterator - operator++(int) - { return *this; } - }; -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline front_insert_iterator<_Container> - front_inserter(_Container& __x) - { return front_insert_iterator<_Container>(__x); } -# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class insert_iterator - : public iterator - { - - - - typedef typename _Container::iterator _Iter; - - protected: - _Container* container; - _Iter iter; - - public: - - typedef _Container container_type; -# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator(_Container& __x, _Iter __i) - : container(std::__addressof(__x)), iter(__i) {} -# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator& - operator=(const typename _Container::value_type& __value) - { - iter = container->insert(iter, __value); - ++iter; - return *this; - } - - - insert_iterator& - operator=(typename _Container::value_type&& __value) - { - iter = container->insert(iter, std::move(__value)); - ++iter; - return *this; - } - - - - [[__nodiscard__]] - insert_iterator& - operator*() - { return *this; } - - - - insert_iterator& - operator++() - { return *this; } - - - - insert_iterator& - operator++(int) - { return *this; } - }; - -#pragma GCC diagnostic pop -# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline insert_iterator<_Container> - inserter(_Container& __x, typename _Container::iterator __i) - { return insert_iterator<_Container>(__x, __i); } - - - - - -} - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class __normal_iterator - { - protected: - _Iterator _M_current; - - typedef std::iterator_traits<_Iterator> __traits_type; - - - template - using __convertible_from - = std::__enable_if_t::value>; - - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; - typedef typename __traits_type::pointer pointer; - - - - - - constexpr __normal_iterator() noexcept - : _M_current(_Iterator()) { } - - explicit - __normal_iterator(const _Iterator& __i) noexcept - : _M_current(__i) { } - - - - template> - - __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) - noexcept -# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - : _M_current(__i.base()) { } - - - - reference - operator*() const noexcept - { return *_M_current; } - - - pointer - operator->() const noexcept - { return _M_current; } - - - __normal_iterator& - operator++() noexcept - { - ++_M_current; - return *this; - } - - - __normal_iterator - operator++(int) noexcept - { return __normal_iterator(_M_current++); } - - - - __normal_iterator& - operator--() noexcept - { - --_M_current; - return *this; - } - - - __normal_iterator - operator--(int) noexcept - { return __normal_iterator(_M_current--); } - - - - reference - operator[](difference_type __n) const noexcept - { return _M_current[__n]; } - - - __normal_iterator& - operator+=(difference_type __n) noexcept - { _M_current += __n; return *this; } - - - __normal_iterator - operator+(difference_type __n) const noexcept - { return __normal_iterator(_M_current + __n); } - - - __normal_iterator& - operator-=(difference_type __n) noexcept - { _M_current -= __n; return *this; } - - - __normal_iterator - operator-(difference_type __n) const noexcept - { return __normal_iterator(_M_current - __n); } - - - const _Iterator& - base() const noexcept - { return _M_current; } - }; -# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - - - - - - template - - - [[__nodiscard__]] - inline auto - operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept - -> decltype(__lhs.base() - __rhs.base()) - - - - - - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline typename __normal_iterator<_Iterator, _Container>::difference_type - operator-(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline __normal_iterator<_Iterator, _Container> - operator+(typename __normal_iterator<_Iterator, _Container>::difference_type - __n, const __normal_iterator<_Iterator, _Container>& __i) - noexcept - { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } - - -} - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - - _Iterator - __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it.base(); } - - - - - - - template - constexpr auto - __to_address(const __gnu_cxx::__normal_iterator<_Iterator, - _Container>& __it) noexcept - -> decltype(std::__to_address(__it.base())) - { return std::__to_address(__it.base()); } -# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - namespace __detail - { -# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - } -# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class move_iterator - - - - { - _Iterator _M_current; - - using __traits_type = iterator_traits<_Iterator>; - - using __base_ref = typename __traits_type::reference; - - - template - friend class move_iterator; -# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - public: - using iterator_type = _Iterator; -# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - - typedef _Iterator pointer; - - - using reference - = __conditional_t::value, - typename remove_reference<__base_ref>::type&&, - __base_ref>; - - - constexpr - move_iterator() - : _M_current() { } - - explicit constexpr - move_iterator(iterator_type __i) - : _M_current(std::move(__i)) { } - - template - - - - constexpr - move_iterator(const move_iterator<_Iter>& __i) - : _M_current(__i._M_current) { } - - template - - - - - constexpr - move_iterator& operator=(const move_iterator<_Iter>& __i) - { - _M_current = __i._M_current; - return *this; - } - - - [[__nodiscard__]] - constexpr iterator_type - base() const - { return _M_current; } -# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - - - - { return static_cast(*_M_current); } - - - [[__nodiscard__]] - constexpr pointer - operator->() const - { return _M_current; } - - constexpr move_iterator& - operator++() - { - ++_M_current; - return *this; - } - - constexpr move_iterator - operator++(int) - { - move_iterator __tmp = *this; - ++_M_current; - return __tmp; - } - - - - - - - - constexpr move_iterator& - operator--() - { - --_M_current; - return *this; - } - - constexpr move_iterator - operator--(int) - { - move_iterator __tmp = *this; - --_M_current; - return __tmp; - } - - [[__nodiscard__]] - constexpr move_iterator - operator+(difference_type __n) const - { return move_iterator(_M_current + __n); } - - constexpr move_iterator& - operator+=(difference_type __n) - { - _M_current += __n; - return *this; - } - - [[__nodiscard__]] - constexpr move_iterator - operator-(difference_type __n) const - { return move_iterator(_M_current - __n); } - - constexpr move_iterator& - operator-=(difference_type __n) - { - _M_current -= __n; - return *this; - } - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - - - - { return std::move(_M_current[__n]); } -# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - }; - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() == __y.base(); } -# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - { return !(__x == __y); } - - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } -# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - template - [[__nodiscard__]] - inline constexpr auto - operator-(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - -> decltype(__x.base() - __y.base()) - { return __x.base() - __y.base(); } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - operator+(typename move_iterator<_Iterator>::difference_type __n, - const move_iterator<_Iterator>& __x) - { return __x + __n; } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - make_move_iterator(_Iterator __i) - { return move_iterator<_Iterator>(std::move(__i)); } - - template::value_type>::value, - _Iterator, move_iterator<_Iterator>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Iterator __i) - { return _ReturnType(__i); } - - - - template::value, - const _Tp*, move_iterator<_Tp*>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Tp* __i) - { return _ReturnType(__i); } -# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(move_iterator<_Iterator> __it) - -> decltype(make_move_iterator(__niter_base(__it.base()))) - { return make_move_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template - - auto - __miter_base(move_iterator<_Iterator> __it) - -> decltype(__miter_base(__it.base())) - { return __miter_base(__it.base()); } -# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - using __iter_key_t = remove_const_t< - typename iterator_traits<_InputIterator>::value_type::first_type>; - - template - using __iter_val_t - = typename iterator_traits<_InputIterator>::value_type::second_type; - - template - struct pair; - - template - using __iter_to_alloc_t - = pair, __iter_val_t<_InputIterator>>; - - - -} -# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct unary_function - { - - typedef _Arg argument_type; - - - typedef _Result result_type; - } __attribute__ ((__deprecated__)); - - - - - - template - struct binary_function - { - - typedef _Arg1 first_argument_type; - - - typedef _Arg2 second_argument_type; - - - typedef _Result result_type; - } __attribute__ ((__deprecated__)); -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - struct __is_transparent; - - template - struct plus; - - template - struct minus; - - template - struct multiplies; - - template - struct divides; - - template - struct modulus; - - template - struct negate; - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct plus : public binary_function<_Tp, _Tp, _Tp> - { - - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x + __y; } - }; - - - template - struct minus : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x - __y; } - }; - - - template - struct multiplies : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x * __y; } - }; - - - template - struct divides : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x / __y; } - }; - - - template - struct modulus : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x % __y; } - }; - - - template - struct negate : public unary_function<_Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x) const - { return -__x; } - }; -#pragma GCC diagnostic pop - - - - - - template<> - struct plus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct minus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct multiplies - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct divides - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct modulus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct negate - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(-std::forward<_Tp>(__t))) - -> decltype(-std::forward<_Tp>(__t)) - { return -std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; -# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct equal_to; - - template - struct not_equal_to; - - template - struct greater; - - template - struct less; - - template - struct greater_equal; - - template - struct less_equal; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct equal_to : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x == __y; } - }; - - - template - struct not_equal_to : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x != __y; } - }; - - - template - struct greater : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x > __y; } - }; - - - template - struct less : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x < __y; } - }; - - - template - struct greater_equal : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x >= __y; } - }; - - - template - struct less_equal : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x <= __y; } - }; - - - template - struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x > __y; - - return (long unsigned int)__x > (long unsigned int)__y; - } - }; - - - template - struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x < __y; - - return (long unsigned int)__x < (long unsigned int)__y; - } - }; - - - template - struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x >= __y; - - return (long unsigned int)__x >= (long unsigned int)__y; - } - }; - - - template - struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x <= __y; - - return (long unsigned int)__x <= (long unsigned int)__y; - } - }; -#pragma GCC diagnostic pop - - - - template<> - struct equal_to - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct not_equal_to - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct greater - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return greater>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return greater{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct less - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return less>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return less{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct greater_equal - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return greater_equal>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return greater_equal{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct less_equal - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return less_equal>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return less_equal{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; -# 781 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct logical_and; - - template - struct logical_or; - - template - struct logical_not; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct logical_and : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x && __y; } - }; - - - template - struct logical_or : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x || __y; } - }; - - - template - struct logical_not : public unary_function<_Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x) const - { return !__x; } - }; -#pragma GCC diagnostic pop - - - - template<> - struct logical_and - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct logical_or - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct logical_not - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(!std::forward<_Tp>(__t))) - -> decltype(!std::forward<_Tp>(__t)) - { return !std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; - - - - - template - struct bit_and; - - template - struct bit_or; - - template - struct bit_xor; - - template - struct bit_not; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - - template - struct bit_and : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x & __y; } - }; - - template - struct bit_or : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x | __y; } - }; - - template - struct bit_xor : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x ^ __y; } - }; - - template - struct bit_not : public unary_function<_Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x) const - { return ~__x; } - }; -#pragma GCC diagnostic pop - - - template <> - struct bit_and - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_or - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_xor - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_not - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(~std::forward<_Tp>(__t))) - -> decltype(~std::forward<_Tp>(__t)) - { return ~std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class [[__deprecated__]] unary_negate - : public unary_function - { - protected: - _Predicate _M_pred; - - public: - constexpr - explicit - unary_negate(const _Predicate& __x) : _M_pred(__x) { } - - constexpr - bool - operator()(const typename _Predicate::argument_type& __x) const - { return !_M_pred(__x); } - }; - - - template - __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) - constexpr - inline unary_negate<_Predicate> - not1(const _Predicate& __pred) - { return unary_negate<_Predicate>(__pred); } - - - template - class [[__deprecated__]] binary_negate - : public binary_function - { - protected: - _Predicate _M_pred; - - public: - constexpr - explicit - binary_negate(const _Predicate& __x) : _M_pred(__x) { } - - constexpr - bool - operator()(const typename _Predicate::first_argument_type& __x, - const typename _Predicate::second_argument_type& __y) const - { return !_M_pred(__x, __y); } - }; - - - template - __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) - constexpr - inline binary_negate<_Predicate> - not2(const _Predicate& __pred) - { return binary_negate<_Predicate>(__pred); } -# 1104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class pointer_to_unary_function : public unary_function<_Arg, _Result> - { - protected: - _Result (*_M_ptr)(_Arg); - - public: - pointer_to_unary_function() { } - - explicit - pointer_to_unary_function(_Result (*__x)(_Arg)) - : _M_ptr(__x) { } - - _Result - operator()(_Arg __x) const - { return _M_ptr(__x); } - } __attribute__ ((__deprecated__)); - - - template - __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) - inline pointer_to_unary_function<_Arg, _Result> - ptr_fun(_Result (*__x)(_Arg)) - { return pointer_to_unary_function<_Arg, _Result>(__x); } - - - template - class pointer_to_binary_function - : public binary_function<_Arg1, _Arg2, _Result> - { - protected: - _Result (*_M_ptr)(_Arg1, _Arg2); - - public: - pointer_to_binary_function() { } - - explicit - pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) - : _M_ptr(__x) { } - - _Result - operator()(_Arg1 __x, _Arg2 __y) const - { return _M_ptr(__x, __y); } - } __attribute__ ((__deprecated__)); - - - template - __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) - inline pointer_to_binary_function<_Arg1, _Arg2, _Result> - ptr_fun(_Result (*__x)(_Arg1, _Arg2)) - { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } - - - template - struct _Identity - : public unary_function<_Tp, _Tp> - { - _Tp& - operator()(_Tp& __x) const - { return __x; } - - const _Tp& - operator()(const _Tp& __x) const - { return __x; } - }; - - - template struct _Identity : _Identity<_Tp> { }; - - template - struct _Select1st - : public unary_function<_Pair, typename _Pair::first_type> - { - typename _Pair::first_type& - operator()(_Pair& __x) const - { return __x.first; } - - const typename _Pair::first_type& - operator()(const _Pair& __x) const - { return __x.first; } - - - template - typename _Pair2::first_type& - operator()(_Pair2& __x) const - { return __x.first; } - - template - const typename _Pair2::first_type& - operator()(const _Pair2& __x) const - { return __x.first; } - - }; - - template - struct _Select2nd - : public unary_function<_Pair, typename _Pair::second_type> - { - typename _Pair::second_type& - operator()(_Pair& __x) const - { return __x.second; } - - const typename _Pair::second_type& - operator()(const _Pair& __x) const - { return __x.second; } - }; -# 1231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class mem_fun_t : public unary_function<_Tp*, _Ret> - { - public: - explicit - mem_fun_t(_Ret (_Tp::*__pf)()) - : _M_f(__pf) { } - - _Ret - operator()(_Tp* __p) const - { return (__p->*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)(); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun_t : public unary_function - { - public: - explicit - const_mem_fun_t(_Ret (_Tp::*__pf)() const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp* __p) const - { return (__p->*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)() const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun_ref_t : public unary_function<_Tp, _Ret> - { - public: - explicit - mem_fun_ref_t(_Ret (_Tp::*__pf)()) - : _M_f(__pf) { } - - _Ret - operator()(_Tp& __r) const - { return (__r.*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)(); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> - { - public: - explicit - const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp& __r) const - { return (__r.*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)() const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> - { - public: - explicit - mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) - : _M_f(__pf) { } - - _Ret - operator()(_Tp* __p, _Arg __x) const - { return (__p->*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun1_t : public binary_function - { - public: - explicit - const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp* __p, _Arg __x) const - { return (__p->*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg) const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> - { - public: - explicit - mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) - : _M_f(__pf) { } - - _Ret - operator()(_Tp& __r, _Arg __x) const - { return (__r.*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> - { - public: - explicit - const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp& __r, _Arg __x) const - { return (__r.*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg) const; - } __attribute__ ((__deprecated__)); - - - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun_t<_Ret, _Tp> - mem_fun(_Ret (_Tp::*__f)()) - { return mem_fun_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun_t<_Ret, _Tp> - mem_fun(_Ret (_Tp::*__f)() const) - { return const_mem_fun_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun_ref_t<_Ret, _Tp> - mem_fun_ref(_Ret (_Tp::*__f)()) - { return mem_fun_ref_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun_ref_t<_Ret, _Tp> - mem_fun_ref(_Ret (_Tp::*__f)() const) - { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun1_t<_Ret, _Tp, _Arg> - mem_fun(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun1_t<_Ret, _Tp, _Arg> - mem_fun(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun1_ref_t<_Ret, _Tp, _Arg> - mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> - mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } -#pragma GCC diagnostic pop - - - - - template> - struct __has_is_transparent - { }; - - template - struct __has_is_transparent<_Func, _SfinaeType, - __void_t> - { typedef void type; }; - - template - using __has_is_transparent_t - = typename __has_is_transparent<_Func, _SfinaeType>::type; - - - -} - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 1 3 -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 - template - class binder1st - : public unary_function - { - protected: - _Operation op; - typename _Operation::first_argument_type value; - - public: - binder1st(const _Operation& __x, - const typename _Operation::first_argument_type& __y) - : op(__x), value(__y) { } - - typename _Operation::result_type - operator()(const typename _Operation::second_argument_type& __x) const - { return op(value, __x); } - - - - typename _Operation::result_type - operator()(typename _Operation::second_argument_type& __x) const - { return op(value, __x); } - } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); - - - template - __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) - inline binder1st<_Operation> - bind1st(const _Operation& __fn, const _Tp& __x) - { - typedef typename _Operation::first_argument_type _Arg1_type; - return binder1st<_Operation>(__fn, _Arg1_type(__x)); - } - - - template - class binder2nd - : public unary_function - { - protected: - _Operation op; - typename _Operation::second_argument_type value; - - public: - binder2nd(const _Operation& __x, - const typename _Operation::second_argument_type& __y) - : op(__x), value(__y) { } - - typename _Operation::result_type - operator()(const typename _Operation::first_argument_type& __x) const - { return op(__x, value); } - - - - typename _Operation::result_type - operator()(typename _Operation::first_argument_type& __x) const - { return op(__x, value); } - } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); - - - template - __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) - inline binder2nd<_Operation> - bind2nd(const _Operation& __fn, const _Tp& __x) - { - typedef typename _Operation::second_argument_type _Arg2_type; - return binder2nd<_Operation>(__fn, _Arg2_type(__x)); - } - - - -} - -#pragma GCC diagnostic pop -# 1439 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 2 3 -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - - - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __is_integer_nonstrict - : public std::__is_integer<_Tp> - { - using std::__is_integer<_Tp>::__value; - - - enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; - }; - - template - struct __numeric_traits_integer - { - - static_assert(__is_integer_nonstrict<_Value>::__value, - "invalid specialization"); - - - - - static const bool __is_signed = (_Value)(-1) < 0; - static const int __digits - = __is_integer_nonstrict<_Value>::__width - __is_signed; - - - static const _Value __max = __is_signed - ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) - : ~(_Value)0; - static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; - }; - - template - const _Value __numeric_traits_integer<_Value>::__min; - - template - const _Value __numeric_traits_integer<_Value>::__max; - - template - const bool __numeric_traits_integer<_Value>::__is_signed; - - template - const int __numeric_traits_integer<_Value>::__digits; -# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; - - - - - - - template - using __int_traits = __numeric_traits_integer<_Tp>; -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __numeric_traits_floating - { - - static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); - - - static const bool __is_signed = true; - static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); - static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); - }; - - template - const int __numeric_traits_floating<_Value>::__max_digits10; - - template - const bool __numeric_traits_floating<_Value>::__is_signed; - - template - const int __numeric_traits_floating<_Value>::__digits10; - - template - const int __numeric_traits_floating<_Value>::__max_exponent10; - - - - - - - template - struct __numeric_traits - : public __numeric_traits_integer<_Value> - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; -# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 -} -# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct tuple_size; - - - - - - template::type, - typename = typename enable_if::value>::type, - size_t = tuple_size<_Tp>::value> - using __enable_if_has_tuple_size = _Tp; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - - template - inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; - - - - template - struct tuple_element; - - - template - using __tuple_element_t = typename tuple_element<__i, _Tp>::type; - - template - struct tuple_element<__i, const _Tp> - { - using type = const __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, volatile _Tp> - { - using type = volatile __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, const volatile _Tp> - { - using type = const volatile __tuple_element_t<__i, _Tp>; - }; - - - - - - template - constexpr size_t - __find_uniq_type_in_pack() - { - constexpr size_t __sz = sizeof...(_Types); - constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; - size_t __n = __sz; - for (size_t __i = 0; __i < __sz; ++__i) - { - if (__found[__i]) - { - if (__n < __sz) - return __sz; - __n = __i; - } - } - return __n; - } -# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - template - using tuple_element_t = typename tuple_element<__i, _Tp>::type; - - - - - template struct _Index_tuple { }; - - - template - struct _Build_index_tuple - { - - template - using _IdxTuple = _Index_tuple<_Indices...>; - - - using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; - - - - - }; - - - - - - - template - struct integer_sequence - { - typedef _Tp value_type; - static constexpr size_t size() noexcept { return sizeof...(_Idx); } - }; - - - template - using make_integer_sequence - - = __make_integer_seq; - - - - - - template - using index_sequence = integer_sequence; - - - template - using make_index_sequence = make_integer_sequence; - - - template - using index_sequence_for = make_index_sequence; - - - - struct in_place_t { - explicit in_place_t() = default; - }; - - inline constexpr in_place_t in_place{}; - - template struct in_place_type_t - { - explicit in_place_type_t() = default; - }; - - template - inline constexpr in_place_type_t<_Tp> in_place_type{}; - - template struct in_place_index_t - { - explicit in_place_index_t() = default; - }; - - template - inline constexpr in_place_index_t<_Idx> in_place_index{}; - - template - inline constexpr bool __is_in_place_type_v = false; - - template - inline constexpr bool __is_in_place_type_v> = true; - - template - using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; - - - - - template - struct _Nth_type - { }; - - template - struct _Nth_type<0, _Tp0, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Rest...> - { using type = _Tp1; }; - - template - struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp2; }; - - template - - - - struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> - : _Nth_type<_Np - 3, _Rest...> - { }; - - - template - struct _Nth_type<0, _Tp0, _Tp1, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp1; }; - - - - - - - -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; - - - inline constexpr piecewise_construct_t piecewise_construct = - piecewise_construct_t(); - - - - - template - class tuple; - - template - struct _Index_tuple; - - - - - - - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return __and_, - is_constructible<_T2, const _U2&>>::value; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return __and_, - is_convertible>::value; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return __and_, - is_constructible<_T2, _U2&&>>::value; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return __and_, - is_convertible<_U2&&, _T2>>::value; - } - }; - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return false; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return false; - } - }; - - - - template class __pair_base - { - - template friend struct pair; - __pair_base() = default; - ~__pair_base() = default; - __pair_base(const __pair_base&) = default; - __pair_base& operator=(const __pair_base&) = delete; - - }; -# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct pair - : public __pair_base<_T1, _T2> - { - typedef _T1 first_type; - typedef _T2 second_type; - - _T1 first; - _T2 second; - - - constexpr pair(const pair&) = default; - constexpr pair(pair&&) = default; - - template - - pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); - - - void - swap(pair& __p) - noexcept(__and_<__is_nothrow_swappable<_T1>, - __is_nothrow_swappable<_T2>>::value) - { - using std::swap; - swap(first, __p.first); - swap(second, __p.second); - } -# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - template - - pair(tuple<_Args1...>&, tuple<_Args2...>&, - _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); - public: -# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template , - __is_implicitly_default_constructible<_U2>> - ::value, bool>::type = true> - constexpr pair() - : first(), second() { } - - template , - is_default_constructible<_U2>, - __not_< - __and_<__is_implicitly_default_constructible<_U1>, - __is_implicitly_default_constructible<_U2>>>> - ::value, bool>::type = false> - explicit constexpr pair() - : first(), second() { } - - - - using _PCCP = _PCC; - - - - template() - && _PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - template() - && !_PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - - template - using _PCCFP = _PCC::value - || !is_same<_T2, _U2>::value, - _T1, _T2>; - - - template::template - _ConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } - - template::template - _ConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } -# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - - - - struct __zero_as_null_pointer_constant - { - __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) - { } - template::value>> - __zero_as_null_pointer_constant(_Tp) = delete; - }; - - public: - - - - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - is_convertible<_U1, _T1>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - is_convertible<_U2, _T2>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - - - template() - && _PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - template() - && !_PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - - template::template - _MoveConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - template::template - _MoveConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - - - pair& - operator=(__conditional_t<__and_, - is_copy_assignable<_T2>>::value, - const pair&, const __nonesuch&> __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - pair& - operator=(__conditional_t<__and_, - is_move_assignable<_T2>>::value, - pair&&, __nonesuch&&> __p) - noexcept(__and_, - is_nothrow_move_assignable<_T2>>::value) - { - first = std::forward(__p.first); - second = std::forward(__p.second); - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, const _U2&>>::value, - pair&>::type - operator=(const pair<_U1, _U2>& __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, _U2&&>>::value, - pair&>::type - operator=(pair<_U1, _U2>&& __p) - { - first = std::forward<_U1>(__p.first); - second = std::forward<_U2>(__p.second); - return *this; - } -# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - }; - - - - - template pair(_T1, _T2) -> pair<_T1, _T2>; - - - - template - inline constexpr bool - operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first == __y.first && __x.second == __y.second; } -# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline constexpr bool - operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first < __y.first - || (!(__y.first < __x.first) && __x.second < __y.second); } - - - template - inline constexpr bool - operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x == __y); } - - - template - inline constexpr bool - operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __y < __x; } - - - template - inline constexpr bool - operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__y < __x); } - - - template - inline constexpr bool - operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x < __y); } -# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline - - - typename enable_if<__and_<__is_swappable<_T1>, - __is_swappable<_T2>>::value>::type - - - - swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } -# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - typename enable_if, - __is_swappable<_T2>>::value>::type - swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; -# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - constexpr pair::__type, - typename __decay_and_strip<_T2>::__type> - make_pair(_T1&& __x, _T2&& __y) - { - typedef typename __decay_and_strip<_T1>::__type __ds_type1; - typedef typename __decay_and_strip<_T2>::__type __ds_type2; - typedef pair<__ds_type1, __ds_type2> __pair_type; - return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); - } -# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct __is_tuple_like_impl> : true_type - { }; - - - - template - struct tuple_size> - : public integral_constant { }; - - - template - struct tuple_element<0, pair<_Tp1, _Tp2>> - { typedef _Tp1 type; }; - - - template - struct tuple_element<1, pair<_Tp1, _Tp2>> - { typedef _Tp2 type; }; - - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr bool __is_pair = false; - - template - inline constexpr bool __is_pair> = true; - - - - template - struct __pair_get; - - template<> - struct __pair_get<0> - { - template - static constexpr _Tp1& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr _Tp1&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp1>(__pair.first); } - - template - static constexpr const _Tp1& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr const _Tp1&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.first); } - }; - - template<> - struct __pair_get<1> - { - template - static constexpr _Tp2& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr _Tp2&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp2>(__pair.second); } - - template - static constexpr const _Tp2& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr const _Tp2&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.second); } - }; - - - - - - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__get(__in); } - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__move_get(std::move(__in)); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(const pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__const_get(__in); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(const pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__const_move_get(std::move(__in)); } - - - - - - template - constexpr _Tp& - get(pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr const _Tp& - get(const pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr _Tp&& - get(pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr const _Tp&& - get(const pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr _Tp& - get(pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr const _Tp& - get(const pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr _Tp&& - get(pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } - - template - constexpr const _Tp&& - get(const pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } -# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 -namespace std -{ - namespace __debug { } -} - - - - -namespace __gnu_debug -{ - using namespace std::__debug; - - template - struct _Safe_iterator; -} -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 -namespace __gnu_cxx -{ -namespace __ops -{ - struct _Iter_less_iter - { - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 < *__it2; } - }; - - constexpr - inline _Iter_less_iter - __iter_less_iter() - { return _Iter_less_iter(); } - - struct _Iter_less_val - { - - constexpr _Iter_less_val() = default; - - - - - - explicit - _Iter_less_val(_Iter_less_iter) { } - - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it < __val; } - }; - - - inline _Iter_less_val - __iter_less_val() - { return _Iter_less_val(); } - - - inline _Iter_less_val - __iter_comp_val(_Iter_less_iter) - { return _Iter_less_val(); } - - struct _Val_less_iter - { - - constexpr _Val_less_iter() = default; - - - - - - explicit - _Val_less_iter(_Iter_less_iter) { } - - template - - bool - operator()(_Value& __val, _Iterator __it) const - { return __val < *__it; } - }; - - - inline _Val_less_iter - __val_less_iter() - { return _Val_less_iter(); } - - - inline _Val_less_iter - __val_comp_iter(_Iter_less_iter) - { return _Val_less_iter(); } - - struct _Iter_equal_to_iter - { - template - - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 == *__it2; } - }; - - - inline _Iter_equal_to_iter - __iter_equal_to_iter() - { return _Iter_equal_to_iter(); } - - struct _Iter_equal_to_val - { - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it == __val; } - }; - - - inline _Iter_equal_to_val - __iter_equal_to_val() - { return _Iter_equal_to_val(); } - - - inline _Iter_equal_to_val - __iter_comp_val(_Iter_equal_to_iter) - { return _Iter_equal_to_val(); } - - template - struct _Iter_comp_iter - { - _Compare _M_comp; - - explicit constexpr - _Iter_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) - { return bool(_M_comp(*__it1, *__it2)); } - }; - - template - constexpr - inline _Iter_comp_iter<_Compare> - __iter_comp_iter(_Compare __comp) - { return _Iter_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_comp_val - { - _Compare _M_comp; - - - explicit - _Iter_comp_val(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Iterator __it, _Value& __val) - { return bool(_M_comp(*__it, __val)); } - }; - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Compare __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Iter_comp_iter<_Compare> __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - struct _Val_comp_iter - { - _Compare _M_comp; - - - explicit - _Val_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Value& __val, _Iterator __it) - { return bool(_M_comp(__val, *__it)); } - }; - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Compare __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Iter_comp_iter<_Compare> __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_equals_val - { - _Value& _M_value; - - - explicit - _Iter_equals_val(_Value& __value) - : _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return *__it == _M_value; } - }; - - template - - inline _Iter_equals_val<_Value> - __iter_equals_val(_Value& __val) - { return _Iter_equals_val<_Value>(__val); } - - template - struct _Iter_equals_iter - { - _Iterator1 _M_it1; - - - explicit - _Iter_equals_iter(_Iterator1 __it1) - : _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return *__it2 == *_M_it1; } - }; - - template - - inline _Iter_equals_iter<_Iterator> - __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) - { return _Iter_equals_iter<_Iterator>(__it); } - - template - struct _Iter_pred - { - _Predicate _M_pred; - - - explicit - _Iter_pred(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_pred<_Predicate> - __pred_iter(_Predicate __pred) - { return _Iter_pred<_Predicate>(std::move(__pred)); } - - template - struct _Iter_comp_to_val - { - _Compare _M_comp; - _Value& _M_value; - - - _Iter_comp_to_val(_Compare __comp, _Value& __value) - : _M_comp(std::move(__comp)), _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_comp(*__it, _M_value)); } - }; - - template - _Iter_comp_to_val<_Compare, _Value> - - __iter_comp_val(_Compare __comp, _Value &__val) - { - return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); - } - - template - struct _Iter_comp_to_iter - { - _Compare _M_comp; - _Iterator1 _M_it1; - - - _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) - : _M_comp(std::move(__comp)), _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return bool(_M_comp(*__it2, *_M_it1)); } - }; - - template - - inline _Iter_comp_to_iter<_Compare, _Iterator> - __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) - { - return _Iter_comp_to_iter<_Compare, _Iterator>( - std::move(__comp._M_comp), __it); - } - - template - struct _Iter_negate - { - _Predicate _M_pred; - - - explicit - _Iter_negate(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return !bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_negate<_Predicate> - __negate(_Iter_pred<_Predicate> __pred) - { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } - -} -} -# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 - template - constexpr _Tp - __rotl(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); - else - return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); - } - - template - constexpr _Tp - __rotr(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); - else - return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); - } - - template - constexpr int - __countl_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - { - constexpr int __diff = _Nd_u - _Nd; - return __builtin_clz(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ul) - { - constexpr int __diff = _Nd_ul - _Nd; - return __builtin_clzl(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ull) - { - constexpr int __diff = _Nd_ull - _Nd; - return __builtin_clzll(__x) - __diff; - } - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - unsigned long long __high = __x >> _Nd_ull; - if (__high != 0) - { - constexpr int __diff = (2 * _Nd_ull) - _Nd; - return __builtin_clzll(__high) - __diff; - } - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - return (_Nd - _Nd_ull) + __builtin_clzll(__low); - } - } - - template - constexpr int - __countl_one(_Tp __x) noexcept - { - return std::__countl_zero<_Tp>((_Tp)~__x); - } - - template - constexpr int - __countr_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_ctz(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_ctzl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_ctzll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - if (__low != 0) - return __builtin_ctzll(__low); - unsigned long long __high = __x >> _Nd_ull; - return __builtin_ctzll(__high) + _Nd_ull; - } - } - - template - constexpr int - __countr_one(_Tp __x) noexcept - { - return std::__countr_zero((_Tp)~__x); - } - - template - constexpr int - __popcount(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_popcount(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_popcountl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_popcountll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - unsigned long long __high = __x >> _Nd_ull; - return __builtin_popcountll(__low) + __builtin_popcountll(__high); - } - } - - template - constexpr bool - __has_single_bit(_Tp __x) noexcept - { return std::__popcount(__x) == 1; } - - template - constexpr _Tp - __bit_ceil(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - if (__x == 0 || __x == 1) - return 1; - auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); - - - - - if (!std::__is_constant_evaluated()) - { - do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); - } - - using __promoted_type = decltype(__x << 1); - if constexpr (!is_same<__promoted_type, _Tp>::value) - { - - - - - - const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; - __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; - } - return (_Tp)1u << __shift_exponent; - } - - template - constexpr _Tp - __bit_floor(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if (__x == 0) - return 0; - return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); - } - - template - constexpr int - __bit_width(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - return _Nd - std::__countl_zero(__x); - } -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -} -# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - template - constexpr - inline int - __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) - { - - static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); -# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); - } -# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) - { -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - swap(*__a, *__b); - - } -# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - _ForwardIterator2 - swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - std::iter_swap(__first1, __first2); - return __first2; - } -# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b) - { - - - - if (__b < __a) - return __b; - return __a; - } -# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b) - { - - - - if (__a < __b) - return __b; - return __a; - } -# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__b, __a)) - return __b; - return __a; - } -# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__a, __b)) - return __b; - return __a; - } - - - - template - - inline _Iterator - __niter_base(_Iterator __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it; } - - template - _Ite - __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, - std::random_access_iterator_tag>&); - - - - - template - - inline _From - __niter_wrap(_From __from, _To __res) - { return __from + (__res - std::__niter_base(__from)); } - - - template - - inline _Iterator - __niter_wrap(const _Iterator&, _Iterator __res) - { return __res; } - - - - - - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = *__first; - return __result; - } - }; - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = std::move(*__first); - return __result; - } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = *__first; - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = *__from; } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = std::move(*__first); - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = std::move(*__from); } - }; - - - template - struct __copy_move<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_m(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result, __first); - return __result + _Num; - } - }; - - - - template - struct _Deque_iterator; - - struct _Bit_iterator; - - - - - - - template - struct char_traits; - - template - class istreambuf_iterator; - - template - class ostreambuf_iterator; - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(_CharT*, _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(const _CharT*, const _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - _CharT*>::__type - __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_move_a2( - istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>); - - - template - - inline _OI - __copy_move_a2(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::iterator_category _Category; - - - - - - return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, - _Category>::__copy_m(__first, __last, __result); - } - - template - _OI - __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_a1(_II __first, _II __last, _OI __result) - { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } - - template - - inline _OI - __copy_move_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_a1<_IsMove>(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); - - template - - _OutputIterator - __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, - bool) - { - if (__n > 0) - { - while (true) - { - *__result = *__first; - ++__result; - if (--__n > 0) - ++__first; - else - break; - } - } - return __result; - } - - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, _CharT*>::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, - _Size, _CharT*, bool); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>, - bool); -# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - copy(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a<__is_move_iterator<_II>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - move(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a(std::__miter_base(__first), - std::__miter_base(__last), __result); - } - - - - - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = *--__last; - return __result; - } - }; - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = *--__last; - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template - struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result - 1, __first); - return __result - _Num; - } - }; - - template - - inline _BI2 - __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) - { - typedef typename iterator_traits<_BI1>::iterator_category _Category; - - - - - - return std::__copy_move_backward<_IsMove, - __memcpyable<_BI2, _BI1>::__value, - _Category>::__copy_move_b(__first, - __last, - __result); - } - - template - - inline _BI2 - __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) - { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } - - template - _OI - __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_backward_a1( - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_backward_a1(_II, _II, - std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_backward_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_backward_a1<_IsMove> - (std::__niter_base(__first), std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_backward_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); -# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - move_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a(std::__miter_base(__first), - std::__miter_base(__last), - __result); - } - - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - for (; __first != __last; ++__first) - *__first = __value; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __first != __last; ++__first) - *__first = __tmp; - } - - - template - - inline typename - __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type - __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) - { - const _Tp __tmp = __c; -# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - if (const size_t __len = __last - __first) - __builtin_memset(__first, static_cast(__tmp), __len); - } - - template - - inline void - __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, - ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, - const _Tp& __value) - { std::__fill_a1(__first.base(), __last.base(), __value); } - - template - void - __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const _VTp&); - - - void - __fill_a1(std::_Bit_iterator, std::_Bit_iterator, - const bool&); - - template - - inline void - __fill_a(_FIte __first, _FIte __last, const _Tp& __value) - { std::__fill_a1(__first, __last, __value); } - - template - void - __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const _Tp&); -# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) - { - - - - ; - - std::__fill_a(__first, __last, __value); - } - - - inline constexpr int - __size_to_integer(int __n) { return __n; } - inline constexpr unsigned - __size_to_integer(unsigned __n) { return __n; } - inline constexpr long - __size_to_integer(long __n) { return __n; } - inline constexpr unsigned long - __size_to_integer(unsigned long __n) { return __n; } - inline constexpr long long - __size_to_integer(long long __n) { return __n; } - inline constexpr unsigned long long - __size_to_integer(unsigned long long __n) { return __n; } -# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - inline constexpr long long - __size_to_integer(float __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(double __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(long double __n) { return (long long)__n; } - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - for (; __n > 0; --__n, (void) ++__first) - *__first = __value; - return __first; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __n > 0; --__n, (void) ++__first) - *__first = __tmp; - return __first; - } - - template - ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, - _Size __n, const _Tp& __value, - std::input_iterator_tag); - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::output_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::input_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::random_access_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - if (__n <= 0) - return __first; - - ; - - std::__fill_a(__first, __first + __n, __value); - return __first + __n; - } -# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - fill_n(_OI __first, _Size __n, const _Tp& __value) - { - - - - return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, - std::__iterator_category(__first)); - } - - template - struct __equal - { - template - - static bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - for (; __first1 != __last1; ++__first1, (void) ++__first2) - if (!(*__first1 == *__first2)) - return false; - return true; - } - }; - - template<> - struct __equal - { - template - - static bool - equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) - { - if (const size_t __len = (__last1 - __first1)) - return !std::__memcmp(__first1, __first2, __len); - return true; - } - }; - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _II); - - template - bool - __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(_II, _II, - std::_Deque_iterator<_Tp, _Ref, _Ptr>); - - template - - inline bool - __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - const bool __simple = ((__is_integer<_ValueType1>::__value - || __is_pointer<_ValueType1>::__value) - && __memcmpable<_II1, _II2>::__value); - return std::__equal<__simple>::equal(__first1, __last1, __first2); - } - - template - - inline bool - __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) - { - return std::__equal_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2)); - } - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - _II2); - - template - bool - __equal_aux(_II1, _II1, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - struct __lc_rai - { - template - - static _II1 - __newlast1(_II1, _II1 __last1, _II2, _II2) - { return __last1; } - - template - - static bool - __cnd2(_II __first, _II __last) - { return __first != __last; } - }; - - template<> - struct __lc_rai - { - template - - static _RAI1 - __newlast1(_RAI1 __first1, _RAI1 __last1, - _RAI2 __first2, _RAI2 __last2) - { - const typename iterator_traits<_RAI1>::difference_type - __diff1 = __last1 - __first1; - const typename iterator_traits<_RAI2>::difference_type - __diff2 = __last2 - __first2; - return __diff2 < __diff1 ? __first1 + __diff2 : __last1; - } - - template - static bool - __cnd2(_RAI, _RAI) - { return true; } - }; - - template - - bool - __lexicographical_compare_impl(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, - _Compare __comp) - { - typedef typename iterator_traits<_II1>::iterator_category _Category1; - typedef typename iterator_traits<_II2>::iterator_category _Category2; - typedef std::__lc_rai<_Category1, _Category2> __rai_type; - - __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); - for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); - ++__first1, (void)++__first2) - { - if (__comp(__first1, __first2)) - return true; - if (__comp(__first2, __first1)) - return false; - } - return __first1 == __last1 && __first2 != __last2; - } - - template - struct __lexicographical_compare - { - template - - static bool - __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using __gnu_cxx::__ops::__iter_less_iter; - return std::__lexicographical_compare_impl(__first1, __last1, - __first2, __last2, - __iter_less_iter()); - } - - template - - static int - __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - while (__first1 != __last1) - { - if (__first2 == __last2) - return +1; - if (*__first1 < *__first2) - return -1; - if (*__first2 < *__first1) - return +1; - ++__first1; - ++__first2; - } - return int(__first2 == __last2) - 1; - } - }; - - template<> - struct __lexicographical_compare - { - template - - static bool - __lc(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { return __3way(__first1, __last1, __first2, __last2) < 0; } - - template - - static ptrdiff_t - __3way(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { - const size_t __len1 = __last1 - __first1; - const size_t __len2 = __last2 - __first2; - if (const size_t __len = std::min(__len1, __len2)) - if (int __result = std::__memcmp(__first1, __first2, __len)) - return __result; - return ptrdiff_t(__len1 - __len2); - } - }; - - template - - inline bool - __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - typedef typename iterator_traits<_II2>::value_type _ValueType2; - const bool __simple = - (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value - && __is_pointer<_II1>::__value - && __is_pointer<_II2>::__value - - - - - - - - ); - - return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, - __first2, __last2); - } - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - _Tp2*, _Tp2*); - - template - bool - __lexicographical_compare_aux1(_Tp1*, _Tp1*, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - - inline bool - __lexicographical_compare_aux(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - return std::__lexicographical_compare_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2), - std::__niter_base(__last2)); - } - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - _II2, _II2); - - template - bool - __lexicographical_compare_aux( - _II1, _II1, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - - _ForwardIterator - __lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val, _Compare __comp) - { - typedef typename iterator_traits<_ForwardIterator>::difference_type - _DistanceType; - - _DistanceType __len = std::distance(__first, __last); - - while (__len > 0) - { - _DistanceType __half = __len >> 1; - _ForwardIterator __middle = __first; - std::advance(__middle, __half); - if (__comp(__middle, __val)) - { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - else - __len = __half; - } - return __first; - } -# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _ForwardIterator - lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val) - { - - - - - ; - - return std::__lower_bound(__first, __last, __val, - __gnu_cxx::__ops::__iter_less_val()); - } - - - - template - inline constexpr _Tp - __lg(_Tp __n) - { - - return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; -# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - } -# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - - - - - - - ; - - return std::__equal_aux(__first1, __last1, __first2); - } -# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return true; - } - - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!(*__first1 == *__first2)) - return false; - return __first1 == __last1 && __first2 == __last2; - } - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, - _BinaryPredicate __binary_pred) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2, - __binary_pred); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return __first1 == __last1 && __first2 == __last2; - } -# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - - - - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2); - } -# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2, - __binary_pred); - } -# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { -# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - ; - ; - - return std::__lexicographical_compare_aux(__first1, __last1, - __first2, __last2); - } -# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, _Compare __comp) - { - - - - ; - ; - - return std::__lexicographical_compare_impl - (__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); - } -# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2) - { - - - - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __first2 != __last2 - && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2) - { - - - - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - - - template - - inline _InputIterator - __find_if(_InputIterator __first, _InputIterator __last, - _Predicate __pred, input_iterator_tag) - { - while (__first != __last && !__pred(__first)) - ++__first; - return __first; - } - - - template - - _RandomAccessIterator - __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Predicate __pred, random_access_iterator_tag) - { - typename iterator_traits<_RandomAccessIterator>::difference_type - __trip_count = (__last - __first) >> 2; - - for (; __trip_count > 0; --__trip_count) - { - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - } - - switch (__last - __first) - { - case 3: - if (__pred(__first)) - return __first; - ++__first; - - case 2: - if (__pred(__first)) - return __first; - ++__first; - - case 1: - if (__pred(__first)) - return __first; - ++__first; - - case 0: - default: - return __last; - } - } - - template - - inline _Iterator - __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) - { - return __find_if(__first, __last, __pred, - std::__iterator_category(__first)); - } - - template - - typename iterator_traits<_InputIterator>::difference_type - __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) - { - typename iterator_traits<_InputIterator>::difference_type __n = 0; - for (; __first != __last; ++__first) - if (__pred(__first)) - ++__n; - return __n; - } - - template - - _ForwardIterator - __remove_if(_ForwardIterator __first, _ForwardIterator __last, - _Predicate __pred) - { - __first = std::__find_if(__first, __last, __pred); - if (__first == __last) - return __first; - _ForwardIterator __result = __first; - ++__first; - for (; __first != __last; ++__first) - if (!__pred(__first)) - { - *__result = std::move(*__first); - ++__result; - } - return __result; - } - - - template - - bool - __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _BinaryPredicate __pred) - { - - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!__pred(__first1, __first2)) - break; - - if (__first1 == __last1) - return true; - - - - _ForwardIterator2 __last2 = __first2; - std::advance(__last2, std::distance(__first1, __last1)); - for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) - { - if (__scan != std::__find_if(__first1, __scan, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) - continue; - - auto __matches - = std::__count_if(__first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); - if (0 == __matches || - std::__count_if(__scan, __last1, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) - != __matches) - return false; - } - return true; - } -# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - - ; - - return std::__is_permutation(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } - - - -} -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 - - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 - template::type> - constexpr _Up&& - __invfwd(typename remove_reference<_Tp>::type& __t) noexcept - { return static_cast<_Up&&>(__t); } - - template - constexpr _Res - __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) - { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } - - template - constexpr _Res - __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, - _Args&&... __args) - { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } - - template - constexpr _Res - __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, - _Args&&... __args) - { - return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); - } - - template - constexpr _Res - __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) - { return __invfwd<_Tp>(__t).*__f; } - - template - constexpr _Res - __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) - { return (*std::forward<_Tp>(__t)).*__f; } - - - template - constexpr typename __invoke_result<_Callable, _Args...>::type - __invoke(_Callable&& __fn, _Args&&... __args) - noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) - { - using __result = __invoke_result<_Callable, _Args...>; - using __type = typename __result::type; - using __tag = typename __result::__invoke_type; - return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - } - - - - template - constexpr enable_if_t, _Res> - __invoke_r(_Callable&& __fn, _Args&&... __args) - noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) - { - using __result = __invoke_result<_Callable, _Args...>; - using __type = typename __result::type; - using __tag = typename __result::__invoke_type; - if constexpr (is_void_v<_Res>) - std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - else - return std::__invoke_impl<__type>(__tag{}, - std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - } -# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 - template - struct _Maybe_unary_or_binary_function { }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct _Maybe_unary_or_binary_function<_Res, _T1> - : std::unary_function<_T1, _Res> { }; - - - template - struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> - : std::binary_function<_T1, _T2, _Res> { }; - -#pragma GCC diagnostic pop - - template - struct _Mem_fn_traits; - - template - struct _Mem_fn_traits_base - { - using __result_type = _Res; - using __maybe_type - = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; - using __arity = integral_constant; - }; -# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; - - -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; - - - - - - - template> - struct _Maybe_get_result_type - { }; - - template - struct _Maybe_get_result_type<_Functor, - __void_t> - { typedef typename _Functor::result_type result_type; }; - - - - - - template - struct _Weak_result_type_impl - : _Maybe_get_result_type<_Functor> - { }; - - - template - struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct - _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)> - { typedef _Res result_type; }; - - - template::value> - struct _Weak_result_type_memfun - : _Weak_result_type_impl<_Functor> - { }; - - - template - struct _Weak_result_type_memfun<_MemFunPtr, true> - { - using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; - }; - - - template - struct _Weak_result_type_memfun<_Func _Class::*, false> - { }; - - - - - - template - struct _Weak_result_type - : _Weak_result_type_memfun::type> - { }; - - - - template> - struct _Refwrap_base_arg1 - { }; - - - template - struct _Refwrap_base_arg1<_Tp, - __void_t> - { - typedef typename _Tp::argument_type argument_type; - }; - - - template> - struct _Refwrap_base_arg2 - { }; - - - template - struct _Refwrap_base_arg2<_Tp, - __void_t> - { - typedef typename _Tp::first_argument_type first_argument_type; - typedef typename _Tp::second_argument_type second_argument_type; - }; - - - - - - - - template - struct _Reference_wrapper_base - : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> - { }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) volatile> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const volatile> - : unary_function<_T1, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> - : binary_function<_T1, _T2, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)> - : unary_function<_T1, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)> - : binary_function<_T1, _T2, _Res> - { }; - - template::value> - struct _Reference_wrapper_base_memfun - : _Reference_wrapper_base<_Tp> - { }; - - template - struct _Reference_wrapper_base_memfun<_MemFunPtr, true> - : _Mem_fn_traits<_MemFunPtr>::__maybe_type - { - using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; - }; -#pragma GCC diagnostic pop - - - - - - - - - template - class reference_wrapper - - - - : public _Reference_wrapper_base_memfun::type> - - { - _Tp* _M_data; - - - static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } - - static void _S_fun(_Tp&&) = delete; - - template> - using __not_same - = typename enable_if::value>::type; - - public: - typedef _Tp type; - - - - - template, typename - = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> - - reference_wrapper(_Up&& __uref) - noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) - : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) - { } - - reference_wrapper(const reference_wrapper&) = default; - - reference_wrapper& - operator=(const reference_wrapper&) = default; - - - operator _Tp&() const noexcept - { return this->get(); } - - - _Tp& - get() const noexcept - { return *_M_data; } - - template - - typename __invoke_result<_Tp&, _Args...>::type - operator()(_Args&&... __args) const - noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value) - { - - - - - return std::__invoke(get(), std::forward<_Args>(__args)...); - } - }; - - - template - reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; - - - - - - template - - inline reference_wrapper<_Tp> - ref(_Tp& __t) noexcept - { return reference_wrapper<_Tp>(__t); } - - - template - - inline reference_wrapper - cref(const _Tp& __t) noexcept - { return reference_wrapper(__t); } - - template - void ref(const _Tp&&) = delete; - - template - void cref(const _Tp&&) = delete; - - - template - - inline reference_wrapper<_Tp> - ref(reference_wrapper<_Tp> __t) noexcept - { return __t; } - - - template - - inline reference_wrapper - cref(reference_wrapper<_Tp> __t) noexcept - { return { __t.get() }; } - - - - -} -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - template - class initializer_list - { - public: - typedef _E value_type; - typedef const _E& reference; - typedef const _E& const_reference; - typedef size_t size_type; - typedef const _E* iterator; - typedef const _E* const_iterator; - - private: - iterator _M_array; - size_type _M_len; - - - constexpr initializer_list(const_iterator __a, size_type __l) - : _M_array(__a), _M_len(__l) { } - - public: - constexpr initializer_list() noexcept - : _M_array(0), _M_len(0) { } - - - constexpr size_type - size() const noexcept { return _M_len; } - - - constexpr const_iterator - begin() const noexcept { return _M_array; } - - - constexpr const_iterator - end() const noexcept { return begin() + size(); } - }; - - - - - - - - template - constexpr const _Tp* - begin(initializer_list<_Tp> __ils) noexcept - { return __ils.begin(); } - - - - - - - - template - constexpr const _Tp* - end(initializer_list<_Tp> __ils) noexcept - { return __ils.end(); } -} -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 2 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - begin(_Container& __cont) -> decltype(__cont.begin()) - { return __cont.begin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - begin(const _Container& __cont) -> decltype(__cont.begin()) - { return __cont.begin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - end(_Container& __cont) -> decltype(__cont.end()) - { return __cont.end(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - end(const _Container& __cont) -> decltype(__cont.end()) - { return __cont.end(); } - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr _Tp* - begin(_Tp (&__arr)[_Nm]) noexcept - { return __arr; } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr _Tp* - end(_Tp (&__arr)[_Nm]) noexcept - { return __arr + _Nm; } - - - - template class valarray; - - template _Tp* begin(valarray<_Tp>&) noexcept; - template const _Tp* begin(const valarray<_Tp>&) noexcept; - template _Tp* end(valarray<_Tp>&) noexcept; - template const _Tp* end(const valarray<_Tp>&) noexcept; - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - constexpr auto - cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) - -> decltype(std::begin(__cont)) - { return std::begin(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - constexpr auto - cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) - -> decltype(std::end(__cont)) - { return std::end(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rbegin(_Container& __cont) -> decltype(__cont.rbegin()) - { return __cont.rbegin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) - { return __cont.rbegin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rend(_Container& __cont) -> decltype(__cont.rend()) - { return __cont.rend(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rend(const _Container& __cont) -> decltype(__cont.rend()) - { return __cont.rend(); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Tp*> - rbegin(_Tp (&__arr)[_Nm]) noexcept - { return reverse_iterator<_Tp*>(__arr + _Nm); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Tp*> - rend(_Tp (&__arr)[_Nm]) noexcept - { return reverse_iterator<_Tp*>(__arr); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator - rbegin(initializer_list<_Tp> __il) noexcept - { return reverse_iterator(__il.end()); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator - rend(initializer_list<_Tp> __il) noexcept - { return reverse_iterator(__il.begin()); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) - { return std::rbegin(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - crend(const _Container& __cont) -> decltype(std::rend(__cont)) - { return std::rend(__cont); } -# 261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - size(const _Container& __cont) noexcept(noexcept(__cont.size())) - -> decltype(__cont.size()) - { return __cont.size(); } - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr size_t - size(const _Tp (&)[_Nm]) noexcept - { return _Nm; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) - -> decltype(__cont.empty()) - { return __cont.empty(); } - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr bool - empty(const _Tp (&)[_Nm]) noexcept - { return false; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr bool - empty(initializer_list<_Tp> __il) noexcept - { return __il.size() == 0;} - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - data(_Container& __cont) noexcept(noexcept(__cont.data())) - -> decltype(__cont.data()) - { return __cont.data(); } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - data(const _Container& __cont) noexcept(noexcept(__cont.data())) - -> decltype(__cont.data()) - { return __cont.data(); } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr _Tp* - data(_Tp (&__array)[_Nm]) noexcept - { return __array; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr const _Tp* - data(initializer_list<_Tp> __il) noexcept - { return __il.begin(); } -# 371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 -} -# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 1 3 -# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - inline void - destroy_at(_Tp* __location) - { - if constexpr (201703L > 201703L && is_array_v<_Tp>) - { - for (auto& __x : *__location) - std::destroy_at(std::__addressof(__x)); - } - else - __location->~_Tp(); - } -# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - template - - inline void - _Construct(_Tp* __p, _Args&&... __args) - { -# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); - } -# 132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - template - inline void - _Construct_novalue(_T1* __p) - { ::new((void*)__p) _T1; } - - template - void - _Destroy(_ForwardIterator __first, _ForwardIterator __last); - - - - - template - constexpr inline void - _Destroy(_Tp* __pointer) - { - - - - __pointer->~_Tp(); - - } - - template - struct _Destroy_aux - { - template - static void - __destroy(_ForwardIterator __first, _ForwardIterator __last) - { - for (; __first != __last; ++__first) - std::_Destroy(std::__addressof(*__first)); - } - }; - - template<> - struct _Destroy_aux - { - template - static void - __destroy(_ForwardIterator, _ForwardIterator) { } - }; - - - - - - - template - inline void - _Destroy(_ForwardIterator __first, _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _Value_type; - - - static_assert(is_destructible<_Value_type>::value, - "value type is destructible"); - - - - - - std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: - __destroy(__first, __last); - } - - template - struct _Destroy_n_aux - { - template - static _ForwardIterator - __destroy_n(_ForwardIterator __first, _Size __count) - { - for (; __count > 0; (void)++__first, --__count) - std::_Destroy(std::__addressof(*__first)); - return __first; - } - }; - - template<> - struct _Destroy_n_aux - { - template - static _ForwardIterator - __destroy_n(_ForwardIterator __first, _Size __count) - { - std::advance(__first, __count); - return __first; - } - }; - - - - - - - template - inline _ForwardIterator - _Destroy_n(_ForwardIterator __first, _Size __count) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _Value_type; - - - static_assert(is_destructible<_Value_type>::value, - "value type is destructible"); - - - - - - return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: - __destroy_n(__first, __count); - } - - - template - inline void - destroy(_ForwardIterator __first, _ForwardIterator __last) - { - std::_Destroy(__first, __last); - } - - template - inline _ForwardIterator - destroy_n(_ForwardIterator __first, _Size __count) - { - return std::_Destroy_n(__first, __count); - } - - - -} -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 2 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - struct __allocator_traits_base - { - template - struct __rebind : __replace_first_arg<_Tp, _Up> - { - static_assert(is_same< - typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, - _Tp>::value, - "allocator_traits::rebind_alloc must be A"); - }; - - template - struct __rebind<_Tp, _Up, - __void_t::other>> - { - using type = typename _Tp::template rebind<_Up>::other; - - static_assert(is_same< - typename _Tp::template rebind::other, - _Tp>::value, - "allocator_traits::rebind_alloc must be A"); - }; - - protected: - template - using __pointer = typename _Tp::pointer; - template - using __c_pointer = typename _Tp::const_pointer; - template - using __v_pointer = typename _Tp::void_pointer; - template - using __cv_pointer = typename _Tp::const_void_pointer; - template - using __pocca = typename _Tp::propagate_on_container_copy_assignment; - template - using __pocma = typename _Tp::propagate_on_container_move_assignment; - template - using __pocs = typename _Tp::propagate_on_container_swap; - template - using __equal = __type_identity; - }; - - template - using __alloc_rebind - = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; -# 104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct allocator_traits : __allocator_traits_base - { - - typedef _Alloc allocator_type; - - typedef typename _Alloc::value_type value_type; - - - - - - - using pointer = __detected_or_t; - - private: - - template class _Func, typename _Tp, typename = void> - struct _Ptr - { - using type = typename pointer_traits::template rebind<_Tp>; - }; - - template class _Func, typename _Tp> - struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> - { - using type = _Func<_Alloc>; - }; - - - template - struct _Diff - { using type = typename pointer_traits<_PtrT>::difference_type; }; - - template - struct _Diff<_A2, _PtrT, __void_t> - { using type = typename _A2::difference_type; }; - - - template - struct _Size : make_unsigned<_DiffT> { }; - - template - struct _Size<_A2, _DiffT, __void_t> - { using type = typename _A2::size_type; }; - - public: - - - - - - - using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; - - - - - - - - using void_pointer = typename _Ptr<__v_pointer, void>::type; - - - - - - - - using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; - - - - - - - - using difference_type = typename _Diff<_Alloc, pointer>::type; - - - - - - - - using size_type = typename _Size<_Alloc, difference_type>::type; - - - - - - - - using propagate_on_container_copy_assignment - = __detected_or_t; - - - - - - - - using propagate_on_container_move_assignment - = __detected_or_t; - - - - - - - - using propagate_on_container_swap - = __detected_or_t; - - - - - - - - using is_always_equal - = typename __detected_or_t, __equal, _Alloc>::type; - - template - using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; - template - using rebind_traits = allocator_traits>; - - private: - template - static constexpr auto - _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) - -> decltype(__a.allocate(__n, __hint)) - { return __a.allocate(__n, __hint); } - - template - static constexpr pointer - _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) - { return __a.allocate(__n); } - - template - struct __construct_helper - { - template()->construct( - std::declval<_Tp*>(), std::declval<_Args>()...))> - static true_type __test(int); - - template - static false_type __test(...); - - using type = decltype(__test<_Alloc>(0)); - }; - - template - using __has_construct - = typename __construct_helper<_Tp, _Args...>::type; - - template - static constexpr _Require<__has_construct<_Tp, _Args...>> - _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) - noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) - { __a.construct(__p, std::forward<_Args>(__args)...); } - - template - static constexpr - _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, - is_constructible<_Tp, _Args...>>> - _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) - { - - ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); - - - - } - - template - static constexpr auto - _S_destroy(_Alloc2& __a, _Tp* __p, int) - noexcept(noexcept(__a.destroy(__p))) - -> decltype(__a.destroy(__p)) - { __a.destroy(__p); } - - template - static constexpr void - _S_destroy(_Alloc2&, _Tp* __p, ...) - noexcept(std::is_nothrow_destructible<_Tp>::value) - { std::_Destroy(__p); } - - template - static constexpr auto - _S_max_size(_Alloc2& __a, int) - -> decltype(__a.max_size()) - { return __a.max_size(); } - - template - static constexpr size_type - _S_max_size(_Alloc2&, ...) - { - - - return __gnu_cxx::__numeric_traits::__max - / sizeof(value_type); - } - - template - static constexpr auto - _S_select(_Alloc2& __a, int) - -> decltype(__a.select_on_container_copy_construction()) - { return __a.select_on_container_copy_construction(); } - - template - static constexpr _Alloc2 - _S_select(_Alloc2& __a, ...) - { return __a; } - - public: -# 331 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__]] static pointer - allocate(_Alloc& __a, size_type __n) - { return __a.allocate(__n); } -# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__]] static pointer - allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) - { return _S_allocate(__a, __n, __hint, 0); } -# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static void - deallocate(_Alloc& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 373 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - static auto - construct(_Alloc& __a, _Tp* __p, _Args&&... __args) - noexcept(noexcept(_S_construct(__a, __p, - std::forward<_Args>(__args)...))) - -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) - { _S_construct(__a, __p, std::forward<_Args>(__args)...); } -# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - static void - destroy(_Alloc& __a, _Tp* __p) - noexcept(noexcept(_S_destroy(__a, __p, 0))) - { _S_destroy(__a, __p, 0); } -# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static size_type - max_size(const _Alloc& __a) noexcept - { return _S_max_size(__a, 0); } -# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static _Alloc - select_on_container_copy_construction(const _Alloc& __rhs) - { return _S_select(__rhs, 0); } - }; -# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct allocator_traits> - { - - using allocator_type = allocator<_Tp>; - - - using value_type = _Tp; - - - using pointer = _Tp*; - - - using const_pointer = const _Tp*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - using propagate_on_container_copy_assignment = false_type; - - - using propagate_on_container_move_assignment = true_type; - - - using propagate_on_container_swap = false_type; - - - using is_always_equal = true_type; - - template - using rebind_alloc = allocator<_Up>; - - template - using rebind_traits = allocator_traits>; -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__,__gnu__::__always_inline__]] - static pointer - allocate(allocator_type& __a, size_type __n) - { return __a.allocate(__n); } -# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__,__gnu__::__always_inline__]] - static pointer - allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) - { - - return __a.allocate(__n, __hint); - - - - } -# 513 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__gnu__::__always_inline__]] - static void - deallocate(allocator_type& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, - _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { - - __a.construct(__p, std::forward<_Args>(__args)...); - - - - } -# 550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { - - __a.destroy(__p); - - - - } - - - - - - - [[__gnu__::__always_inline__]] - static size_type - max_size(const allocator_type& __a __attribute__((__unused__))) noexcept - { - - return __a.max_size(); - - - - } - - - - - - - [[__gnu__::__always_inline__]] - static allocator_type - select_on_container_copy_construction(const allocator_type& __rhs) - { return __rhs; } - }; - - - template<> - struct allocator_traits> - { - - using allocator_type = allocator; - - - using value_type = void; - - - using pointer = void*; - - - using const_pointer = const void*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - using propagate_on_container_copy_assignment = false_type; - - - using propagate_on_container_move_assignment = true_type; - - - using propagate_on_container_swap = false_type; - - - using is_always_equal = true_type; - - template - using rebind_alloc = allocator<_Up>; - - template - using rebind_traits = allocator_traits>; - - - static void* - allocate(allocator_type&, size_type, const void* = nullptr) = delete; - - - static void - deallocate(allocator_type&, void*, size_type) = delete; -# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - construct(allocator_type&, _Up* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { std::_Construct(__p, std::forward<_Args>(__args)...); } -# 669 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - destroy(allocator_type&, _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { std::_Destroy(__p); } - - - static size_type - max_size(const allocator_type&) = delete; - - - - - - - [[__gnu__::__always_inline__]] - static allocator_type - select_on_container_copy_construction(const allocator_type& __rhs) - { return __rhs; } - }; -# 707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_copy(_Alloc& __one, const _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocca = - typename __traits::propagate_on_container_copy_assignment::type; - - if constexpr (__pocca::value) - __one = __two; - - - - } - - template - [[__gnu__::__always_inline__]] - constexpr _Alloc - __alloc_on_copy(const _Alloc& __a) - { - typedef allocator_traits<_Alloc> __traits; - return __traits::select_on_container_copy_construction(__a); - } -# 744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_move(_Alloc& __one, _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocma - = typename __traits::propagate_on_container_move_assignment::type; - - if constexpr (__pocma::value) - __one = std::move(__two); - - - - } -# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_swap(_Alloc& __one, _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocs = typename __traits::propagate_on_container_swap::type; - - if constexpr (__pocs::value) - { - using std::swap; - swap(__one, __two); - } - - - - } - - template, - typename = void> - struct __is_alloc_insertable_impl - : false_type - { }; - - template - struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, - __void_t::construct( - std::declval<_Alloc&>(), std::declval<_ValueT*>(), - std::declval<_Tp>()))>> - : true_type - { }; - - - - - template - struct __is_copy_insertable - : __is_alloc_insertable_impl<_Alloc, - typename _Alloc::value_type const&>::type - { }; - - - - template - struct __is_copy_insertable> - : is_copy_constructible<_Tp> - { }; - - - - - - template - struct __is_move_insertable - : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type - { }; - - - - template - struct __is_move_insertable> - : is_move_constructible<_Tp> - { }; - - - - template - struct __is_allocator : false_type { }; - - template - struct __is_allocator<_Alloc, - __void_t().allocate(size_t{}))>> - : true_type { }; - - template - using _RequireAllocator - = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; - - template - using _RequireNotAllocator - = typename enable_if::value, _Alloc>::type; -# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct __alloc_swap - { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; - - template - struct __alloc_swap<_Alloc, false> - { - static void - _S_do_it(_Alloc& __one, _Alloc& __two) noexcept - { - - if (__one != __two) - swap(__one, __two); - } - }; - - - template, - is_nothrow_move_constructible>::value> - struct __shrink_to_fit_aux - { static bool _S_do_it(_Tp&) noexcept { return false; } }; - - template - struct __shrink_to_fit_aux<_Tp, true> - { - - static bool - _S_do_it(_Tp& __c) noexcept - { - - try - { - _Tp(__make_move_if_noexcept_iterator(__c.begin()), - __make_move_if_noexcept_iterator(__c.end()), - __c.get_allocator()).swap(__c); - return true; - } - catch(...) - { return false; } - - - - } - }; -# 925 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - - void - _Destroy(_ForwardIterator __first, _ForwardIterator __last, - _Allocator& __alloc) - { - for (; __first != __last; ++__first) - - - - allocator_traits<_Allocator>::destroy(__alloc, - std::__addressof(*__first)); - - } - - - template - __attribute__((__always_inline__)) - inline void - _Destroy(_ForwardIterator __first, _ForwardIterator __last, - allocator<_Tp>&) - { - std::_Destroy(__first, __last); - } - - - - -} -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 2 3 - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - - - -template - struct __alloc_traits - - : std::allocator_traits<_Alloc> - - { - typedef _Alloc allocator_type; - - typedef std::allocator_traits<_Alloc> _Base_type; - typedef typename _Base_type::value_type value_type; - typedef typename _Base_type::pointer pointer; - typedef typename _Base_type::const_pointer const_pointer; - typedef typename _Base_type::size_type size_type; - typedef typename _Base_type::difference_type difference_type; - - typedef value_type& reference; - typedef const value_type& const_reference; - using _Base_type::allocate; - using _Base_type::deallocate; - using _Base_type::construct; - using _Base_type::destroy; - using _Base_type::max_size; - - private: - template - using __is_custom_pointer - = std::__and_, - std::__not_>>; - - public: - - template - [[__gnu__::__always_inline__]] - static constexpr - std::__enable_if_t<__is_custom_pointer<_Ptr>::value> - construct(_Alloc& __a, _Ptr __p, _Args&&... __args) - noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), - std::forward<_Args>(__args)...))) - { - _Base_type::construct(__a, std::__to_address(__p), - std::forward<_Args>(__args)...); - } - - - template - [[__gnu__::__always_inline__]] - static constexpr - std::__enable_if_t<__is_custom_pointer<_Ptr>::value> - destroy(_Alloc& __a, _Ptr __p) - noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) - { _Base_type::destroy(__a, std::__to_address(__p)); } - - [[__gnu__::__always_inline__]] - static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) - { return _Base_type::select_on_container_copy_construction(__a); } - - [[__gnu__::__always_inline__]] - static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) - { std::__alloc_on_swap(__a, __b); } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_copy_assign() - { return _Base_type::propagate_on_container_copy_assignment::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_move_assign() - { return _Base_type::propagate_on_container_move_assignment::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_swap() - { return _Base_type::propagate_on_container_swap::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_always_equal() - { return _Base_type::is_always_equal::value; } - - __attribute__((__always_inline__)) - static constexpr bool _S_nothrow_move() - { return _S_propagate_on_move_assign() || _S_always_equal(); } - - template - struct rebind - { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; -# 180 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 - }; - - -} -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 2 3 - - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template - struct __hash_base - { - typedef _Result result_type [[__deprecated__]]; - typedef _Arg argument_type [[__deprecated__]]; - }; - - - template - struct hash; - - template - struct __poison_hash - { - static constexpr bool __enable_hash_call = false; - private: - - __poison_hash(__poison_hash&&); - ~__poison_hash(); - }; - - template - struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> - { - static constexpr bool __enable_hash_call = true; - }; - - - template::value> - struct __hash_enum - { - private: - - __hash_enum(__hash_enum&&); - ~__hash_enum(); - }; - - - template - struct __hash_enum<_Tp, true> : public __hash_base - { - size_t - operator()(_Tp __val) const noexcept - { - using __type = typename underlying_type<_Tp>::type; - return hash<__type>{}(static_cast<__type>(__val)); - } - }; - - - - template - struct hash : __hash_enum<_Tp> - { }; - - - template - struct hash<_Tp*> : public __hash_base - { - size_t - operator()(_Tp* __p) const noexcept - { return reinterpret_cast(__p); } - }; -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; - - - - - - - - template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; -# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - struct _Hash_impl - { - static size_t - hash(const void* __ptr, size_t __clength, - size_t __seed = static_cast(0xc70f6907UL)) - { return _Hash_bytes(__ptr, __clength, __seed); } - - template - static size_t - hash(const _Tp& __val) - { return hash(&__val, sizeof(__val)); } - - template - static size_t - __hash_combine(const _Tp& __val, size_t __hash) - { return hash(&__val, sizeof(__val), __hash); } - }; - - - struct _Fnv_hash_impl - { - static size_t - hash(const void* __ptr, size_t __clength, - size_t __seed = static_cast(2166136261UL)) - { return _Fnv_hash_bytes(__ptr, __clength, __seed); } - - template - static size_t - hash(const _Tp& __val) - { return hash(&__val, sizeof(__val)); } - - template - static size_t - __hash_combine(const _Tp& __val, size_t __hash) - { return hash(&__val, sizeof(__val), __hash); } - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(float __val) const noexcept - { - - return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; - } - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(double __val) const noexcept - { - - return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; - } - }; - - - template<> - struct hash - : public __hash_base - { - __attribute__ ((__pure__)) size_t - operator()(long double __val) const noexcept; - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(nullptr_t) const noexcept - { return 0; } - }; -# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template - struct __is_fast_hash : public std::true_type - { }; - - template<> - struct __is_fast_hash> : public std::false_type - { }; - - -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 2 3 -# 56 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 69 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 - constexpr size_t - __sv_check(size_t __size, size_t __pos, const char* __s) - { - if (__pos > __size) - __throw_out_of_range_fmt(("%s: __pos (which is %zu) > __size " "(which is %zu)"), __s, __pos, __size); - - return __pos; - } - - - - constexpr size_t - __sv_limit(size_t __size, size_t __pos, size_t __off) noexcept - { - const bool __testoff = __off < __size - __pos; - return __testoff ? __off : __size - __pos; - } -# 105 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 - template> - class basic_string_view - { - static_assert(!is_array_v<_CharT>); - static_assert(is_trivial_v<_CharT> && is_standard_layout_v<_CharT>); - static_assert(is_same_v<_CharT, typename _Traits::char_type>); - - public: - - - using traits_type = _Traits; - using value_type = _CharT; - using pointer = value_type*; - using const_pointer = const value_type*; - using reference = value_type&; - using const_reference = const value_type&; - using const_iterator = const value_type*; - using iterator = const_iterator; - using const_reverse_iterator = std::reverse_iterator; - using reverse_iterator = const_reverse_iterator; - using size_type = size_t; - using difference_type = ptrdiff_t; - static constexpr size_type npos = size_type(-1); - - - - constexpr - basic_string_view() noexcept - : _M_len{0}, _M_str{nullptr} - { } - - constexpr basic_string_view(const basic_string_view&) noexcept = default; - - [[__gnu__::__nonnull__]] - constexpr - basic_string_view(const _CharT* __str) noexcept - : _M_len{traits_type::length(__str)}, - _M_str{__str} - { } - - constexpr - basic_string_view(const _CharT* __str, size_type __len) noexcept - : _M_len{__len}, _M_str{__str} - { } -# 182 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 - constexpr basic_string_view& - operator=(const basic_string_view&) noexcept = default; - - - - [[nodiscard]] - constexpr const_iterator - begin() const noexcept - { return this->_M_str; } - - [[nodiscard]] - constexpr const_iterator - end() const noexcept - { return this->_M_str + this->_M_len; } - - [[nodiscard]] - constexpr const_iterator - cbegin() const noexcept - { return this->_M_str; } - - [[nodiscard]] - constexpr const_iterator - cend() const noexcept - { return this->_M_str + this->_M_len; } - - [[nodiscard]] - constexpr const_reverse_iterator - rbegin() const noexcept - { return const_reverse_iterator(this->end()); } - - [[nodiscard]] - constexpr const_reverse_iterator - rend() const noexcept - { return const_reverse_iterator(this->begin()); } - - [[nodiscard]] - constexpr const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(this->end()); } - - [[nodiscard]] - constexpr const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(this->begin()); } - - - - [[nodiscard]] - constexpr size_type - size() const noexcept - { return this->_M_len; } - - [[nodiscard]] - constexpr size_type - length() const noexcept - { return _M_len; } - - [[nodiscard]] - constexpr size_type - max_size() const noexcept - { - return (npos - sizeof(size_type) - sizeof(void*)) - / sizeof(value_type) / 4; - } - - [[nodiscard]] - constexpr bool - empty() const noexcept - { return this->_M_len == 0; } - - - - [[nodiscard]] - constexpr const_reference - operator[](size_type __pos) const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__pos < this->_M_len)) __builtin_unreachable(); } while (false); - return *(this->_M_str + __pos); - } - - [[nodiscard]] - constexpr const_reference - at(size_type __pos) const - { - if (__pos >= _M_len) - __throw_out_of_range_fmt(("basic_string_view::at: __pos " "(which is %zu) >= this->size() " "(which is %zu)"), __pos, this->size()); - - - return *(this->_M_str + __pos); - } - - [[nodiscard]] - constexpr const_reference - front() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(this->_M_len > 0)) __builtin_unreachable(); } while (false); - return *this->_M_str; - } - - [[nodiscard]] - constexpr const_reference - back() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(this->_M_len > 0)) __builtin_unreachable(); } while (false); - return *(this->_M_str + this->_M_len - 1); - } - - [[nodiscard]] - constexpr const_pointer - data() const noexcept - { return this->_M_str; } - - - - constexpr void - remove_prefix(size_type __n) noexcept - { - do { if (std::__is_constant_evaluated() && !bool(this->_M_len >= __n)) __builtin_unreachable(); } while (false); - this->_M_str += __n; - this->_M_len -= __n; - } - - constexpr void - remove_suffix(size_type __n) noexcept - { this->_M_len -= __n; } - - constexpr void - swap(basic_string_view& __sv) noexcept - { - auto __tmp = *this; - *this = __sv; - __sv = __tmp; - } - - - - - size_type - copy(_CharT* __str, size_type __n, size_type __pos = 0) const - { - ; - __pos = std::__sv_check(size(), __pos, "basic_string_view::copy"); - const size_type __rlen = std::min(__n, _M_len - __pos); - - - traits_type::copy(__str, data() + __pos, __rlen); - return __rlen; - } - - [[nodiscard]] - constexpr basic_string_view - substr(size_type __pos = 0, size_type __n = npos) const noexcept(false) - { - __pos = std::__sv_check(size(), __pos, "basic_string_view::substr"); - const size_type __rlen = std::min(__n, _M_len - __pos); - return basic_string_view{_M_str + __pos, __rlen}; - } - - [[nodiscard]] - constexpr int - compare(basic_string_view __str) const noexcept - { - const size_type __rlen = std::min(this->_M_len, __str._M_len); - int __ret = traits_type::compare(this->_M_str, __str._M_str, __rlen); - if (__ret == 0) - __ret = _S_compare(this->_M_len, __str._M_len); - return __ret; - } - - [[nodiscard]] - constexpr int - compare(size_type __pos1, size_type __n1, basic_string_view __str) const - { return this->substr(__pos1, __n1).compare(__str); } - - [[nodiscard]] - constexpr int - compare(size_type __pos1, size_type __n1, - basic_string_view __str, size_type __pos2, size_type __n2) const - { - return this->substr(__pos1, __n1).compare(__str.substr(__pos2, __n2)); - } - - [[nodiscard, __gnu__::__nonnull__]] - constexpr int - compare(const _CharT* __str) const noexcept - { return this->compare(basic_string_view{__str}); } - - [[nodiscard, __gnu__::__nonnull__]] - constexpr int - compare(size_type __pos1, size_type __n1, const _CharT* __str) const - { return this->substr(__pos1, __n1).compare(basic_string_view{__str}); } - - [[nodiscard]] - constexpr int - compare(size_type __pos1, size_type __n1, - const _CharT* __str, size_type __n2) const noexcept(false) - { - return this->substr(__pos1, __n1) - .compare(basic_string_view(__str, __n2)); - } -# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 - [[nodiscard]] - constexpr size_type - find(basic_string_view __str, size_type __pos = 0) const noexcept - { return this->find(__str._M_str, __pos, __str._M_len); } - - [[nodiscard]] - constexpr size_type - find(_CharT __c, size_type __pos = 0) const noexcept; - - [[nodiscard]] - constexpr size_type - find(const _CharT* __str, size_type __pos, size_type __n) const noexcept; - - [[nodiscard, __gnu__::__nonnull__]] - constexpr size_type - find(const _CharT* __str, size_type __pos = 0) const noexcept - { return this->find(__str, __pos, traits_type::length(__str)); } - - [[nodiscard]] - constexpr size_type - rfind(basic_string_view __str, size_type __pos = npos) const noexcept - { return this->rfind(__str._M_str, __pos, __str._M_len); } - - [[nodiscard]] - constexpr size_type - rfind(_CharT __c, size_type __pos = npos) const noexcept; - - [[nodiscard]] - constexpr size_type - rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept; - - [[nodiscard, __gnu__::__nonnull__]] - constexpr size_type - rfind(const _CharT* __str, size_type __pos = npos) const noexcept - { return this->rfind(__str, __pos, traits_type::length(__str)); } - - [[nodiscard]] - constexpr size_type - find_first_of(basic_string_view __str, size_type __pos = 0) const noexcept - { return this->find_first_of(__str._M_str, __pos, __str._M_len); } - - [[nodiscard]] - constexpr size_type - find_first_of(_CharT __c, size_type __pos = 0) const noexcept - { return this->find(__c, __pos); } - - [[nodiscard]] - constexpr size_type - find_first_of(const _CharT* __str, size_type __pos, - size_type __n) const noexcept; - - [[nodiscard, __gnu__::__nonnull__]] - constexpr size_type - find_first_of(const _CharT* __str, size_type __pos = 0) const noexcept - { return this->find_first_of(__str, __pos, traits_type::length(__str)); } - - [[nodiscard]] - constexpr size_type - find_last_of(basic_string_view __str, - size_type __pos = npos) const noexcept - { return this->find_last_of(__str._M_str, __pos, __str._M_len); } - - [[nodiscard]] - constexpr size_type - find_last_of(_CharT __c, size_type __pos=npos) const noexcept - { return this->rfind(__c, __pos); } - - [[nodiscard]] - constexpr size_type - find_last_of(const _CharT* __str, size_type __pos, - size_type __n) const noexcept; - - [[nodiscard, __gnu__::__nonnull__]] - constexpr size_type - find_last_of(const _CharT* __str, size_type __pos = npos) const noexcept - { return this->find_last_of(__str, __pos, traits_type::length(__str)); } - - [[nodiscard]] - constexpr size_type - find_first_not_of(basic_string_view __str, - size_type __pos = 0) const noexcept - { return this->find_first_not_of(__str._M_str, __pos, __str._M_len); } - - [[nodiscard]] - constexpr size_type - find_first_not_of(_CharT __c, size_type __pos = 0) const noexcept; - - [[nodiscard]] - constexpr size_type - find_first_not_of(const _CharT* __str, - size_type __pos, size_type __n) const noexcept; - - [[nodiscard, __gnu__::__nonnull__]] - constexpr size_type - find_first_not_of(const _CharT* __str, size_type __pos = 0) const noexcept - { - return this->find_first_not_of(__str, __pos, - traits_type::length(__str)); - } - - [[nodiscard]] - constexpr size_type - find_last_not_of(basic_string_view __str, - size_type __pos = npos) const noexcept - { return this->find_last_not_of(__str._M_str, __pos, __str._M_len); } - - [[nodiscard]] - constexpr size_type - find_last_not_of(_CharT __c, size_type __pos = npos) const noexcept; - - [[nodiscard]] - constexpr size_type - find_last_not_of(const _CharT* __str, - size_type __pos, size_type __n) const noexcept; - - [[nodiscard, __gnu__::__nonnull__]] - constexpr size_type - find_last_not_of(const _CharT* __str, - size_type __pos = npos) const noexcept - { - return this->find_last_not_of(__str, __pos, - traits_type::length(__str)); - } - - private: - - static constexpr int - _S_compare(size_type __n1, size_type __n2) noexcept - { - using __limits = __gnu_cxx::__int_traits; - const difference_type __diff = __n1 - __n2; - if (__diff > __limits::__max) - return __limits::__max; - if (__diff < __limits::__min) - return __limits::__min; - return static_cast(__diff); - } - - size_t _M_len; - const _CharT* _M_str; - }; -# 605 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 - template - [[nodiscard]] - constexpr bool - operator==(basic_string_view<_CharT, _Traits> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.size() == __y.size() && __x.compare(__y) == 0; } - - template - [[nodiscard]] - constexpr bool - operator==(basic_string_view<_CharT, _Traits> __x, - __type_identity_t> __y) - noexcept - { return __x.size() == __y.size() && __x.compare(__y) == 0; } -# 638 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 - template - [[nodiscard]] - constexpr bool - operator==(__type_identity_t> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.size() == __y.size() && __x.compare(__y) == 0; } - - template - [[nodiscard]] - constexpr bool - operator!=(basic_string_view<_CharT, _Traits> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return !(__x == __y); } - - template - [[nodiscard]] - constexpr bool - operator!=(basic_string_view<_CharT, _Traits> __x, - __type_identity_t> __y) - noexcept - { return !(__x == __y); } - - template - [[nodiscard]] - constexpr bool - operator!=(__type_identity_t> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return !(__x == __y); } - - template - [[nodiscard]] - constexpr bool - operator< (basic_string_view<_CharT, _Traits> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.compare(__y) < 0; } - - template - [[nodiscard]] - constexpr bool - operator< (basic_string_view<_CharT, _Traits> __x, - __type_identity_t> __y) - noexcept - { return __x.compare(__y) < 0; } - - template - [[nodiscard]] - constexpr bool - operator< (__type_identity_t> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.compare(__y) < 0; } - - template - [[nodiscard]] - constexpr bool - operator> (basic_string_view<_CharT, _Traits> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.compare(__y) > 0; } - - template - [[nodiscard]] - constexpr bool - operator> (basic_string_view<_CharT, _Traits> __x, - __type_identity_t> __y) - noexcept - { return __x.compare(__y) > 0; } - - template - [[nodiscard]] - constexpr bool - operator> (__type_identity_t> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.compare(__y) > 0; } - - template - [[nodiscard]] - constexpr bool - operator<=(basic_string_view<_CharT, _Traits> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.compare(__y) <= 0; } - - template - [[nodiscard]] - constexpr bool - operator<=(basic_string_view<_CharT, _Traits> __x, - __type_identity_t> __y) - noexcept - { return __x.compare(__y) <= 0; } - - template - [[nodiscard]] - constexpr bool - operator<=(__type_identity_t> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.compare(__y) <= 0; } - - template - [[nodiscard]] - constexpr bool - operator>=(basic_string_view<_CharT, _Traits> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.compare(__y) >= 0; } - - template - [[nodiscard]] - constexpr bool - operator>=(basic_string_view<_CharT, _Traits> __x, - __type_identity_t> __y) - noexcept - { return __x.compare(__y) >= 0; } - - template - [[nodiscard]] - constexpr bool - operator>=(__type_identity_t> __x, - basic_string_view<_CharT, _Traits> __y) noexcept - { return __x.compare(__y) >= 0; } - - - - - template - inline basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - basic_string_view<_CharT,_Traits> __str) - { return __ostream_insert(__os, __str.data(), __str.size()); } - - - - - using string_view = basic_string_view; - using wstring_view = basic_string_view; - - - - using u16string_view = basic_string_view; - using u32string_view = basic_string_view; - - - - template - struct hash; - - template<> - struct hash - : public __hash_base - { - [[nodiscard]] - size_t - operator()(const string_view& __str) const noexcept - { return std::_Hash_impl::hash(__str.data(), __str.length()); } - }; - - template<> - struct __is_fast_hash> : std::false_type - { }; - - template<> - struct hash - : public __hash_base - { - [[nodiscard]] - size_t - operator()(const wstring_view& __s) const noexcept - { return std::_Hash_impl::hash(__s.data(), - __s.length() * sizeof(wchar_t)); } - }; - - template<> - struct __is_fast_hash> : std::false_type - { }; -# 825 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 - template<> - struct hash - : public __hash_base - { - [[nodiscard]] - size_t - operator()(const u16string_view& __s) const noexcept - { return std::_Hash_impl::hash(__s.data(), - __s.length() * sizeof(char16_t)); } - }; - - template<> - struct __is_fast_hash> : std::false_type - { }; - - template<> - struct hash - : public __hash_base - { - [[nodiscard]] - size_t - operator()(const u32string_view& __s) const noexcept - { return std::_Hash_impl::hash(__s.data(), - __s.length() * sizeof(char32_t)); } - }; - - template<> - struct __is_fast_hash> : std::false_type - { }; - - inline namespace literals - { - inline namespace string_view_literals - { -#pragma GCC diagnostic push - - inline constexpr basic_string_view - operator""sv(const char* __str, size_t __len) noexcept - { return basic_string_view{__str, __len}; } - - inline constexpr basic_string_view - operator""sv(const wchar_t* __str, size_t __len) noexcept - { return basic_string_view{__str, __len}; } - - - - - - - - inline constexpr basic_string_view - operator""sv(const char16_t* __str, size_t __len) noexcept - { return basic_string_view{__str, __len}; } - - inline constexpr basic_string_view - operator""sv(const char32_t* __str, size_t __len) noexcept - { return basic_string_view{__str, __len}; } - -#pragma GCC diagnostic pop - } - } -# 902 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 3 -} - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/string_view.tcc" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/string_view.tcc" 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - find(const _CharT* __str, size_type __pos, size_type __n) const noexcept - { - ; - - if (__n == 0) - return __pos <= _M_len ? __pos : npos; - if (__pos >= _M_len) - return npos; - - const _CharT __elem0 = __str[0]; - const _CharT* __first = _M_str + __pos; - const _CharT* const __last = _M_str + _M_len; - size_type __len = _M_len - __pos; - - while (__len >= __n) - { - - __first = traits_type::find(__first, __len - __n + 1, __elem0); - if (!__first) - return npos; - - - - if (traits_type::compare(__first, __str, __n) == 0) - return __first - _M_str; - __len = __last - ++__first; - } - return npos; - } - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - find(_CharT __c, size_type __pos) const noexcept - { - size_type __ret = npos; - if (__pos < this->_M_len) - { - const size_type __n = this->_M_len - __pos; - const _CharT* __p = traits_type::find(this->_M_str + __pos, __n, __c); - if (__p) - __ret = __p - this->_M_str; - } - return __ret; - } - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - rfind(const _CharT* __str, size_type __pos, size_type __n) const noexcept - { - ; - - if (__n <= this->_M_len) - { - __pos = std::min(size_type(this->_M_len - __n), __pos); - do - { - if (traits_type::compare(this->_M_str + __pos, __str, __n) == 0) - return __pos; - } - while (__pos-- > 0); - } - return npos; - } - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - rfind(_CharT __c, size_type __pos) const noexcept - { - size_type __size = this->_M_len; - if (__size > 0) - { - if (--__size > __pos) - __size = __pos; - for (++__size; __size-- > 0; ) - if (traits_type::eq(this->_M_str[__size], __c)) - return __size; - } - return npos; - } - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - find_first_of(const _CharT* __str, size_type __pos, - size_type __n) const noexcept - { - ; - for (; __n && __pos < this->_M_len; ++__pos) - { - const _CharT* __p = traits_type::find(__str, __n, - this->_M_str[__pos]); - if (__p) - return __pos; - } - return npos; - } - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - find_last_of(const _CharT* __str, size_type __pos, - size_type __n) const noexcept - { - ; - size_type __size = this->size(); - if (__size && __n) - { - if (--__size > __pos) - __size = __pos; - do - { - if (traits_type::find(__str, __n, this->_M_str[__size])) - return __size; - } - while (__size-- != 0); - } - return npos; - } - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - find_first_not_of(const _CharT* __str, size_type __pos, - size_type __n) const noexcept - { - ; - for (; __pos < this->_M_len; ++__pos) - if (!traits_type::find(__str, __n, this->_M_str[__pos])) - return __pos; - return npos; - } - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - find_first_not_of(_CharT __c, size_type __pos) const noexcept - { - for (; __pos < this->_M_len; ++__pos) - if (!traits_type::eq(this->_M_str[__pos], __c)) - return __pos; - return npos; - } - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - find_last_not_of(const _CharT* __str, size_type __pos, - size_type __n) const noexcept - { - ; - size_type __size = this->_M_len; - if (__size) - { - if (--__size > __pos) - __size = __pos; - do - { - if (!traits_type::find(__str, __n, this->_M_str[__size])) - return __size; - } - while (__size--); - } - return npos; - } - - template - constexpr typename basic_string_view<_CharT, _Traits>::size_type - basic_string_view<_CharT, _Traits>:: - find_last_not_of(_CharT __c, size_type __pos) const noexcept - { - size_type __size = this->_M_len; - if (__size) - { - if (--__size > __pos) - __size = __pos; - do - { - if (!traits_type::eq(this->_M_str[__size], __c)) - return __size; - } - while (__size--); - } - return npos; - } - - -} -# 905 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string_view" 2 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 2 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - -namespace __cxx11 { -# 86 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - class basic_string - { - typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template - rebind<_CharT>::other _Char_alloc_type; - - typedef __gnu_cxx::__alloc_traits<_Char_alloc_type> _Alloc_traits; - - - public: - typedef _Traits traits_type; - typedef typename _Traits::char_type value_type; - typedef _Char_alloc_type allocator_type; - typedef typename _Alloc_traits::size_type size_type; - typedef typename _Alloc_traits::difference_type difference_type; - typedef typename _Alloc_traits::reference reference; - typedef typename _Alloc_traits::const_reference const_reference; - typedef typename _Alloc_traits::pointer pointer; - typedef typename _Alloc_traits::const_pointer const_pointer; - typedef __gnu_cxx::__normal_iterator iterator; - typedef __gnu_cxx::__normal_iterator - const_iterator; - typedef std::reverse_iterator const_reverse_iterator; - typedef std::reverse_iterator reverse_iterator; - - - static const size_type npos = static_cast(-1); - - protected: - - - - - typedef const_iterator __const_iterator; - - - private: - static pointer - _S_allocate(_Char_alloc_type& __a, size_type __n) - { - pointer __p = _Alloc_traits::allocate(__a, __n); -# 136 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - return __p; - } - - - - typedef basic_string_view<_CharT, _Traits> __sv_type; - - template - using _If_sv = enable_if_t< - __and_, - __not_>, - __not_>>::value, - _Res>; - - - - static __sv_type - _S_to_string_view(__sv_type __svt) noexcept - { return __svt; } - - - - - - struct __sv_wrapper - { - explicit - __sv_wrapper(__sv_type __sv) noexcept : _M_sv(__sv) { } - - __sv_type _M_sv; - }; -# 175 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - explicit - basic_string(__sv_wrapper __svw, const _Alloc& __a) - : basic_string(__svw._M_sv.data(), __svw._M_sv.size(), __a) { } - - - - struct _Alloc_hider : allocator_type - { - - - - - - _Alloc_hider(pointer __dat, const _Alloc& __a) - : allocator_type(__a), _M_p(__dat) { } - - - _Alloc_hider(pointer __dat, _Alloc&& __a = _Alloc()) - : allocator_type(std::move(__a)), _M_p(__dat) { } - - - pointer _M_p; - }; - - _Alloc_hider _M_dataplus; - size_type _M_string_length; - - enum { _S_local_capacity = 15 / sizeof(_CharT) }; - - union - { - _CharT _M_local_buf[_S_local_capacity + 1]; - size_type _M_allocated_capacity; - }; - - - void - _M_data(pointer __p) - { _M_dataplus._M_p = __p; } - - - void - _M_length(size_type __length) - { _M_string_length = __length; } - - - pointer - _M_data() const - { return _M_dataplus._M_p; } - - - pointer - _M_local_data() - { - - return std::pointer_traits::pointer_to(*_M_local_buf); - - - - } - - - const_pointer - _M_local_data() const - { - - return std::pointer_traits::pointer_to(*_M_local_buf); - - - - } - - - void - _M_capacity(size_type __capacity) - { _M_allocated_capacity = __capacity; } - - - void - _M_set_length(size_type __n) - { - _M_length(__n); - traits_type::assign(_M_data()[__n], _CharT()); - } - - - bool - _M_is_local() const - { - if (_M_data() == _M_local_data()) - { - if (_M_string_length > _S_local_capacity) - __builtin_unreachable(); - return true; - } - return false; - } - - - - pointer - _M_create(size_type&, size_type); - - - void - _M_dispose() - { - if (!_M_is_local()) - _M_destroy(_M_allocated_capacity); - } - - - void - _M_destroy(size_type __size) throw() - { _Alloc_traits::deallocate(_M_get_allocator(), _M_data(), __size + 1); } -# 316 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - void - _M_construct(_InIterator __beg, _InIterator __end, - std::input_iterator_tag); - - - - template - - void - _M_construct(_FwdIterator __beg, _FwdIterator __end, - std::forward_iterator_tag); - - - void - _M_construct(size_type __req, _CharT __c); - - - allocator_type& - _M_get_allocator() - { return _M_dataplus; } - - - const allocator_type& - _M_get_allocator() const - { return _M_dataplus; } - - - __attribute__((__always_inline__)) - constexpr - pointer - _M_use_local_data() noexcept - { - - - - - - return _M_local_data(); - } - - private: -# 375 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - size_type - _M_check(size_type __pos, const char* __s) const - { - if (__pos > this->size()) - __throw_out_of_range_fmt(("%s: __pos (which is %zu) > " "this->size() (which is %zu)"), - - __s, __pos, this->size()); - return __pos; - } - - - void - _M_check_length(size_type __n1, size_type __n2, const char* __s) const - { - if (this->max_size() - (this->size() - __n1) < __n2) - __throw_length_error((__s)); - } - - - - - size_type - _M_limit(size_type __pos, size_type __off) const noexcept - { - const bool __testoff = __off < this->size() - __pos; - return __testoff ? __off : this->size() - __pos; - } - - - bool - _M_disjunct(const _CharT* __s) const noexcept - { - return (less()(__s, _M_data()) - || less()(_M_data() + this->size(), __s)); - } - - - - - static void - _S_copy(_CharT* __d, const _CharT* __s, size_type __n) - { - if (__n == 1) - traits_type::assign(*__d, *__s); - else - traits_type::copy(__d, __s, __n); - } - - - static void - _S_move(_CharT* __d, const _CharT* __s, size_type __n) - { - if (__n == 1) - traits_type::assign(*__d, *__s); - else - traits_type::move(__d, __s, __n); - } - - - static void - _S_assign(_CharT* __d, size_type __n, _CharT __c) - { - if (__n == 1) - traits_type::assign(*__d, __c); - else - traits_type::assign(__d, __n, __c); - } - - - - template - - static void - _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) - { - for (; __k1 != __k2; ++__k1, (void)++__p) - traits_type::assign(*__p, *__k1); - } - - - static void - _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) noexcept - { _S_copy_chars(__p, __k1.base(), __k2.base()); } - - - static void - _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) - noexcept - { _S_copy_chars(__p, __k1.base(), __k2.base()); } - - - static void - _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) noexcept - { _S_copy(__p, __k1, __k2 - __k1); } - - - static void - _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) - noexcept - { _S_copy(__p, __k1, __k2 - __k1); } - - - static int - _S_compare(size_type __n1, size_type __n2) noexcept - { - const difference_type __d = difference_type(__n1 - __n2); - - if (__d > __gnu_cxx::__numeric_traits::__max) - return __gnu_cxx::__numeric_traits::__max; - else if (__d < __gnu_cxx::__numeric_traits::__min) - return __gnu_cxx::__numeric_traits::__min; - else - return int(__d); - } - - - void - _M_assign(const basic_string&); - - - void - _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, - size_type __len2); - - - void - _M_erase(size_type __pos, size_type __n); - - public: -# 512 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string() - noexcept(is_nothrow_default_constructible<_Alloc>::value) - : _M_dataplus(_M_local_data()) - { - _M_use_local_data(); - _M_set_length(0); - } - - - - - - explicit - basic_string(const _Alloc& __a) noexcept - : _M_dataplus(_M_local_data(), __a) - { - _M_use_local_data(); - _M_set_length(0); - } - - - - - - - basic_string(const basic_string& __str) - : _M_dataplus(_M_local_data(), - _Alloc_traits::_S_select_on_copy(__str._M_get_allocator())) - { - _M_construct(__str._M_data(), __str._M_data() + __str.length(), - std::forward_iterator_tag()); - } -# 554 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string(const basic_string& __str, size_type __pos, - const _Alloc& __a = _Alloc()) - : _M_dataplus(_M_local_data(), __a) - { - const _CharT* __start = __str._M_data() - + __str._M_check(__pos, "basic_string::basic_string"); - _M_construct(__start, __start + __str._M_limit(__pos, npos), - std::forward_iterator_tag()); - } -# 571 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string(const basic_string& __str, size_type __pos, - size_type __n) - : _M_dataplus(_M_local_data()) - { - const _CharT* __start = __str._M_data() - + __str._M_check(__pos, "basic_string::basic_string"); - _M_construct(__start, __start + __str._M_limit(__pos, __n), - std::forward_iterator_tag()); - } -# 589 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string(const basic_string& __str, size_type __pos, - size_type __n, const _Alloc& __a) - : _M_dataplus(_M_local_data(), __a) - { - const _CharT* __start - = __str._M_data() + __str._M_check(__pos, "string::string"); - _M_construct(__start, __start + __str._M_limit(__pos, __n), - std::forward_iterator_tag()); - } -# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string(const _CharT* __s, size_type __n, - const _Alloc& __a = _Alloc()) - : _M_dataplus(_M_local_data(), __a) - { - - if (__s == 0 && __n > 0) - std::__throw_logic_error(("basic_string: " "construction from null is not valid")); - - _M_construct(__s, __s + __n, std::forward_iterator_tag()); - } -# 628 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template> - - - basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()) - : _M_dataplus(_M_local_data(), __a) - { - - if (__s == 0) - std::__throw_logic_error(("basic_string: " "construction from null is not valid")); - - const _CharT* __end = __s + traits_type::length(__s); - _M_construct(__s, __end, forward_iterator_tag()); - } -# 651 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template> - - - basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()) - : _M_dataplus(_M_local_data(), __a) - { _M_construct(__n, __c); } -# 667 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string(basic_string&& __str) noexcept - : _M_dataplus(_M_local_data(), std::move(__str._M_get_allocator())) - { - if (__str._M_is_local()) - { - traits_type::copy(_M_local_buf, __str._M_local_buf, - __str.length() + 1); - } - else - { - _M_data(__str._M_data()); - _M_capacity(__str._M_allocated_capacity); - } - - - - - _M_length(__str.length()); - __str._M_data(__str._M_local_data()); - __str._M_set_length(0); - } - - - - - - - - basic_string(initializer_list<_CharT> __l, const _Alloc& __a = _Alloc()) - : _M_dataplus(_M_local_data(), __a) - { _M_construct(__l.begin(), __l.end(), std::forward_iterator_tag()); } - - - basic_string(const basic_string& __str, const _Alloc& __a) - : _M_dataplus(_M_local_data(), __a) - { _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); } - - - basic_string(basic_string&& __str, const _Alloc& __a) - noexcept(_Alloc_traits::_S_always_equal()) - : _M_dataplus(_M_local_data(), __a) - { - if (__str._M_is_local()) - { - traits_type::copy(_M_local_buf, __str._M_local_buf, - __str.length() + 1); - _M_length(__str.length()); - __str._M_set_length(0); - } - else if (_Alloc_traits::_S_always_equal() - || __str.get_allocator() == __a) - { - _M_data(__str._M_data()); - _M_length(__str.length()); - _M_capacity(__str._M_allocated_capacity); - __str._M_data(__str._M_local_buf); - __str._M_set_length(0); - } - else - _M_construct(__str.begin(), __str.end(), std::forward_iterator_tag()); - } -# 742 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template> - - - - - basic_string(_InputIterator __beg, _InputIterator __end, - const _Alloc& __a = _Alloc()) - : _M_dataplus(_M_local_data(), __a), _M_string_length(0) - { - - _M_construct(__beg, __end, std::__iterator_category(__beg)); - - - - - } -# 768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template>> - - basic_string(const _Tp& __t, size_type __pos, size_type __n, - const _Alloc& __a = _Alloc()) - : basic_string(_S_to_string_view(__t).substr(__pos, __n), __a) { } - - - - - - - template> - - explicit - basic_string(const _Tp& __t, const _Alloc& __a = _Alloc()) - : basic_string(__sv_wrapper(_S_to_string_view(__t)), __a) { } - - - - - - - ~basic_string() - { _M_dispose(); } - - - - - - - basic_string& - operator=(const basic_string& __str) - { - return this->assign(__str); - } - - - - - - - basic_string& - operator=(const _CharT* __s) - { return this->assign(__s); } -# 822 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - operator=(_CharT __c) - { - this->assign(1, __c); - return *this; - } -# 840 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - operator=(basic_string&& __str) - noexcept(_Alloc_traits::_S_nothrow_move()) - { - const bool __equal_allocs = _Alloc_traits::_S_always_equal() - || _M_get_allocator() == __str._M_get_allocator(); - if (!_M_is_local() && _Alloc_traits::_S_propagate_on_move_assign() - && !__equal_allocs) - { - - _M_destroy(_M_allocated_capacity); - _M_data(_M_local_data()); - _M_set_length(0); - } - - std::__alloc_on_move(_M_get_allocator(), __str._M_get_allocator()); - - if (__str._M_is_local()) - { - - - - if (__builtin_expect(std::__addressof(__str) != this, true)) - { - if (__str.size()) - this->_S_copy(_M_data(), __str._M_data(), __str.size()); - _M_set_length(__str.size()); - } - } - else if (_Alloc_traits::_S_propagate_on_move_assign() || __equal_allocs) - { - - pointer __data = nullptr; - size_type __capacity; - if (!_M_is_local()) - { - if (__equal_allocs) - { - - __data = _M_data(); - __capacity = _M_allocated_capacity; - } - else - _M_destroy(_M_allocated_capacity); - } - - _M_data(__str._M_data()); - _M_length(__str.length()); - _M_capacity(__str._M_allocated_capacity); - if (__data) - { - __str._M_data(__data); - __str._M_capacity(__capacity); - } - else - __str._M_data(__str._M_local_buf); - } - else - assign(__str); - __str.clear(); - return *this; - } - - - - - - - basic_string& - operator=(initializer_list<_CharT> __l) - { - this->assign(__l.begin(), __l.size()); - return *this; - } - - - - - - - - template - - _If_sv<_Tp, basic_string&> - operator=(const _Tp& __svt) - { return this->assign(__svt); } - - - - - - - operator __sv_type() const noexcept - { return __sv_type(data(), size()); } - - - - - - - - [[__nodiscard__]] - iterator - begin() noexcept - { return iterator(_M_data()); } - - - - - - [[__nodiscard__]] - const_iterator - begin() const noexcept - { return const_iterator(_M_data()); } - - - - - - [[__nodiscard__]] - iterator - end() noexcept - { return iterator(_M_data() + this->size()); } - - - - - - [[__nodiscard__]] - const_iterator - end() const noexcept - { return const_iterator(_M_data() + this->size()); } - - - - - - - [[__nodiscard__]] - reverse_iterator - rbegin() noexcept - { return reverse_iterator(this->end()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - rbegin() const noexcept - { return const_reverse_iterator(this->end()); } - - - - - - - [[__nodiscard__]] - reverse_iterator - rend() noexcept - { return reverse_iterator(this->begin()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - rend() const noexcept - { return const_reverse_iterator(this->begin()); } - - - - - - - [[__nodiscard__]] - const_iterator - cbegin() const noexcept - { return const_iterator(this->_M_data()); } - - - - - - [[__nodiscard__]] - const_iterator - cend() const noexcept - { return const_iterator(this->_M_data() + this->size()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(this->end()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(this->begin()); } - - - public: - - - - [[__nodiscard__]] - size_type - size() const noexcept - { return _M_string_length; } - - - - [[__nodiscard__]] - size_type - length() const noexcept - { return _M_string_length; } - - - [[__nodiscard__]] - size_type - max_size() const noexcept - { return (_Alloc_traits::max_size(_M_get_allocator()) - 1) / 2; } -# 1086 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - void - resize(size_type __n, _CharT __c); -# 1100 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - void - resize(size_type __n) - { this->resize(__n, _CharT()); } - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - void - shrink_to_fit() noexcept - { reserve(); } -#pragma GCC diagnostic pop -# 1155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - capacity() const noexcept - { - return _M_is_local() ? size_type(_S_local_capacity) - : _M_allocated_capacity; - } -# 1181 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - void - reserve(size_type __res_arg); -# 1191 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - void - reserve(); - - - - - - void - clear() noexcept - { _M_set_length(0); } - - - - - - [[__nodiscard__]] - bool - empty() const noexcept - { return this->size() == 0; } -# 1222 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - const_reference - operator[] (size_type __pos) const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(__pos <= size())) __builtin_unreachable(); } while (false); - return _M_data()[__pos]; - } -# 1240 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - reference - operator[](size_type __pos) - { - - - do { if (std::__is_constant_evaluated() && !bool(__pos <= size())) __builtin_unreachable(); } while (false); - - ; - return _M_data()[__pos]; - } -# 1262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - const_reference - at(size_type __n) const - { - if (__n >= this->size()) - __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"), - - - __n, this->size()); - return _M_data()[__n]; - } -# 1284 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - reference - at(size_type __n) - { - if (__n >= size()) - __throw_out_of_range_fmt(("basic_string::at: __n " "(which is %zu) >= this->size() " "(which is %zu)"), - - - __n, this->size()); - return _M_data()[__n]; - } - - - - - - - [[__nodiscard__]] - reference - front() noexcept - { - do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); - return operator[](0); - } - - - - - - [[__nodiscard__]] - const_reference - front() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); - return operator[](0); - } - - - - - - [[__nodiscard__]] - reference - back() noexcept - { - do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); - return operator[](this->size() - 1); - } - - - - - - [[__nodiscard__]] - const_reference - back() const noexcept - { - do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); - return operator[](this->size() - 1); - } -# 1353 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - operator+=(const basic_string& __str) - { return this->append(__str); } - - - - - - - - basic_string& - operator+=(const _CharT* __s) - { return this->append(__s); } - - - - - - - - basic_string& - operator+=(_CharT __c) - { - this->push_back(__c); - return *this; - } -# 1387 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - operator+=(initializer_list<_CharT> __l) - { return this->append(__l.begin(), __l.size()); } -# 1398 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - _If_sv<_Tp, basic_string&> - operator+=(const _Tp& __svt) - { return this->append(__svt); } -# 1411 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - append(const basic_string& __str) - { return this->append(__str._M_data(), __str.size()); } -# 1429 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - append(const basic_string& __str, size_type __pos, size_type __n = npos) - { return this->append(__str._M_data() - + __str._M_check(__pos, "basic_string::append"), - __str._M_limit(__pos, __n)); } -# 1442 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - append(const _CharT* __s, size_type __n) - { - ; - _M_check_length(size_type(0), __n, "basic_string::append"); - return _M_append(__s, __n); - } - - - - - - - - basic_string& - append(const _CharT* __s) - { - ; - const size_type __n = traits_type::length(__s); - _M_check_length(size_type(0), __n, "basic_string::append"); - return _M_append(__s, __n); - } -# 1474 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - append(size_type __n, _CharT __c) - { return _M_replace_aux(this->size(), size_type(0), __n, __c); } -# 1485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - append(initializer_list<_CharT> __l) - { return this->append(__l.begin(), __l.size()); } -# 1499 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template> - - - - - basic_string& - append(_InputIterator __first, _InputIterator __last) - { return this->replace(end(), end(), __first, __last); } - - - - - - - - template - - _If_sv<_Tp, basic_string&> - append(const _Tp& __svt) - { - __sv_type __sv = __svt; - return this->append(__sv.data(), __sv.size()); - } -# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - _If_sv<_Tp, basic_string&> - append(const _Tp& __svt, size_type __pos, size_type __n = npos) - { - __sv_type __sv = __svt; - return _M_append(__sv.data() - + std::__sv_check(__sv.size(), __pos, "basic_string::append"), - std::__sv_limit(__sv.size(), __pos, __n)); - } - - - - - - - - void - push_back(_CharT __c) - { - const size_type __size = this->size(); - if (__size + 1 > this->capacity()) - this->_M_mutate(__size, size_type(0), 0, size_type(1)); - traits_type::assign(this->_M_data()[__size], __c); - this->_M_set_length(__size + 1); - } - - - - - - - - basic_string& - assign(const basic_string& __str) - { - - if (_Alloc_traits::_S_propagate_on_copy_assign()) - { - if (!_Alloc_traits::_S_always_equal() && !_M_is_local() - && _M_get_allocator() != __str._M_get_allocator()) - { - - - if (__str.size() <= _S_local_capacity) - { - _M_destroy(_M_allocated_capacity); - _M_data(_M_use_local_data()); - _M_set_length(0); - } - else - { - const auto __len = __str.size(); - auto __alloc = __str._M_get_allocator(); - - auto __ptr = _S_allocate(__alloc, __len + 1); - _M_destroy(_M_allocated_capacity); - _M_data(__ptr); - _M_capacity(__len); - _M_set_length(__len); - } - } - std::__alloc_on_copy(_M_get_allocator(), __str._M_get_allocator()); - } - - this->_M_assign(__str); - return *this; - } -# 1610 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - assign(basic_string&& __str) - noexcept(_Alloc_traits::_S_nothrow_move()) - { - - - return *this = std::move(__str); - } -# 1634 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - assign(const basic_string& __str, size_type __pos, size_type __n = npos) - { return _M_replace(size_type(0), this->size(), __str._M_data() - + __str._M_check(__pos, "basic_string::assign"), - __str._M_limit(__pos, __n)); } -# 1651 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - assign(const _CharT* __s, size_type __n) - { - ; - return _M_replace(size_type(0), this->size(), __s, __n); - } -# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - assign(const _CharT* __s) - { - ; - return _M_replace(size_type(0), this->size(), __s, - traits_type::length(__s)); - } -# 1686 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - assign(size_type __n, _CharT __c) - { return _M_replace_aux(size_type(0), this->size(), __n, __c); } -# 1699 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template> - - - - - basic_string& - assign(_InputIterator __first, _InputIterator __last) - { return this->replace(begin(), end(), __first, __last); } -# 1716 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - assign(initializer_list<_CharT> __l) - { return this->assign(__l.begin(), __l.size()); } -# 1727 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - _If_sv<_Tp, basic_string&> - assign(const _Tp& __svt) - { - __sv_type __sv = __svt; - return this->assign(__sv.data(), __sv.size()); - } -# 1743 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - _If_sv<_Tp, basic_string&> - assign(const _Tp& __svt, size_type __pos, size_type __n = npos) - { - __sv_type __sv = __svt; - return _M_replace(size_type(0), this->size(), - __sv.data() - + std::__sv_check(__sv.size(), __pos, "basic_string::assign"), - std::__sv_limit(__sv.size(), __pos, __n)); - } -# 1773 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - iterator - insert(const_iterator __p, size_type __n, _CharT __c) - { - ; - const size_type __pos = __p - begin(); - this->replace(__p, __p, __n, __c); - return iterator(this->_M_data() + __pos); - } -# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template> - - iterator - insert(const_iterator __p, _InputIterator __beg, _InputIterator __end) - { - ; - const size_type __pos = __p - begin(); - this->replace(__p, __p, __beg, __end); - return iterator(this->_M_data() + __pos); - } -# 1853 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - iterator - insert(const_iterator __p, initializer_list<_CharT> __l) - { return this->insert(__p, __l.begin(), __l.end()); } -# 1881 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - insert(size_type __pos1, const basic_string& __str) - { return this->replace(__pos1, size_type(0), - __str._M_data(), __str.size()); } -# 1905 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - insert(size_type __pos1, const basic_string& __str, - size_type __pos2, size_type __n = npos) - { return this->replace(__pos1, size_type(0), __str._M_data() - + __str._M_check(__pos2, "basic_string::insert"), - __str._M_limit(__pos2, __n)); } -# 1929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - insert(size_type __pos, const _CharT* __s, size_type __n) - { return this->replace(__pos, size_type(0), __s, __n); } -# 1949 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - insert(size_type __pos, const _CharT* __s) - { - ; - return this->replace(__pos, size_type(0), __s, - traits_type::length(__s)); - } -# 1974 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - insert(size_type __pos, size_type __n, _CharT __c) - { return _M_replace_aux(_M_check(__pos, "basic_string::insert"), - size_type(0), __n, __c); } -# 1993 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - iterator - insert(__const_iterator __p, _CharT __c) - { - ; - const size_type __pos = __p - begin(); - _M_replace_aux(__pos, size_type(0), size_type(1), __c); - return iterator(_M_data() + __pos); - } -# 2009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - _If_sv<_Tp, basic_string&> - insert(size_type __pos, const _Tp& __svt) - { - __sv_type __sv = __svt; - return this->insert(__pos, __sv.data(), __sv.size()); - } -# 2026 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - _If_sv<_Tp, basic_string&> - insert(size_type __pos1, const _Tp& __svt, - size_type __pos2, size_type __n = npos) - { - __sv_type __sv = __svt; - return this->replace(__pos1, size_type(0), - __sv.data() - + std::__sv_check(__sv.size(), __pos2, "basic_string::insert"), - std::__sv_limit(__sv.size(), __pos2, __n)); - } -# 2056 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - erase(size_type __pos = 0, size_type __n = npos) - { - _M_check(__pos, "basic_string::erase"); - if (__n == npos) - this->_M_set_length(__pos); - else if (__n != 0) - this->_M_erase(__pos, _M_limit(__pos, __n)); - return *this; - } -# 2076 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - iterator - erase(__const_iterator __position) - { - - ; - const size_type __pos = __position - begin(); - this->_M_erase(__pos, size_type(1)); - return iterator(_M_data() + __pos); - } -# 2096 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - iterator - erase(__const_iterator __first, __const_iterator __last) - { - - ; - const size_type __pos = __first - begin(); - if (__last == end()) - this->_M_set_length(__pos); - else - this->_M_erase(__pos, __last - __first); - return iterator(this->_M_data() + __pos); - } -# 2116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - void - pop_back() noexcept - { - do { if (std::__is_constant_evaluated() && !bool(!empty())) __builtin_unreachable(); } while (false); - _M_erase(size() - 1, 1); - } -# 2142 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(size_type __pos, size_type __n, const basic_string& __str) - { return this->replace(__pos, __n, __str._M_data(), __str.size()); } -# 2165 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(size_type __pos1, size_type __n1, const basic_string& __str, - size_type __pos2, size_type __n2 = npos) - { return this->replace(__pos1, __n1, __str._M_data() - + __str._M_check(__pos2, "basic_string::replace"), - __str._M_limit(__pos2, __n2)); } -# 2191 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(size_type __pos, size_type __n1, const _CharT* __s, - size_type __n2) - { - ; - return _M_replace(_M_check(__pos, "basic_string::replace"), - _M_limit(__pos, __n1), __s, __n2); - } -# 2217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(size_type __pos, size_type __n1, const _CharT* __s) - { - ; - return this->replace(__pos, __n1, __s, traits_type::length(__s)); - } -# 2242 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) - { return _M_replace_aux(_M_check(__pos, "basic_string::replace"), - _M_limit(__pos, __n1), __n2, __c); } -# 2261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(__const_iterator __i1, __const_iterator __i2, - const basic_string& __str) - { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } -# 2282 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(__const_iterator __i1, __const_iterator __i2, - const _CharT* __s, size_type __n) - { - - ; - return this->replace(__i1 - begin(), __i2 - __i1, __s, __n); - } -# 2305 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(__const_iterator __i1, __const_iterator __i2, const _CharT* __s) - { - ; - return this->replace(__i1, __i2, __s, traits_type::length(__s)); - } -# 2327 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(__const_iterator __i1, __const_iterator __i2, size_type __n, - _CharT __c) - { - - ; - return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __c); - } -# 2352 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template> - - basic_string& - replace(const_iterator __i1, const_iterator __i2, - _InputIterator __k1, _InputIterator __k2) - { - - ; - ; - return this->_M_replace_dispatch(__i1, __i2, __k1, __k2, - std::__false_type()); - } -# 2386 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& - replace(__const_iterator __i1, __const_iterator __i2, - _CharT* __k1, _CharT* __k2) - { - - ; - ; - return this->replace(__i1 - begin(), __i2 - __i1, - __k1, __k2 - __k1); - } - - - basic_string& - replace(__const_iterator __i1, __const_iterator __i2, - const _CharT* __k1, const _CharT* __k2) - { - - ; - ; - return this->replace(__i1 - begin(), __i2 - __i1, - __k1, __k2 - __k1); - } - - - basic_string& - replace(__const_iterator __i1, __const_iterator __i2, - iterator __k1, iterator __k2) - { - - ; - ; - return this->replace(__i1 - begin(), __i2 - __i1, - __k1.base(), __k2 - __k1); - } - - - basic_string& - replace(__const_iterator __i1, __const_iterator __i2, - const_iterator __k1, const_iterator __k2) - { - - ; - ; - return this->replace(__i1 - begin(), __i2 - __i1, - __k1.base(), __k2 - __k1); - } -# 2449 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - basic_string& replace(const_iterator __i1, const_iterator __i2, - initializer_list<_CharT> __l) - { return this->replace(__i1, __i2, __l.begin(), __l.size()); } -# 2462 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - _If_sv<_Tp, basic_string&> - replace(size_type __pos, size_type __n, const _Tp& __svt) - { - __sv_type __sv = __svt; - return this->replace(__pos, __n, __sv.data(), __sv.size()); - } -# 2480 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - _If_sv<_Tp, basic_string&> - replace(size_type __pos1, size_type __n1, const _Tp& __svt, - size_type __pos2, size_type __n2 = npos) - { - __sv_type __sv = __svt; - return this->replace(__pos1, __n1, - __sv.data() - + std::__sv_check(__sv.size(), __pos2, "basic_string::replace"), - std::__sv_limit(__sv.size(), __pos2, __n2)); - } -# 2502 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - _If_sv<_Tp, basic_string&> - replace(const_iterator __i1, const_iterator __i2, const _Tp& __svt) - { - __sv_type __sv = __svt; - return this->replace(__i1 - begin(), __i2 - __i1, __sv); - } - - - private: - template - - basic_string& - _M_replace_dispatch(const_iterator __i1, const_iterator __i2, - _Integer __n, _Integer __val, __true_type) - { return _M_replace_aux(__i1 - begin(), __i2 - __i1, __n, __val); } - - template - - basic_string& - _M_replace_dispatch(const_iterator __i1, const_iterator __i2, - _InputIterator __k1, _InputIterator __k2, - __false_type); - - - basic_string& - _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, - _CharT __c); - - __attribute__((__noinline__, __noclone__, __cold__)) void - _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s, - const size_type __len2, const size_type __how_much); - - - basic_string& - _M_replace(size_type __pos, size_type __len1, const _CharT* __s, - const size_type __len2); - - - basic_string& - _M_append(const _CharT* __s, size_type __n); - - public: -# 2560 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - size_type - copy(_CharT* __s, size_type __n, size_type __pos = 0) const; -# 2571 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - void - swap(basic_string& __s) noexcept; -# 2581 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - const _CharT* - c_str() const noexcept - { return _M_data(); } -# 2594 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - const _CharT* - data() const noexcept - { return _M_data(); } -# 2606 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - _CharT* - data() noexcept - { return _M_data(); } - - - - - - [[__nodiscard__]] - allocator_type - get_allocator() const noexcept - { return _M_get_allocator(); } -# 2632 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find(const _CharT* __s, size_type __pos, size_type __n) const - noexcept; -# 2647 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find(const basic_string& __str, size_type __pos = 0) const - noexcept - { return this->find(__str.data(), __pos, __str.size()); } -# 2660 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - _If_sv<_Tp, size_type> - find(const _Tp& __svt, size_type __pos = 0) const - noexcept(is_same<_Tp, __sv_type>::value) - { - __sv_type __sv = __svt; - return this->find(__sv.data(), __pos, __sv.size()); - } -# 2681 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find(const _CharT* __s, size_type __pos = 0) const noexcept - { - ; - return this->find(__s, __pos, traits_type::length(__s)); - } -# 2699 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find(_CharT __c, size_type __pos = 0) const noexcept; -# 2713 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - rfind(const basic_string& __str, size_type __pos = npos) const - noexcept - { return this->rfind(__str.data(), __pos, __str.size()); } -# 2726 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - _If_sv<_Tp, size_type> - rfind(const _Tp& __svt, size_type __pos = npos) const - noexcept(is_same<_Tp, __sv_type>::value) - { - __sv_type __sv = __svt; - return this->rfind(__sv.data(), __pos, __sv.size()); - } -# 2749 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - rfind(const _CharT* __s, size_type __pos, size_type __n) const - noexcept; -# 2764 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - rfind(const _CharT* __s, size_type __pos = npos) const - { - ; - return this->rfind(__s, __pos, traits_type::length(__s)); - } -# 2782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - rfind(_CharT __c, size_type __pos = npos) const noexcept; -# 2797 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_first_of(const basic_string& __str, size_type __pos = 0) const - noexcept - { return this->find_first_of(__str.data(), __pos, __str.size()); } -# 2811 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - _If_sv<_Tp, size_type> - find_first_of(const _Tp& __svt, size_type __pos = 0) const - noexcept(is_same<_Tp, __sv_type>::value) - { - __sv_type __sv = __svt; - return this->find_first_of(__sv.data(), __pos, __sv.size()); - } -# 2834 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_first_of(const _CharT* __s, size_type __pos, size_type __n) const - noexcept; -# 2849 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_first_of(const _CharT* __s, size_type __pos = 0) const - noexcept - { - ; - return this->find_first_of(__s, __pos, traits_type::length(__s)); - } -# 2870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_first_of(_CharT __c, size_type __pos = 0) const noexcept - { return this->find(__c, __pos); } -# 2886 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_last_of(const basic_string& __str, size_type __pos = npos) const - noexcept - { return this->find_last_of(__str.data(), __pos, __str.size()); } -# 2900 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - _If_sv<_Tp, size_type> - find_last_of(const _Tp& __svt, size_type __pos = npos) const - noexcept(is_same<_Tp, __sv_type>::value) - { - __sv_type __sv = __svt; - return this->find_last_of(__sv.data(), __pos, __sv.size()); - } -# 2923 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_last_of(const _CharT* __s, size_type __pos, size_type __n) const - noexcept; -# 2938 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_last_of(const _CharT* __s, size_type __pos = npos) const - noexcept - { - ; - return this->find_last_of(__s, __pos, traits_type::length(__s)); - } -# 2959 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_last_of(_CharT __c, size_type __pos = npos) const noexcept - { return this->rfind(__c, __pos); } -# 2974 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_first_not_of(const basic_string& __str, size_type __pos = 0) const - noexcept - { return this->find_first_not_of(__str.data(), __pos, __str.size()); } -# 2988 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - _If_sv<_Tp, size_type> - find_first_not_of(const _Tp& __svt, size_type __pos = 0) const - noexcept(is_same<_Tp, __sv_type>::value) - { - __sv_type __sv = __svt; - return this->find_first_not_of(__sv.data(), __pos, __sv.size()); - } -# 3011 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_first_not_of(const _CharT* __s, size_type __pos, - size_type __n) const noexcept; -# 3026 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_first_not_of(const _CharT* __s, size_type __pos = 0) const - noexcept - { - ; - return this->find_first_not_of(__s, __pos, traits_type::length(__s)); - } -# 3045 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_first_not_of(_CharT __c, size_type __pos = 0) const - noexcept; -# 3061 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_last_not_of(const basic_string& __str, size_type __pos = npos) const - noexcept - { return this->find_last_not_of(__str.data(), __pos, __str.size()); } -# 3075 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - _If_sv<_Tp, size_type> - find_last_not_of(const _Tp& __svt, size_type __pos = npos) const - noexcept(is_same<_Tp, __sv_type>::value) - { - __sv_type __sv = __svt; - return this->find_last_not_of(__sv.data(), __pos, __sv.size()); - } -# 3098 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_last_not_of(const _CharT* __s, size_type __pos, - size_type __n) const noexcept; -# 3113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_last_not_of(const _CharT* __s, size_type __pos = npos) const - noexcept - { - ; - return this->find_last_not_of(__s, __pos, traits_type::length(__s)); - } -# 3132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - size_type - find_last_not_of(_CharT __c, size_type __pos = npos) const - noexcept; -# 3149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - basic_string - substr(size_type __pos = 0, size_type __n = npos) const - { return basic_string(*this, - _M_check(__pos, "basic_string::substr"), __n); } -# 3169 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - int - compare(const basic_string& __str) const - { - const size_type __size = this->size(); - const size_type __osize = __str.size(); - const size_type __len = std::min(__size, __osize); - - int __r = traits_type::compare(_M_data(), __str.data(), __len); - if (!__r) - __r = _S_compare(__size, __osize); - return __r; - } - - - - - - - - template - [[__nodiscard__]] - _If_sv<_Tp, int> - compare(const _Tp& __svt) const - noexcept(is_same<_Tp, __sv_type>::value) - { - __sv_type __sv = __svt; - const size_type __size = this->size(); - const size_type __osize = __sv.size(); - const size_type __len = std::min(__size, __osize); - - int __r = traits_type::compare(_M_data(), __sv.data(), __len); - if (!__r) - __r = _S_compare(__size, __osize); - return __r; - } -# 3214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - _If_sv<_Tp, int> - compare(size_type __pos, size_type __n, const _Tp& __svt) const - noexcept(is_same<_Tp, __sv_type>::value) - { - __sv_type __sv = __svt; - return __sv_type(*this).substr(__pos, __n).compare(__sv); - } -# 3234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - _If_sv<_Tp, int> - compare(size_type __pos1, size_type __n1, const _Tp& __svt, - size_type __pos2, size_type __n2 = npos) const - noexcept(is_same<_Tp, __sv_type>::value) - { - __sv_type __sv = __svt; - return __sv_type(*this) - .substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2)); - } -# 3266 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - int - compare(size_type __pos, size_type __n, const basic_string& __str) const - { - _M_check(__pos, "basic_string::compare"); - __n = _M_limit(__pos, __n); - const size_type __osize = __str.size(); - const size_type __len = std::min(__n, __osize); - int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); - if (!__r) - __r = _S_compare(__n, __osize); - return __r; - } -# 3303 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - int - compare(size_type __pos1, size_type __n1, const basic_string& __str, - size_type __pos2, size_type __n2 = npos) const - { - _M_check(__pos1, "basic_string::compare"); - __str._M_check(__pos2, "basic_string::compare"); - __n1 = _M_limit(__pos1, __n1); - __n2 = __str._M_limit(__pos2, __n2); - const size_type __len = std::min(__n1, __n2); - int __r = traits_type::compare(_M_data() + __pos1, - __str.data() + __pos2, __len); - if (!__r) - __r = _S_compare(__n1, __n2); - return __r; - } -# 3334 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - int - compare(const _CharT* __s) const noexcept - { - ; - const size_type __size = this->size(); - const size_type __osize = traits_type::length(__s); - const size_type __len = std::min(__size, __osize); - int __r = traits_type::compare(_M_data(), __s, __len); - if (!__r) - __r = _S_compare(__size, __osize); - return __r; - } -# 3369 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - int - compare(size_type __pos, size_type __n1, const _CharT* __s) const - { - ; - _M_check(__pos, "basic_string::compare"); - __n1 = _M_limit(__pos, __n1); - const size_type __osize = traits_type::length(__s); - const size_type __len = std::min(__n1, __osize); - int __r = traits_type::compare(_M_data() + __pos, __s, __len); - if (!__r) - __r = _S_compare(__n1, __osize); - return __r; - } -# 3408 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - [[__nodiscard__]] - int - compare(size_type __pos, size_type __n1, const _CharT* __s, - size_type __n2) const - { - ; - _M_check(__pos, "basic_string::compare"); - __n1 = _M_limit(__pos, __n1); - const size_type __len = std::min(__n1, __n2); - int __r = traits_type::compare(_M_data() + __pos, __s, __len); - if (!__r) - __r = _S_compare(__n1, __n2); - return __r; - } -# 3473 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template friend class basic_stringbuf; - }; -} - -} - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - -namespace __cxx11 { - template::value_type, - typename _Allocator = allocator<_CharT>, - typename = _RequireInputIter<_InputIterator>, - typename = _RequireAllocator<_Allocator>> - basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator()) - -> basic_string<_CharT, char_traits<_CharT>, _Allocator>; - - - - template, - typename = _RequireAllocator<_Allocator>> - basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator()) - -> basic_string<_CharT, _Traits, _Allocator>; - - template, - typename = _RequireAllocator<_Allocator>> - basic_string(basic_string_view<_CharT, _Traits>, - typename basic_string<_CharT, _Traits, _Allocator>::size_type, - typename basic_string<_CharT, _Traits, _Allocator>::size_type, - const _Allocator& = _Allocator()) - -> basic_string<_CharT, _Traits, _Allocator>; -} - - - template - - inline _Str - __str_concat(typename _Str::value_type const* __lhs, - typename _Str::size_type __lhs_len, - typename _Str::value_type const* __rhs, - typename _Str::size_type __rhs_len, - typename _Str::allocator_type const& __a) - { - typedef typename _Str::allocator_type allocator_type; - typedef __gnu_cxx::__alloc_traits _Alloc_traits; - _Str __str(_Alloc_traits::_S_select_on_copy(__a)); - __str.reserve(__lhs_len + __rhs_len); - __str.append(__lhs, __lhs_len); - __str.append(__rhs, __rhs_len); - return __str; - } -# 3538 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - inline basic_string<_CharT, _Traits, _Alloc> - operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { - typedef basic_string<_CharT, _Traits, _Alloc> _Str; - return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(), - __rhs.c_str(), __rhs.size(), - __lhs.get_allocator()); - } - - - - - - - - template - [[__nodiscard__]] - inline basic_string<_CharT,_Traits,_Alloc> - operator+(const _CharT* __lhs, - const basic_string<_CharT,_Traits,_Alloc>& __rhs) - { - ; - typedef basic_string<_CharT, _Traits, _Alloc> _Str; - return std::__str_concat<_Str>(__lhs, _Traits::length(__lhs), - __rhs.c_str(), __rhs.size(), - __rhs.get_allocator()); - } - - - - - - - - template - [[__nodiscard__]] - inline basic_string<_CharT,_Traits,_Alloc> - operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs) - { - typedef basic_string<_CharT, _Traits, _Alloc> _Str; - return std::__str_concat<_Str>(__builtin_addressof(__lhs), 1, - __rhs.c_str(), __rhs.size(), - __rhs.get_allocator()); - } - - - - - - - - template - [[__nodiscard__]] - inline basic_string<_CharT, _Traits, _Alloc> - operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { - ; - typedef basic_string<_CharT, _Traits, _Alloc> _Str; - return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(), - __rhs, _Traits::length(__rhs), - __lhs.get_allocator()); - } - - - - - - - template - [[__nodiscard__]] - inline basic_string<_CharT, _Traits, _Alloc> - operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) - { - typedef basic_string<_CharT, _Traits, _Alloc> _Str; - return std::__str_concat<_Str>(__lhs.c_str(), __lhs.size(), - __builtin_addressof(__rhs), 1, - __lhs.get_allocator()); - } - - - template - [[__nodiscard__]] - inline basic_string<_CharT, _Traits, _Alloc> - operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return std::move(__lhs.append(__rhs)); } - - template - - inline basic_string<_CharT, _Traits, _Alloc> - operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - basic_string<_CharT, _Traits, _Alloc>&& __rhs) - { return std::move(__rhs.insert(0, __lhs)); } - - template - [[__nodiscard__]] - inline basic_string<_CharT, _Traits, _Alloc> - operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, - basic_string<_CharT, _Traits, _Alloc>&& __rhs) - { - - using _Alloc_traits = allocator_traits<_Alloc>; - bool __use_rhs = false; - if constexpr (typename _Alloc_traits::is_always_equal{}) - __use_rhs = true; - else if (__lhs.get_allocator() == __rhs.get_allocator()) - __use_rhs = true; - if (__use_rhs) - - { - const auto __size = __lhs.size() + __rhs.size(); - if (__size > __lhs.capacity() && __size <= __rhs.capacity()) - return std::move(__rhs.insert(0, __lhs)); - } - return std::move(__lhs.append(__rhs)); - } - - template - [[__nodiscard__]] [[__nodiscard__]] - inline basic_string<_CharT, _Traits, _Alloc> - operator+(const _CharT* __lhs, - basic_string<_CharT, _Traits, _Alloc>&& __rhs) - { return std::move(__rhs.insert(0, __lhs)); } - - template - [[__nodiscard__]] - inline basic_string<_CharT, _Traits, _Alloc> - operator+(_CharT __lhs, - basic_string<_CharT, _Traits, _Alloc>&& __rhs) - { return std::move(__rhs.insert(0, 1, __lhs)); } - - template - [[__nodiscard__]] - inline basic_string<_CharT, _Traits, _Alloc> - operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, - const _CharT* __rhs) - { return std::move(__lhs.append(__rhs)); } - - template - [[__nodiscard__]] - inline basic_string<_CharT, _Traits, _Alloc> - operator+(basic_string<_CharT, _Traits, _Alloc>&& __lhs, - _CharT __rhs) - { return std::move(__lhs.append(1, __rhs)); } -# 3695 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - inline bool - operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - noexcept - { - return __lhs.size() == __rhs.size() - && !_Traits::compare(__lhs.data(), __rhs.data(), __lhs.size()); - } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { - return __lhs.size() == _Traits::length(__rhs) - && !_Traits::compare(__lhs.data(), __rhs, __lhs.size()); - } -# 3759 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - inline bool - operator==(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs == __lhs; } -# 3773 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - inline bool - operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - noexcept - { return !(__lhs == __rhs); } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator!=(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return !(__rhs == __lhs); } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return !(__lhs == __rhs); } -# 3814 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - inline bool - operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - noexcept - { return __lhs.compare(__rhs) < 0; } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) < 0; } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator<(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) > 0; } -# 3855 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - inline bool - operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - noexcept - { return __lhs.compare(__rhs) > 0; } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) > 0; } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator>(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) < 0; } -# 3896 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - inline bool - operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - noexcept - { return __lhs.compare(__rhs) <= 0; } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) <= 0; } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator<=(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) >= 0; } -# 3937 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - [[__nodiscard__]] - inline bool - operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - noexcept - { return __lhs.compare(__rhs) >= 0; } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, - const _CharT* __rhs) - { return __lhs.compare(__rhs) >= 0; } - - - - - - - - template - [[__nodiscard__]] - inline bool - operator>=(const _CharT* __lhs, - const basic_string<_CharT, _Traits, _Alloc>& __rhs) - { return __rhs.compare(__lhs) <= 0; } -# 3979 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - - inline void - swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, - basic_string<_CharT, _Traits, _Alloc>& __rhs) - noexcept(noexcept(__lhs.swap(__rhs))) - { __lhs.swap(__rhs); } -# 4000 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Alloc>& __str); - - template<> - basic_istream& - operator>>(basic_istream& __is, basic_string& __str); -# 4018 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - inline basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, - const basic_string<_CharT, _Traits, _Alloc>& __str) - { - - - return __ostream_insert(__os, __str.data(), __str.size()); - } -# 4041 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - basic_istream<_CharT, _Traits>& - getline(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); -# 4058 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - inline basic_istream<_CharT, _Traits>& - getline(basic_istream<_CharT, _Traits>& __is, - basic_string<_CharT, _Traits, _Alloc>& __str) - { return std::getline(__is, __str, __is.widen('\n')); } - - - - template - inline basic_istream<_CharT, _Traits>& - getline(basic_istream<_CharT, _Traits>&& __is, - basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) - { return std::getline(__is, __str, __delim); } - - - template - inline basic_istream<_CharT, _Traits>& - getline(basic_istream<_CharT, _Traits>&& __is, - basic_string<_CharT, _Traits, _Alloc>& __str) - { return std::getline(__is, __str); } - - - template<> - basic_istream& - getline(basic_istream& __in, basic_string& __str, - char __delim); - - - template<> - basic_istream& - getline(basic_istream& __in, basic_string& __str, - wchar_t __delim); - - - -} - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 -# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 -# 1 "/usr/include/stdlib.h" 1 3 4 -# 26 "/usr/include/stdlib.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/stdlib.h" 2 3 4 - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 33 "/usr/include/stdlib.h" 2 3 4 - -extern "C" { - - - - - -# 1 "/usr/include/bits/waitflags.h" 1 3 4 -# 41 "/usr/include/stdlib.h" 2 3 4 -# 1 "/usr/include/bits/waitstatus.h" 1 3 4 -# 42 "/usr/include/stdlib.h" 2 3 4 -# 59 "/usr/include/stdlib.h" 3 4 -typedef struct - { - int quot; - int rem; - } div_t; - - - -typedef struct - { - long int quot; - long int rem; - } ldiv_t; - - - - - -__extension__ typedef struct - { - long long int quot; - long long int rem; - } lldiv_t; -# 98 "/usr/include/stdlib.h" 3 4 -extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; - - - -extern double atof (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - -extern int atoi (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - -extern long int atol (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - -__extension__ extern long long int atoll (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - -extern double strtod (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern float strtof (const char *__restrict __nptr, - char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); - -extern long double strtold (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 141 "/usr/include/stdlib.h" 3 4 -extern _Float32 strtof32 (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern _Float64 strtof64 (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 159 "/usr/include/stdlib.h" 3 4 -extern _Float32x strtof32x (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern _Float64x strtof64x (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 177 "/usr/include/stdlib.h" 3 4 -extern long int strtol (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -extern unsigned long int strtoul (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -__extension__ -extern long long int strtoq (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -__extension__ -extern unsigned long long int strtouq (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -__extension__ -extern long long int strtoll (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -__extension__ -extern unsigned long long int strtoull (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") - - - __attribute__ ((__nonnull__ (1))); -extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") - - - - __attribute__ ((__nonnull__ (1))); - -__extension__ -extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") - - - __attribute__ ((__nonnull__ (1))); -__extension__ -extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") - - - - __attribute__ ((__nonnull__ (1))); - -__extension__ -extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") - - - __attribute__ ((__nonnull__ (1))); -__extension__ -extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") - - - - __attribute__ ((__nonnull__ (1))); -# 278 "/usr/include/stdlib.h" 3 4 -extern int strfromd (char *__dest, size_t __size, const char *__format, - double __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - -extern int strfromf (char *__dest, size_t __size, const char *__format, - float __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - -extern int strfroml (char *__dest, size_t __size, const char *__format, - long double __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 298 "/usr/include/stdlib.h" 3 4 -extern int strfromf32 (char *__dest, size_t __size, const char * __format, - _Float32 __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - - -extern int strfromf64 (char *__dest, size_t __size, const char * __format, - _Float64 __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 316 "/usr/include/stdlib.h" 3 4 -extern int strfromf32x (char *__dest, size_t __size, const char * __format, - _Float32x __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - - -extern int strfromf64x (char *__dest, size_t __size, const char * __format, - _Float64x __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 340 "/usr/include/stdlib.h" 3 4 -extern long int strtol_l (const char *__restrict __nptr, - char **__restrict __endptr, int __base, - locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -extern unsigned long int strtoul_l (const char *__restrict __nptr, - char **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -__extension__ -extern long long int strtoll_l (const char *__restrict __nptr, - char **__restrict __endptr, int __base, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -__extension__ -extern unsigned long long int strtoull_l (const char *__restrict __nptr, - char **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - - - - - -extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") - - - - __attribute__ ((__nonnull__ (1, 4))); -extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -__extension__ -extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -__extension__ -extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -# 415 "/usr/include/stdlib.h" 3 4 -extern double strtod_l (const char *__restrict __nptr, - char **__restrict __endptr, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - -extern float strtof_l (const char *__restrict __nptr, - char **__restrict __endptr, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - -extern long double strtold_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 436 "/usr/include/stdlib.h" 3 4 -extern _Float32 strtof32_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern _Float64 strtof64_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 457 "/usr/include/stdlib.h" 3 4 -extern _Float32x strtof32x_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern _Float64x strtof64x_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 480 "/usr/include/stdlib.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) int - atoi (const char *__nptr) noexcept (true) -{ - return (int) strtol (__nptr, (char **) __null, 10); -} -extern __inline __attribute__ ((__gnu_inline__)) long int - atol (const char *__nptr) noexcept (true) -{ - return strtol (__nptr, (char **) __null, 10); -} - - -__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int - atoll (const char *__nptr) noexcept (true) -{ - return strtoll (__nptr, (char **) __null, 10); -} -# 505 "/usr/include/stdlib.h" 3 4 -extern char *l64a (long int __n) noexcept (true) ; - - -extern long int a64l (const char *__s) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - - -# 1 "/usr/include/sys/types.h" 1 3 4 -# 27 "/usr/include/sys/types.h" 3 4 -extern "C" { - - - - - -typedef __u_char u_char; -typedef __u_short u_short; -typedef __u_int u_int; -typedef __u_long u_long; -typedef __quad_t quad_t; -typedef __u_quad_t u_quad_t; -typedef __fsid_t fsid_t; - - -typedef __loff_t loff_t; - - - - -typedef __ino_t ino_t; - - - - - - -typedef __ino64_t ino64_t; - - - - -typedef __dev_t dev_t; - - - - -typedef __gid_t gid_t; - - - - -typedef __mode_t mode_t; - - - - -typedef __nlink_t nlink_t; - - - - -typedef __uid_t uid_t; - - - - - -typedef __off_t off_t; - - - - - - -typedef __off64_t off64_t; -# 103 "/usr/include/sys/types.h" 3 4 -typedef __id_t id_t; - - - - -typedef __ssize_t ssize_t; - - - - - -typedef __daddr_t daddr_t; -typedef __caddr_t caddr_t; - - - - - -typedef __key_t key_t; -# 134 "/usr/include/sys/types.h" 3 4 -typedef __useconds_t useconds_t; - - - -typedef __suseconds_t suseconds_t; - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 145 "/usr/include/sys/types.h" 2 3 4 - - - -typedef unsigned long int ulong; -typedef unsigned short int ushort; -typedef unsigned int uint; - - - - -# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-intn.h" 3 4 -typedef __int8_t int8_t; -typedef __int16_t int16_t; -typedef __int32_t int32_t; -typedef __int64_t int64_t; -# 156 "/usr/include/sys/types.h" 2 3 4 - - -typedef __uint8_t u_int8_t; -typedef __uint16_t u_int16_t; -typedef __uint32_t u_int32_t; -typedef __uint64_t u_int64_t; - - -typedef int register_t __attribute__ ((__mode__ (__word__))); -# 176 "/usr/include/sys/types.h" 3 4 -# 1 "/usr/include/endian.h" 1 3 4 -# 35 "/usr/include/endian.h" 3 4 -# 1 "/usr/include/bits/byteswap.h" 1 3 4 -# 33 "/usr/include/bits/byteswap.h" 3 4 -static __inline __uint16_t -__bswap_16 (__uint16_t __bsx) -{ - - - - return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8))); - -} - - - - - - -static __inline __uint32_t -__bswap_32 (__uint32_t __bsx) -{ - - - - return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); - -} -# 69 "/usr/include/bits/byteswap.h" 3 4 -__extension__ static __inline __uint64_t -__bswap_64 (__uint64_t __bsx) -{ - - - - return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56)); - -} -# 36 "/usr/include/endian.h" 2 3 4 -# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 -# 32 "/usr/include/bits/uintn-identity.h" 3 4 -static __inline __uint16_t -__uint16_identity (__uint16_t __x) -{ - return __x; -} - -static __inline __uint32_t -__uint32_identity (__uint32_t __x) -{ - return __x; -} - -static __inline __uint64_t -__uint64_identity (__uint64_t __x) -{ - return __x; -} -# 37 "/usr/include/endian.h" 2 3 4 -# 177 "/usr/include/sys/types.h" 2 3 4 - - -# 1 "/usr/include/sys/select.h" 1 3 4 -# 30 "/usr/include/sys/select.h" 3 4 -# 1 "/usr/include/bits/select.h" 1 3 4 -# 31 "/usr/include/sys/select.h" 2 3 4 - - -# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 - - - - - - -typedef __sigset_t sigset_t; -# 34 "/usr/include/sys/select.h" 2 3 4 -# 49 "/usr/include/sys/select.h" 3 4 -typedef long int __fd_mask; -# 59 "/usr/include/sys/select.h" 3 4 -typedef struct - { - - - - __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; - - - - - - } fd_set; - - - - - - -typedef __fd_mask fd_mask; -# 91 "/usr/include/sys/select.h" 3 4 -extern "C" { -# 102 "/usr/include/sys/select.h" 3 4 -extern int select (int __nfds, fd_set *__restrict __readfds, - fd_set *__restrict __writefds, - fd_set *__restrict __exceptfds, - struct timeval *__restrict __timeout); -# 127 "/usr/include/sys/select.h" 3 4 -extern int pselect (int __nfds, fd_set *__restrict __readfds, - fd_set *__restrict __writefds, - fd_set *__restrict __exceptfds, - const struct timespec *__restrict __timeout, - const __sigset_t *__restrict __sigmask); -# 153 "/usr/include/sys/select.h" 3 4 -} -# 180 "/usr/include/sys/types.h" 2 3 4 - - - - - -typedef __blksize_t blksize_t; - - - - - - -typedef __blkcnt_t blkcnt_t; - - - -typedef __fsblkcnt_t fsblkcnt_t; - - - -typedef __fsfilcnt_t fsfilcnt_t; -# 219 "/usr/include/sys/types.h" 3 4 -typedef __blkcnt64_t blkcnt64_t; -typedef __fsblkcnt64_t fsblkcnt64_t; -typedef __fsfilcnt64_t fsfilcnt64_t; -# 230 "/usr/include/sys/types.h" 3 4 -} -# 515 "/usr/include/stdlib.h" 2 3 4 - - - - - - -extern long int random (void) noexcept (true); - - -extern void srandom (unsigned int __seed) noexcept (true); - - - - - -extern char *initstate (unsigned int __seed, char *__statebuf, - size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - -extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - - -struct random_data - { - int32_t *fptr; - int32_t *rptr; - int32_t *state; - int rand_type; - int rand_deg; - int rand_sep; - int32_t *end_ptr; - }; - -extern int random_r (struct random_data *__restrict __buf, - int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern int srandom_r (unsigned int __seed, struct random_data *__buf) - noexcept (true) __attribute__ ((__nonnull__ (2))); - -extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, - size_t __statelen, - struct random_data *__restrict __buf) - noexcept (true) __attribute__ ((__nonnull__ (2, 4))); - -extern int setstate_r (char *__restrict __statebuf, - struct random_data *__restrict __buf) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - - -extern int rand (void) noexcept (true); - -extern void srand (unsigned int __seed) noexcept (true); - - - -extern int rand_r (unsigned int *__seed) noexcept (true); - - - - - - - -extern double drand48 (void) noexcept (true); -extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern long int lrand48 (void) noexcept (true); -extern long int nrand48 (unsigned short int __xsubi[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern long int mrand48 (void) noexcept (true); -extern long int jrand48 (unsigned short int __xsubi[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern void srand48 (long int __seedval) noexcept (true); -extern unsigned short int *seed48 (unsigned short int __seed16v[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); -extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -struct drand48_data - { - unsigned short int __x[3]; - unsigned short int __old_x[3]; - unsigned short int __c; - unsigned short int __init; - __extension__ unsigned long long int __a; - - }; - - -extern int drand48_r (struct drand48_data *__restrict __buffer, - double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int erand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int lrand48_r (struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int nrand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int mrand48_r (struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int jrand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int srand48_r (long int __seedval, struct drand48_data *__buffer) - noexcept (true) __attribute__ ((__nonnull__ (2))); - -extern int seed48_r (unsigned short int __seed16v[3], - struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern int lcong48_r (unsigned short int __param[7], - struct drand48_data *__buffer) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern __uint32_t arc4random (void) - noexcept (true) ; - - -extern void arc4random_buf (void *__buf, size_t __size) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) - noexcept (true) ; - - - - -extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) - ; - -extern void *calloc (size_t __nmemb, size_t __size) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - - - -extern void *realloc (void *__ptr, size_t __size) - noexcept (true) __attribute__ ((__warn_unused_result__)) ; - - -extern void free (void *__ptr) noexcept (true); - - - - - - - -extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) - noexcept (true) __attribute__ ((__warn_unused_result__)) - - ; - - -extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) - noexcept (true) ; - - - -# 1 "/usr/include/alloca.h" 1 3 4 -# 24 "/usr/include/alloca.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 25 "/usr/include/alloca.h" 2 3 4 - -extern "C" { - - - - - -extern void *alloca (size_t __size) noexcept (true); - - - - - -} -# 707 "/usr/include/stdlib.h" 2 3 4 - - - - - -extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) - ; - - - - -extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) - noexcept (true) __attribute__ ((__nonnull__ (1))) ; - - - - -extern void *aligned_alloc (size_t __alignment, size_t __size) - noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) - ; - - - -extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)); - - - -extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern "C++" int at_quick_exit (void (*__func) (void)) - noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); -# 749 "/usr/include/stdlib.h" 3 4 -extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); - - - - - -extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); - - - - - -extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); - - - - -extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; - - - - -extern char *secure_getenv (const char *__name) - noexcept (true) __attribute__ ((__nonnull__ (1))) ; - - - - - - -extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern int setenv (const char *__name, const char *__value, int __replace) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - -extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int clearenv (void) noexcept (true); -# 814 "/usr/include/stdlib.h" 3 4 -extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); -# 827 "/usr/include/stdlib.h" 3 4 -extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; -# 837 "/usr/include/stdlib.h" 3 4 -extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; -# 849 "/usr/include/stdlib.h" 3 4 -extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; -# 859 "/usr/include/stdlib.h" 3 4 -extern int mkstemps64 (char *__template, int __suffixlen) - __attribute__ ((__nonnull__ (1))) ; -# 870 "/usr/include/stdlib.h" 3 4 -extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; -# 881 "/usr/include/stdlib.h" 3 4 -extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; -# 891 "/usr/include/stdlib.h" 3 4 -extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; -# 901 "/usr/include/stdlib.h" 3 4 -extern int mkostemps (char *__template, int __suffixlen, int __flags) - __attribute__ ((__nonnull__ (1))) ; -# 913 "/usr/include/stdlib.h" 3 4 -extern int mkostemps64 (char *__template, int __suffixlen, int __flags) - __attribute__ ((__nonnull__ (1))) ; -# 923 "/usr/include/stdlib.h" 3 4 -extern int system (const char *__command) ; - - - - - -extern char *canonicalize_file_name (const char *__name) - noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) - ; -# 940 "/usr/include/stdlib.h" 3 4 -extern char *realpath (const char *__restrict __name, - char *__restrict __resolved) noexcept (true) ; - - - - - - -typedef int (*__compar_fn_t) (const void *, const void *); - - -typedef __compar_fn_t comparison_fn_t; - - - -typedef int (*__compar_d_fn_t) (const void *, const void *, void *); - - - - -extern void *bsearch (const void *__key, const void *__base, - size_t __nmemb, size_t __size, __compar_fn_t __compar) - __attribute__ ((__nonnull__ (1, 2, 5))) ; - - -# 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4 -# 19 "/usr/include/bits/stdlib-bsearch.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) void * -bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, - __compar_fn_t __compar) -{ - size_t __l, __u, __idx; - const void *__p; - int __comparison; - - __l = 0; - __u = __nmemb; - while (__l < __u) - { - __idx = (__l + __u) / 2; - __p = (const void *) (((const char *) __base) + (__idx * __size)); - __comparison = (*__compar) (__key, __p); - if (__comparison < 0) - __u = __idx; - else if (__comparison > 0) - __l = __idx + 1; - else - { - - - - - return (void *) __p; - - - - } - } - - return __null; -} -# 966 "/usr/include/stdlib.h" 2 3 4 - - - - -extern void qsort (void *__base, size_t __nmemb, size_t __size, - __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); - -extern void qsort_r (void *__base, size_t __nmemb, size_t __size, - __compar_d_fn_t __compar, void *__arg) - __attribute__ ((__nonnull__ (1, 4))); - - - - -extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; -extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; - - -__extension__ extern long long int llabs (long long int __x) - noexcept (true) __attribute__ ((__const__)) ; - - - - - - -extern div_t div (int __numer, int __denom) - noexcept (true) __attribute__ ((__const__)) ; -extern ldiv_t ldiv (long int __numer, long int __denom) - noexcept (true) __attribute__ ((__const__)) ; - - -__extension__ extern lldiv_t lldiv (long long int __numer, - long long int __denom) - noexcept (true) __attribute__ ((__const__)) ; -# 1012 "/usr/include/stdlib.h" 3 4 -extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; - - - - -extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; - - - - -extern char *gcvt (double __value, int __ndigit, char *__buf) - noexcept (true) __attribute__ ((__nonnull__ (3))) ; - - - - -extern char *qecvt (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign) - noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; -extern char *qfcvt (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign) - noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; -extern char *qgcvt (long double __value, int __ndigit, char *__buf) - noexcept (true) __attribute__ ((__nonnull__ (3))) ; - - - - -extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign, char *__restrict __buf, - size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); -extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign, char *__restrict __buf, - size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); - -extern int qecvt_r (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign, - char *__restrict __buf, size_t __len) - noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); -extern int qfcvt_r (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign, - char *__restrict __buf, size_t __len) - noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); - - - - - -extern int mblen (const char *__s, size_t __n) noexcept (true); - - -extern int mbtowc (wchar_t *__restrict __pwc, - const char *__restrict __s, size_t __n) noexcept (true); - - -extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); - - - -extern size_t mbstowcs (wchar_t *__restrict __pwcs, - const char *__restrict __s, size_t __n) noexcept (true) - ; - -extern size_t wcstombs (char *__restrict __s, - const wchar_t *__restrict __pwcs, size_t __n) - noexcept (true) - - ; - - - - - - -extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; -# 1099 "/usr/include/stdlib.h" 3 4 -extern int getsubopt (char **__restrict __optionp, - char *const *__restrict __tokens, - char **__restrict __valuep) - noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; - - - - - - - -extern int posix_openpt (int __oflag) ; - - - - - - - -extern int grantpt (int __fd) noexcept (true); - - - -extern int unlockpt (int __fd) noexcept (true); - - - - -extern char *ptsname (int __fd) noexcept (true) ; - - - - - - -extern int ptsname_r (int __fd, char *__buf, size_t __buflen) - noexcept (true) __attribute__ ((__nonnull__ (2))) ; - - -extern int getpt (void); - - - - - - -extern int getloadavg (double __loadavg[], int __nelem) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 1155 "/usr/include/stdlib.h" 3 4 -# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 -# 24 "/usr/include/bits/stdlib-float.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) double - atof (const char *__nptr) noexcept (true) -{ - return strtod (__nptr, (char **) __null); -} -# 1156 "/usr/include/stdlib.h" 2 3 4 -# 1167 "/usr/include/stdlib.h" 3 4 -} -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::abs; - - - inline long - abs(long __i) { return __builtin_labs(__i); } - - - - inline long long - abs(long long __x) { return __builtin_llabs (__x); } -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 - inline constexpr double - abs(double __x) - { return __builtin_fabs(__x); } - - inline constexpr float - abs(float __x) - { return __builtin_fabsf(__x); } - - inline constexpr long double - abs(long double __x) - { return __builtin_fabsl(__x); } -# 151 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 -} -} -# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::div_t; - using ::ldiv_t; - - using ::abort; - - using ::aligned_alloc; - - using ::atexit; - - - using ::at_quick_exit; - - - using ::atof; - using ::atoi; - using ::atol; - using ::bsearch; - using ::calloc; - using ::div; - using ::exit; - using ::free; - using ::getenv; - using ::labs; - using ::ldiv; - using ::malloc; - - using ::mblen; - using ::mbstowcs; - using ::mbtowc; - - using ::qsort; - - - using ::quick_exit; - - - using ::rand; - using ::realloc; - using ::srand; - using ::strtod; - using ::strtol; - using ::strtoul; - using ::system; - - using ::wcstombs; - using ::wctomb; - - - - inline ldiv_t - div(long __i, long __j) noexcept { return ldiv(__i, __j); } - - - - -} -# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -# 231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 - using ::atoll; - using ::strtoll; - using ::strtoull; - - using ::strtof; - using ::strtold; - - -} - -namespace std -{ - - using ::__gnu_cxx::lldiv_t; - - using ::__gnu_cxx::_Exit; - - using ::__gnu_cxx::llabs; - using ::__gnu_cxx::div; - using ::__gnu_cxx::lldiv; - - using ::__gnu_cxx::atoll; - using ::__gnu_cxx::strtof; - using ::__gnu_cxx::strtoll; - using ::__gnu_cxx::strtoull; - using ::__gnu_cxx::strtold; -} - - - -} -# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwchar" 3 -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 - - -# 1 "/usr/include/stdio.h" 1 3 4 -# 27 "/usr/include/stdio.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/stdio.h" 2 3 4 - -extern "C" { - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 34 "/usr/include/stdio.h" 2 3 4 - - -# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 -# 37 "/usr/include/stdio.h" 2 3 4 - - -# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4 -# 10 "/usr/include/bits/types/__fpos_t.h" 3 4 -typedef struct _G_fpos_t -{ - __off_t __pos; - __mbstate_t __state; -} __fpos_t; -# 40 "/usr/include/stdio.h" 2 3 4 -# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4 -# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4 -typedef struct _G_fpos64_t -{ - __off64_t __pos; - __mbstate_t __state; -} __fpos64_t; -# 41 "/usr/include/stdio.h" 2 3 4 - - -# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4 -# 35 "/usr/include/bits/types/struct_FILE.h" 3 4 -struct _IO_FILE; -struct _IO_marker; -struct _IO_codecvt; -struct _IO_wide_data; - - - - -typedef void _IO_lock_t; - - - - - -struct _IO_FILE -{ - int _flags; - - - char *_IO_read_ptr; - char *_IO_read_end; - char *_IO_read_base; - char *_IO_write_base; - char *_IO_write_ptr; - char *_IO_write_end; - char *_IO_buf_base; - char *_IO_buf_end; - - - char *_IO_save_base; - char *_IO_backup_base; - char *_IO_save_end; - - struct _IO_marker *_markers; - - struct _IO_FILE *_chain; - - int _fileno; - int _flags2; - __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/bits/types/cookie_io_functions_t.h" 1 3 4 -# 27 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4 -typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, - size_t __nbytes); - - - - - - - -typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, - size_t __nbytes); - - - - - - - -typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); - - -typedef int cookie_close_function_t (void *__cookie); - - - - - - -typedef struct _IO_cookie_io_functions_t -{ - cookie_read_function_t *read; - cookie_write_function_t *write; - cookie_seek_function_t *seek; - cookie_close_function_t *close; -} cookie_io_functions_t; -# 47 "/usr/include/stdio.h" 2 3 4 -# 84 "/usr/include/stdio.h" 3 4 -typedef __fpos_t fpos_t; - - - - -typedef __fpos64_t fpos64_t; -# 128 "/usr/include/stdio.h" 3 4 -# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 -# 129 "/usr/include/stdio.h" 2 3 4 -# 148 "/usr/include/stdio.h" 3 4 -extern FILE *stdin; -extern FILE *stdout; -extern FILE *stderr; - - - - - - -extern int remove (const char *__filename) noexcept (true); - -extern int rename (const char *__old, const char *__new) noexcept (true); - - - -extern int renameat (int __oldfd, const char *__old, int __newfd, - const char *__new) noexcept (true); -# 175 "/usr/include/stdio.h" 3 4 -extern int renameat2 (int __oldfd, const char *__old, int __newfd, - const char *__new, unsigned int __flags) noexcept (true); - - - - - - -extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); -# 193 "/usr/include/stdio.h" 3 4 -extern FILE *tmpfile (void) - __attribute__ ((__malloc__)) ; -# 205 "/usr/include/stdio.h" 3 4 -extern FILE *tmpfile64 (void) - __attribute__ ((__malloc__)) ; - - - -extern char *tmpnam (char[20]) noexcept (true) ; - - - - -extern char *tmpnam_r (char __s[20]) noexcept (true) ; -# 227 "/usr/include/stdio.h" 3 4 -extern char *tempnam (const char *__dir, const char *__pfx) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - - - -extern int fflush (FILE *__stream); -# 244 "/usr/include/stdio.h" 3 4 -extern int fflush_unlocked (FILE *__stream); -# 254 "/usr/include/stdio.h" 3 4 -extern int fcloseall (void); -# 263 "/usr/include/stdio.h" 3 4 -extern FILE *fopen (const char *__restrict __filename, - const char *__restrict __modes) - __attribute__ ((__malloc__)) ; - - - - -extern FILE *freopen (const char *__restrict __filename, - const char *__restrict __modes, - FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); -# 288 "/usr/include/stdio.h" 3 4 -extern FILE *fopen64 (const char *__restrict __filename, - const char *__restrict __modes) - __attribute__ ((__malloc__)) ; -extern FILE *freopen64 (const char *__restrict __filename, - const char *__restrict __modes, - FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); - - - - -extern FILE *fdopen (int __fd, const char *__modes) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern FILE *fopencookie (void *__restrict __magic_cookie, - const char *__restrict __modes, - cookie_io_functions_t __io_funcs) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - -extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - -extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true); - - - -extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, - int __modes, size_t __n) noexcept (true); - - - - -extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, - size_t __size) noexcept (true); - - -extern void setlinebuf (FILE *__stream) noexcept (true); - - - - - - - -extern int fprintf (FILE *__restrict __stream, - const char *__restrict __format, ...); - - - - -extern int printf (const char *__restrict __format, ...); - -extern int sprintf (char *__restrict __s, - const char *__restrict __format, ...) noexcept (true); - - - - - -extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, - __gnuc_va_list __arg); - - - - -extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); - -extern int vsprintf (char *__restrict __s, const char *__restrict __format, - __gnuc_va_list __arg) noexcept (true); - - - -extern int snprintf (char *__restrict __s, size_t __maxlen, - const char *__restrict __format, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); - -extern int vsnprintf (char *__restrict __s, size_t __maxlen, - const char *__restrict __format, __gnuc_va_list __arg) - noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); - - - - - -extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, - __gnuc_va_list __arg) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ; -extern int __asprintf (char **__restrict __ptr, - const char *__restrict __fmt, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; -extern int asprintf (char **__restrict __ptr, - const char *__restrict __fmt, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; - - - - -extern int vdprintf (int __fd, const char *__restrict __fmt, - __gnuc_va_list __arg) - __attribute__ ((__format__ (__printf__, 2, 0))); -extern int dprintf (int __fd, const char *__restrict __fmt, ...) - __attribute__ ((__format__ (__printf__, 2, 3))); - - - - - - - -extern int fscanf (FILE *__restrict __stream, - const char *__restrict __format, ...) ; - - - - -extern int scanf (const char *__restrict __format, ...) ; - -extern int sscanf (const char *__restrict __s, - const char *__restrict __format, ...) noexcept (true); -# 440 "/usr/include/stdio.h" 3 4 -extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") ; - - -extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") ; - -extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf"); -# 486 "/usr/include/stdio.h" 3 4 -extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, - __gnuc_va_list __arg) - __attribute__ ((__format__ (__scanf__, 2, 0))) ; - - - - - -extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) - __attribute__ ((__format__ (__scanf__, 1, 0))) ; - - -extern int vsscanf (const char *__restrict __s, - const char *__restrict __format, __gnuc_va_list __arg) - noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0))); - - - - - - -extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf") - - - - __attribute__ ((__format__ (__scanf__, 2, 0))) ; -extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf") - - __attribute__ ((__format__ (__scanf__, 1, 0))) ; -extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf") - - - - __attribute__ ((__format__ (__scanf__, 2, 0))); -# 571 "/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); -# 596 "/usr/include/stdio.h" 3 4 -extern int fgetc_unlocked (FILE *__stream); -# 607 "/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); -# 623 "/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) - ; -# 673 "/usr/include/stdio.h" 3 4 -extern char *fgets_unlocked (char *__restrict __s, int __n, - FILE *__restrict __stream) - ; -# 690 "/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); -# 749 "/usr/include/stdio.h" 3 4 -extern int fputs_unlocked (const char *__restrict __s, - FILE *__restrict __stream); -# 760 "/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); -# 794 "/usr/include/stdio.h" 3 4 -extern int fseeko (FILE *__stream, __off_t __off, int __whence); - - - - -extern __off_t ftello (FILE *__stream) ; -# 818 "/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); -# 837 "/usr/include/stdio.h" 3 4 -extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); -extern __off64_t ftello64 (FILE *__stream) ; -extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); -extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); - - - -extern void clearerr (FILE *__stream) noexcept (true); - -extern int feof (FILE *__stream) noexcept (true) ; - -extern int ferror (FILE *__stream) noexcept (true) ; - - - -extern void clearerr_unlocked (FILE *__stream) noexcept (true); -extern int feof_unlocked (FILE *__stream) noexcept (true) ; -extern int ferror_unlocked (FILE *__stream) noexcept (true) ; - - - - - - - -extern void perror (const char *__s) __attribute__ ((__cold__)); - - - - -extern int fileno (FILE *__stream) noexcept (true) ; - - - - -extern int fileno_unlocked (FILE *__stream) noexcept (true) ; -# 881 "/usr/include/stdio.h" 3 4 -extern int pclose (FILE *__stream); - - - - - -extern FILE *popen (const char *__command, const char *__modes) - __attribute__ ((__malloc__)) ; - - - - - - -extern char *ctermid (char *__s) noexcept (true) - ; - - - - - -extern char *cuserid (char *__s) - ; - - - - -struct obstack; - - -extern int obstack_printf (struct obstack *__restrict __obstack, - const char *__restrict __format, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); -extern int obstack_vprintf (struct obstack *__restrict __obstack, - const char *__restrict __format, - __gnuc_va_list __args) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); - - - - - - - -extern void flockfile (FILE *__stream) noexcept (true); - - - -extern int ftrylockfile (FILE *__stream) noexcept (true) ; - - -extern void funlockfile (FILE *__stream) noexcept (true); -# 943 "/usr/include/stdio.h" 3 4 -extern int __uflow (FILE *); -extern int __overflow (FILE *, int); -# 960 "/usr/include/stdio.h" 3 4 -# 1 "/usr/include/bits/stdio.h" 1 3 4 -# 38 "/usr/include/bits/stdio.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) int -vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) -{ - return vfprintf (stdout, __fmt, __arg); -} - - - -extern __inline __attribute__ ((__gnu_inline__)) int -getchar (void) -{ - return getc (stdin); -} - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -fgetc_unlocked (FILE *__fp) -{ - return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -getc_unlocked (FILE *__fp) -{ - return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); -} - - -extern __inline __attribute__ ((__gnu_inline__)) int -getchar_unlocked (void) -{ - return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++); -} - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -putchar (int __c) -{ - return putc (__c, stdout); -} - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -fputc_unlocked (int __c, FILE *__stream) -{ - return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -putc_unlocked (int __c, FILE *__stream) -{ - return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); -} - - -extern __inline __attribute__ ((__gnu_inline__)) int -putchar_unlocked (int __c) -{ - return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c))); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) __ssize_t -getline (char **__lineptr, size_t *__n, FILE *__stream) -{ - return __getdelim (__lineptr, __n, '\n', __stream); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) int - feof_unlocked (FILE *__stream) noexcept (true) -{ - return (((__stream)->_flags & 0x0010) != 0); -} - - -extern __inline __attribute__ ((__gnu_inline__)) int - ferror_unlocked (FILE *__stream) noexcept (true) -{ - return (((__stream)->_flags & 0x0020) != 0); -} -# 961 "/usr/include/stdio.h" 2 3 4 - - - - - - -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 2 3 -# 96 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 -namespace std -{ - using ::FILE; - using ::fpos_t; - - using ::clearerr; - using ::fclose; - using ::feof; - using ::ferror; - using ::fflush; - using ::fgetc; - using ::fgetpos; - using ::fgets; - using ::fopen; - using ::fprintf; - using ::fputc; - using ::fputs; - using ::fread; - using ::freopen; - using ::fscanf; - using ::fseek; - using ::fsetpos; - using ::ftell; - using ::fwrite; - using ::getc; - using ::getchar; - - - - - using ::perror; - using ::printf; - using ::putc; - using ::putchar; - using ::puts; - using ::remove; - using ::rename; - using ::rewind; - using ::scanf; - using ::setbuf; - using ::setvbuf; - using ::sprintf; - using ::sscanf; - using ::tmpfile; - - using ::tmpnam; - - using ::ungetc; - using ::vfprintf; - using ::vprintf; - using ::vsprintf; -} -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 -namespace __gnu_cxx -{ -# 175 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 - using ::snprintf; - using ::vfscanf; - using ::vscanf; - using ::vsnprintf; - using ::vsscanf; - -} - -namespace std -{ - using ::__gnu_cxx::snprintf; - using ::__gnu_cxx::vfscanf; - using ::__gnu_cxx::vscanf; - using ::__gnu_cxx::vsnprintf; - using ::__gnu_cxx::vsscanf; -} -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 3 - - -# 1 "/usr/include/errno.h" 1 3 4 -# 28 "/usr/include/errno.h" 3 4 -# 1 "/usr/include/bits/errno.h" 1 3 4 -# 26 "/usr/include/bits/errno.h" 3 4 -# 1 "/usr/include/linux/errno.h" 1 3 4 -# 1 "/usr/include/asm/errno.h" 1 3 4 -# 1 "/usr/include/asm-generic/errno.h" 1 3 4 - - - - -# 1 "/usr/include/asm-generic/errno-base.h" 1 3 4 -# 6 "/usr/include/asm-generic/errno.h" 2 3 4 -# 2 "/usr/include/asm/errno.h" 2 3 4 -# 2 "/usr/include/linux/errno.h" 2 3 4 -# 27 "/usr/include/bits/errno.h" 2 3 4 -# 29 "/usr/include/errno.h" 2 3 4 - - - - - -extern "C" { - - -extern int *__errno_location (void) noexcept (true) __attribute__ ((__const__)); - - - - - - - -extern char *program_invocation_name; -extern char *program_invocation_short_name; - -# 1 "/usr/include/bits/types/error_t.h" 1 3 4 -# 22 "/usr/include/bits/types/error_t.h" 3 4 -typedef int error_t; -# 49 "/usr/include/errno.h" 2 3 4 - - - -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 2 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/string_conversions.h" 2 3 - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - template - _Ret - __stoa(_TRet (*__convf) (const _CharT*, _CharT**, _Base...), - const char* __name, const _CharT* __str, std::size_t* __idx, - _Base... __base) - { - _Ret __ret; - - _CharT* __endptr; - - struct _Save_errno { - _Save_errno() : _M_errno((*__errno_location ())) { (*__errno_location ()) = 0; } - ~_Save_errno() { if ((*__errno_location ()) == 0) (*__errno_location ()) = _M_errno; } - int _M_errno; - } const __save_errno; - - struct _Range_chk { - static bool - _S_chk(_TRet, std::false_type) { return false; } - - static bool - _S_chk(_TRet __val, std::true_type) - { - return __val < _TRet(__numeric_traits::__min) - || __val > _TRet(__numeric_traits::__max); - } - }; - - const _TRet __tmp = __convf(__str, &__endptr, __base...); - - if (__endptr == __str) - std::__throw_invalid_argument(__name); - else if ((*__errno_location ()) == 34 - || _Range_chk::_S_chk(__tmp, std::is_same<_Ret, int>{})) - std::__throw_out_of_range(__name); - else - __ret = __tmp; - - if (__idx) - *__idx = __endptr - __str; - - return __ret; - } - - - template - _String - __to_xstring(int (*__convf) (_CharT*, std::size_t, const _CharT*, - __builtin_va_list), std::size_t __n, - const _CharT* __fmt, ...) - { - - - _CharT* __s = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __n)); - - __builtin_va_list __args; - __builtin_va_start(__args, __fmt); - - const int __len = __convf(__s, __n, __fmt, __args); - - __builtin_va_end(__args); - - return _String(__s, __s + __len); - } - - -} -# 4098 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/charconv.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/charconv.h" 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - -namespace __detail -{ - - - template - constexpr bool __integer_to_chars_is_unsigned - = ! __gnu_cxx::__int_traits<_Tp>::__is_signed; - - - - template - constexpr unsigned - __to_chars_len(_Tp __value, int __base = 10) noexcept - { - - static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug"); - - - unsigned __n = 1; - const unsigned __b2 = __base * __base; - const unsigned __b3 = __b2 * __base; - const unsigned long __b4 = __b3 * __base; - for (;;) - { - if (__value < (unsigned)__base) return __n; - if (__value < __b2) return __n + 1; - if (__value < __b3) return __n + 2; - if (__value < __b4) return __n + 3; - __value /= __b4; - __n += 4; - } - } - - - - - template - void - __to_chars_10_impl(char* __first, unsigned __len, _Tp __val) noexcept - { - - static_assert(__integer_to_chars_is_unsigned<_Tp>, "implementation bug"); - - - constexpr char __digits[201] = - "0001020304050607080910111213141516171819" - "2021222324252627282930313233343536373839" - "4041424344454647484950515253545556575859" - "6061626364656667686970717273747576777879" - "8081828384858687888990919293949596979899"; - unsigned __pos = __len - 1; - while (__val >= 100) - { - auto const __num = (__val % 100) * 2; - __val /= 100; - __first[__pos] = __digits[__num + 1]; - __first[__pos - 1] = __digits[__num]; - __pos -= 2; - } - if (__val >= 10) - { - auto const __num = __val * 2; - __first[1] = __digits[__num + 1]; - __first[0] = __digits[__num]; - } - else - __first[0] = '0' + __val; - } - -} - -} -# 4099 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - -namespace __cxx11 { - - - - inline int - stoi(const string& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::strtol, "stoi", __str.c_str(), - __idx, __base); } - - inline long - stol(const string& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::strtol, "stol", __str.c_str(), - __idx, __base); } - - inline unsigned long - stoul(const string& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::strtoul, "stoul", __str.c_str(), - __idx, __base); } - - inline long long - stoll(const string& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::strtoll, "stoll", __str.c_str(), - __idx, __base); } - - inline unsigned long long - stoull(const string& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::strtoull, "stoull", __str.c_str(), - __idx, __base); } - - - inline float - stof(const string& __str, size_t* __idx = 0) - { return __gnu_cxx::__stoa(&std::strtof, "stof", __str.c_str(), __idx); } - - inline double - stod(const string& __str, size_t* __idx = 0) - { return __gnu_cxx::__stoa(&std::strtod, "stod", __str.c_str(), __idx); } - - inline long double - stold(const string& __str, size_t* __idx = 0) - { return __gnu_cxx::__stoa(&std::strtold, "stold", __str.c_str(), __idx); } - - - - - [[__nodiscard__]] - inline string - to_string(int __val) - - noexcept - - { - const bool __neg = __val < 0; - const unsigned __uval = __neg ? (unsigned)~__val + 1u : __val; - const auto __len = __detail::__to_chars_len(__uval); - string __str(__neg + __len, '-'); - __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); - return __str; - } - - [[__nodiscard__]] - inline string - to_string(unsigned __val) - - noexcept - - { - string __str(__detail::__to_chars_len(__val), '\0'); - __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); - return __str; - } - - [[__nodiscard__]] - inline string - to_string(long __val) - - - - { - const bool __neg = __val < 0; - const unsigned long __uval = __neg ? (unsigned long)~__val + 1ul : __val; - const auto __len = __detail::__to_chars_len(__uval); - string __str(__neg + __len, '-'); - __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); - return __str; - } - - [[__nodiscard__]] - inline string - to_string(unsigned long __val) - - - - { - string __str(__detail::__to_chars_len(__val), '\0'); - __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); - return __str; - } - - [[__nodiscard__]] - inline string - to_string(long long __val) - { - const bool __neg = __val < 0; - const unsigned long long __uval - = __neg ? (unsigned long long)~__val + 1ull : __val; - const auto __len = __detail::__to_chars_len(__uval); - string __str(__neg + __len, '-'); - __detail::__to_chars_10_impl(&__str[__neg], __len, __uval); - return __str; - } - - [[__nodiscard__]] - inline string - to_string(unsigned long long __val) - { - string __str(__detail::__to_chars_len(__val), '\0'); - __detail::__to_chars_10_impl(&__str[0], __str.size(), __val); - return __str; - } - - - - - [[__nodiscard__]] - inline string - to_string(float __val) - { - const int __n = - __gnu_cxx::__numeric_traits::__max_exponent10 + 20; - return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, - "%f", __val); - } - - [[__nodiscard__]] - inline string - to_string(double __val) - { - const int __n = - __gnu_cxx::__numeric_traits::__max_exponent10 + 20; - return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, - "%f", __val); - } - - [[__nodiscard__]] - inline string - to_string(long double __val) - { - const int __n = - __gnu_cxx::__numeric_traits::__max_exponent10 + 20; - return __gnu_cxx::__to_xstring(&std::vsnprintf, __n, - "%Lf", __val); - } - - - - inline int - stoi(const wstring& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::wcstol, "stoi", __str.c_str(), - __idx, __base); } - - inline long - stol(const wstring& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::wcstol, "stol", __str.c_str(), - __idx, __base); } - - inline unsigned long - stoul(const wstring& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::wcstoul, "stoul", __str.c_str(), - __idx, __base); } - - inline long long - stoll(const wstring& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::wcstoll, "stoll", __str.c_str(), - __idx, __base); } - - inline unsigned long long - stoull(const wstring& __str, size_t* __idx = 0, int __base = 10) - { return __gnu_cxx::__stoa(&std::wcstoull, "stoull", __str.c_str(), - __idx, __base); } - - - inline float - stof(const wstring& __str, size_t* __idx = 0) - { return __gnu_cxx::__stoa(&std::wcstof, "stof", __str.c_str(), __idx); } - - inline double - stod(const wstring& __str, size_t* __idx = 0) - { return __gnu_cxx::__stoa(&std::wcstod, "stod", __str.c_str(), __idx); } - - inline long double - stold(const wstring& __str, size_t* __idx = 0) - { return __gnu_cxx::__stoa(&std::wcstold, "stold", __str.c_str(), __idx); } - - - - [[__nodiscard__]] - inline wstring - to_wstring(int __val) - { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(int), - L"%d", __val); } - - [[__nodiscard__]] - inline wstring - to_wstring(unsigned __val) - { return __gnu_cxx::__to_xstring(&std::vswprintf, - 4 * sizeof(unsigned), - L"%u", __val); } - - [[__nodiscard__]] - inline wstring - to_wstring(long __val) - { return __gnu_cxx::__to_xstring(&std::vswprintf, 4 * sizeof(long), - L"%ld", __val); } - - [[__nodiscard__]] - inline wstring - to_wstring(unsigned long __val) - { return __gnu_cxx::__to_xstring(&std::vswprintf, - 4 * sizeof(unsigned long), - L"%lu", __val); } - - [[__nodiscard__]] - inline wstring - to_wstring(long long __val) - { return __gnu_cxx::__to_xstring(&std::vswprintf, - 4 * sizeof(long long), - L"%lld", __val); } - - [[__nodiscard__]] - inline wstring - to_wstring(unsigned long long __val) - { return __gnu_cxx::__to_xstring(&std::vswprintf, - 4 * sizeof(unsigned long long), - L"%llu", __val); } - - [[__nodiscard__]] - inline wstring - to_wstring(float __val) - { - const int __n = - __gnu_cxx::__numeric_traits::__max_exponent10 + 20; - return __gnu_cxx::__to_xstring(&std::vswprintf, __n, - L"%f", __val); - } - - [[__nodiscard__]] - inline wstring - to_wstring(double __val) - { - const int __n = - __gnu_cxx::__numeric_traits::__max_exponent10 + 20; - return __gnu_cxx::__to_xstring(&std::vswprintf, __n, - L"%f", __val); - } - - [[__nodiscard__]] - inline wstring - to_wstring(long double __val) - { - const int __n = - __gnu_cxx::__numeric_traits::__max_exponent10 + 20; - return __gnu_cxx::__to_xstring(&std::vswprintf, __n, - L"%Lf", __val); - } - - - -} - -} - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - template, _Alloc>> - struct __str_hash_base - : public __hash_base - { - [[__nodiscard__]] - size_t - operator()(const _StrT& __s) const noexcept - { return _Hash_impl::hash(__s.data(), __s.length() * sizeof(_CharT)); } - }; - - - - template - struct hash, _Alloc>> - : public __str_hash_base - { }; - - - template - struct hash, _Alloc>> - : public __str_hash_base - { }; - - template - struct __is_fast_hash, - _Alloc>>> - : std::false_type - { }; -# 4428 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - template - struct hash, _Alloc>> - : public __str_hash_base - { }; - - - template - struct hash, _Alloc>> - : public __str_hash_base - { }; - - - - template<> struct __is_fast_hash> : std::false_type { }; - template<> struct __is_fast_hash> : std::false_type { }; - template<> struct __is_fast_hash> : std::false_type { }; - template<> struct __is_fast_hash> : std::false_type { }; -# 4460 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - inline namespace literals - { - inline namespace string_literals - { -#pragma GCC diagnostic push - - - - - - - - - __attribute ((__abi_tag__ ("cxx11"))) - inline basic_string - operator""s(const char* __str, size_t __len) - { return basic_string{__str, __len}; } - - __attribute ((__abi_tag__ ("cxx11"))) - inline basic_string - operator""s(const wchar_t* __str, size_t __len) - { return basic_string{__str, __len}; } -# 4490 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.h" 3 - __attribute ((__abi_tag__ ("cxx11"))) - inline basic_string - operator""s(const char16_t* __str, size_t __len) - { return basic_string{__str, __len}; } - - __attribute ((__abi_tag__ ("cxx11"))) - inline basic_string - operator""s(const char32_t* __str, size_t __len) - { return basic_string{__str, __len}; } - - -#pragma GCC diagnostic pop - } - } - - - namespace __detail::__variant - { - template struct _Never_valueless_alt; - - - - template - struct _Never_valueless_alt> - : __and_< - is_nothrow_move_constructible>, - is_nothrow_move_assignable> - >::type - { }; - } - - - - -} -# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 1 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template - const typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>::npos; - - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - swap(basic_string& __s) noexcept - { - if (this == std::__addressof(__s)) - return; - - _Alloc_traits::_S_on_swap(_M_get_allocator(), __s._M_get_allocator()); - - if (_M_is_local()) - if (__s._M_is_local()) - { - if (length() && __s.length()) - { - _CharT __tmp_data[_S_local_capacity + 1]; - traits_type::copy(__tmp_data, __s._M_local_buf, - __s.length() + 1); - traits_type::copy(__s._M_local_buf, _M_local_buf, - length() + 1); - traits_type::copy(_M_local_buf, __tmp_data, - __s.length() + 1); - } - else if (__s.length()) - { - traits_type::copy(_M_local_buf, __s._M_local_buf, - __s.length() + 1); - _M_length(__s.length()); - __s._M_set_length(0); - return; - } - else if (length()) - { - traits_type::copy(__s._M_local_buf, _M_local_buf, - length() + 1); - __s._M_length(length()); - _M_set_length(0); - return; - } - } - else - { - const size_type __tmp_capacity = __s._M_allocated_capacity; - traits_type::copy(__s._M_local_buf, _M_local_buf, - length() + 1); - _M_data(__s._M_data()); - __s._M_data(__s._M_local_buf); - _M_capacity(__tmp_capacity); - } - else - { - const size_type __tmp_capacity = _M_allocated_capacity; - if (__s._M_is_local()) - { - traits_type::copy(_M_local_buf, __s._M_local_buf, - __s.length() + 1); - __s._M_data(_M_data()); - _M_data(_M_local_buf); - } - else - { - pointer __tmp_ptr = _M_data(); - _M_data(__s._M_data()); - __s._M_data(__tmp_ptr); - _M_capacity(__s._M_allocated_capacity); - } - __s._M_capacity(__tmp_capacity); - } - - const size_type __tmp_length = length(); - _M_length(__s.length()); - __s._M_length(__tmp_length); - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::pointer - basic_string<_CharT, _Traits, _Alloc>:: - _M_create(size_type& __capacity, size_type __old_capacity) - { - - - if (__capacity > max_size()) - std::__throw_length_error(("basic_string::_M_create")); - - - - - if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) - { - __capacity = 2 * __old_capacity; - - if (__capacity > max_size()) - __capacity = max_size(); - } - - - - return _S_allocate(_M_get_allocator(), __capacity + 1); - } - - - - - - template - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - _M_construct(_InIterator __beg, _InIterator __end, - std::input_iterator_tag) - { - size_type __len = 0; - size_type __capacity = size_type(_S_local_capacity); - - pointer __p = _M_use_local_data(); - - while (__beg != __end && __len < __capacity) - { - __p[__len++] = *__beg; - ++__beg; - } - - struct _Guard - { - - explicit _Guard(basic_string* __s) : _M_guarded(__s) { } - - - ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); } - - basic_string* _M_guarded; - } __guard(this); - - while (__beg != __end) - { - if (__len == __capacity) - { - - __capacity = __len + 1; - pointer __another = _M_create(__capacity, __len); - this->_S_copy(__another, _M_data(), __len); - _M_dispose(); - _M_data(__another); - _M_capacity(__capacity); - } - traits_type::assign(_M_data()[__len++], *__beg); - ++__beg; - } - - __guard._M_guarded = 0; - - _M_set_length(__len); - } - - template - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - _M_construct(_InIterator __beg, _InIterator __end, - std::forward_iterator_tag) - { - size_type __dnew = static_cast(std::distance(__beg, __end)); - - if (__dnew > size_type(_S_local_capacity)) - { - _M_data(_M_create(__dnew, size_type(0))); - _M_capacity(__dnew); - } - else - _M_use_local_data(); - - - struct _Guard - { - - explicit _Guard(basic_string* __s) : _M_guarded(__s) { } - - - ~_Guard() { if (_M_guarded) _M_guarded->_M_dispose(); } - - basic_string* _M_guarded; - } __guard(this); - - this->_S_copy_chars(_M_data(), __beg, __end); - - __guard._M_guarded = 0; - - _M_set_length(__dnew); - } - - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - _M_construct(size_type __n, _CharT __c) - { - if (__n > size_type(_S_local_capacity)) - { - _M_data(_M_create(__n, size_type(0))); - _M_capacity(__n); - } - else - _M_use_local_data(); - - if (__n) - this->_S_assign(_M_data(), __n, __c); - - _M_set_length(__n); - } - - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - _M_assign(const basic_string& __str) - { - if (this != std::__addressof(__str)) - { - const size_type __rsize = __str.length(); - const size_type __capacity = capacity(); - - if (__rsize > __capacity) - { - size_type __new_capacity = __rsize; - pointer __tmp = _M_create(__new_capacity, __capacity); - _M_dispose(); - _M_data(__tmp); - _M_capacity(__new_capacity); - } - - if (__rsize) - this->_S_copy(_M_data(), __str._M_data(), __rsize); - - _M_set_length(__rsize); - } - } - - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - reserve(size_type __res) - { - const size_type __capacity = capacity(); - - - - - if (__res <= __capacity) - return; - - pointer __tmp = _M_create(__res, __capacity); - this->_S_copy(__tmp, _M_data(), length() + 1); - _M_dispose(); - _M_data(__tmp); - _M_capacity(__res); - } - - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - _M_mutate(size_type __pos, size_type __len1, const _CharT* __s, - size_type __len2) - { - const size_type __how_much = length() - __pos - __len1; - - size_type __new_capacity = length() + __len2 - __len1; - pointer __r = _M_create(__new_capacity, capacity()); - - if (__pos) - this->_S_copy(__r, _M_data(), __pos); - if (__s && __len2) - this->_S_copy(__r + __pos, __s, __len2); - if (__how_much) - this->_S_copy(__r + __pos + __len2, - _M_data() + __pos + __len1, __how_much); - - _M_dispose(); - _M_data(__r); - _M_capacity(__new_capacity); - } - - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - _M_erase(size_type __pos, size_type __n) - { - const size_type __how_much = length() - __pos - __n; - - if (__how_much && __n) - this->_S_move(_M_data() + __pos, _M_data() + __pos + __n, __how_much); - - _M_set_length(length() - __n); - } - - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - reserve() - { - if (_M_is_local()) - return; - - const size_type __length = length(); - const size_type __capacity = _M_allocated_capacity; - - if (__length <= size_type(_S_local_capacity)) - { - this->_S_copy(_M_use_local_data(), _M_data(), __length + 1); - _M_destroy(__capacity); - _M_data(_M_local_data()); - } - - else if (__length < __capacity) - try - { - pointer __tmp = _S_allocate(_M_get_allocator(), __length + 1); - this->_S_copy(__tmp, _M_data(), __length + 1); - _M_dispose(); - _M_data(__tmp); - _M_capacity(__length); - } - catch (const __cxxabiv1::__forced_unwind&) - { throw; } - catch (...) - { } - - } - - template - - void - basic_string<_CharT, _Traits, _Alloc>:: - resize(size_type __n, _CharT __c) - { - const size_type __size = this->size(); - if (__size < __n) - this->append(__n - __size, __c); - else if (__n < __size) - this->_M_set_length(__n); - } - - template - - basic_string<_CharT, _Traits, _Alloc>& - basic_string<_CharT, _Traits, _Alloc>:: - _M_append(const _CharT* __s, size_type __n) - { - const size_type __len = __n + this->size(); - - if (__len <= this->capacity()) - { - if (__n) - this->_S_copy(this->_M_data() + this->size(), __s, __n); - } - else - this->_M_mutate(this->size(), size_type(0), __s, __n); - - this->_M_set_length(__len); - return *this; - } - - template - template - - basic_string<_CharT, _Traits, _Alloc>& - basic_string<_CharT, _Traits, _Alloc>:: - _M_replace_dispatch(const_iterator __i1, const_iterator __i2, - _InputIterator __k1, _InputIterator __k2, - std::__false_type) - { - - - const basic_string __s(__k1, __k2, this->get_allocator()); - const size_type __n1 = __i2 - __i1; - return _M_replace(__i1 - begin(), __n1, __s._M_data(), - __s.size()); - } - - template - - basic_string<_CharT, _Traits, _Alloc>& - basic_string<_CharT, _Traits, _Alloc>:: - _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, - _CharT __c) - { - _M_check_length(__n1, __n2, "basic_string::_M_replace_aux"); - - const size_type __old_size = this->size(); - const size_type __new_size = __old_size + __n2 - __n1; - - if (__new_size <= this->capacity()) - { - pointer __p = this->_M_data() + __pos1; - - const size_type __how_much = __old_size - __pos1 - __n1; - if (__how_much && __n1 != __n2) - this->_S_move(__p + __n2, __p + __n1, __how_much); - } - else - this->_M_mutate(__pos1, __n1, 0, __n2); - - if (__n2) - this->_S_assign(this->_M_data() + __pos1, __n2, __c); - - this->_M_set_length(__new_size); - return *this; - } - - template - __attribute__((__noinline__, __noclone__, __cold__)) void - basic_string<_CharT, _Traits, _Alloc>:: - _M_replace_cold(pointer __p, size_type __len1, const _CharT* __s, - const size_type __len2, const size_type __how_much) - { - - if (__len2 && __len2 <= __len1) - this->_S_move(__p, __s, __len2); - if (__how_much && __len1 != __len2) - this->_S_move(__p + __len2, __p + __len1, __how_much); - if (__len2 > __len1) - { - if (__s + __len2 <= __p + __len1) - this->_S_move(__p, __s, __len2); - else if (__s >= __p + __len1) - { - - - const size_type __poff = (__s - __p) + (__len2 - __len1); - this->_S_copy(__p, __p + __poff, __len2); - } - else - { - const size_type __nleft = (__p + __len1) - __s; - this->_S_move(__p, __s, __nleft); - this->_S_copy(__p + __nleft, __p + __len2, __len2 - __nleft); - } - } - } - - template - - basic_string<_CharT, _Traits, _Alloc>& - basic_string<_CharT, _Traits, _Alloc>:: - _M_replace(size_type __pos, size_type __len1, const _CharT* __s, - const size_type __len2) - { - _M_check_length(__len1, __len2, "basic_string::_M_replace"); - - const size_type __old_size = this->size(); - const size_type __new_size = __old_size + __len2 - __len1; - - if (__new_size <= this->capacity()) - { - pointer __p = this->_M_data() + __pos; - - const size_type __how_much = __old_size - __pos - __len1; -# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 - if (__builtin_expect(_M_disjunct(__s), true)) - { - if (__how_much && __len1 != __len2) - this->_S_move(__p + __len2, __p + __len1, __how_much); - if (__len2) - this->_S_copy(__p, __s, __len2); - } - else - _M_replace_cold(__p, __len1, __s, __len2, __how_much); - } - else - this->_M_mutate(__pos, __len1, __s, __len2); - - this->_M_set_length(__new_size); - return *this; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - copy(_CharT* __s, size_type __n, size_type __pos) const - { - _M_check(__pos, "basic_string::copy"); - __n = _M_limit(__pos, __n); - ; - if (__n) - _S_copy(__s, _M_data() + __pos, __n); - - return __n; - } -# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find(const _CharT* __s, size_type __pos, size_type __n) const - noexcept - { - ; - const size_type __size = this->size(); - - if (__n == 0) - return __pos <= __size ? __pos : npos; - if (__pos >= __size) - return npos; - - const _CharT __elem0 = __s[0]; - const _CharT* const __data = data(); - const _CharT* __first = __data + __pos; - const _CharT* const __last = __data + __size; - size_type __len = __size - __pos; - - while (__len >= __n) - { - - __first = traits_type::find(__first, __len - __n + 1, __elem0); - if (!__first) - return npos; - - - - if (traits_type::compare(__first, __s, __n) == 0) - return __first - __data; - __len = __last - ++__first; - } - return npos; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find(_CharT __c, size_type __pos) const noexcept - { - size_type __ret = npos; - const size_type __size = this->size(); - if (__pos < __size) - { - const _CharT* __data = _M_data(); - const size_type __n = __size - __pos; - const _CharT* __p = traits_type::find(__data + __pos, __n, __c); - if (__p) - __ret = __p - __data; - } - return __ret; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - rfind(const _CharT* __s, size_type __pos, size_type __n) const - noexcept - { - ; - const size_type __size = this->size(); - if (__n <= __size) - { - __pos = std::min(size_type(__size - __n), __pos); - const _CharT* __data = _M_data(); - do - { - if (traits_type::compare(__data + __pos, __s, __n) == 0) - return __pos; - } - while (__pos-- > 0); - } - return npos; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - rfind(_CharT __c, size_type __pos) const noexcept - { - size_type __size = this->size(); - if (__size) - { - if (--__size > __pos) - __size = __pos; - for (++__size; __size-- > 0; ) - if (traits_type::eq(_M_data()[__size], __c)) - return __size; - } - return npos; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_first_of(const _CharT* __s, size_type __pos, size_type __n) const - noexcept - { - ; - for (; __n && __pos < this->size(); ++__pos) - { - const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]); - if (__p) - return __pos; - } - return npos; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_last_of(const _CharT* __s, size_type __pos, size_type __n) const - noexcept - { - ; - size_type __size = this->size(); - if (__size && __n) - { - if (--__size > __pos) - __size = __pos; - do - { - if (traits_type::find(__s, __n, _M_data()[__size])) - return __size; - } - while (__size-- != 0); - } - return npos; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const - noexcept - { - ; - for (; __pos < this->size(); ++__pos) - if (!traits_type::find(__s, __n, _M_data()[__pos])) - return __pos; - return npos; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_first_not_of(_CharT __c, size_type __pos) const noexcept - { - for (; __pos < this->size(); ++__pos) - if (!traits_type::eq(_M_data()[__pos], __c)) - return __pos; - return npos; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const - noexcept - { - ; - size_type __size = this->size(); - if (__size) - { - if (--__size > __pos) - __size = __pos; - do - { - if (!traits_type::find(__s, __n, _M_data()[__size])) - return __size; - } - while (__size--); - } - return npos; - } - - template - - typename basic_string<_CharT, _Traits, _Alloc>::size_type - basic_string<_CharT, _Traits, _Alloc>:: - find_last_not_of(_CharT __c, size_type __pos) const noexcept - { - size_type __size = this->size(); - if (__size) - { - if (--__size > __pos) - __size = __pos; - do - { - if (!traits_type::eq(_M_data()[__size], __c)) - return __size; - } - while (__size--); - } - return npos; - } - - - - - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __in, - basic_string<_CharT, _Traits, _Alloc>& __str) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef basic_string<_CharT, _Traits, _Alloc> __string_type; - typedef typename __istream_type::ios_base __ios_base; - typedef typename __istream_type::int_type __int_type; - typedef typename __string_type::size_type __size_type; - typedef ctype<_CharT> __ctype_type; - typedef typename __ctype_type::ctype_base __ctype_base; - - __size_type __extracted = 0; - typename __ios_base::iostate __err = __ios_base::goodbit; - typename __istream_type::sentry __cerb(__in, false); - if (__cerb) - { - try - { - - __str.erase(); - _CharT __buf[128]; - __size_type __len = 0; - const streamsize __w = __in.width(); - const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) - : __str.max_size(); - const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); - const __int_type __eof = _Traits::eof(); - __int_type __c = __in.rdbuf()->sgetc(); - - while (__extracted < __n - && !_Traits::eq_int_type(__c, __eof) - && !__ct.is(__ctype_base::space, - _Traits::to_char_type(__c))) - { - if (__len == sizeof(__buf) / sizeof(_CharT)) - { - __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); - __len = 0; - } - __buf[__len++] = _Traits::to_char_type(__c); - ++__extracted; - __c = __in.rdbuf()->snextc(); - } - __str.append(__buf, __len); - - if (__extracted < __n && _Traits::eq_int_type(__c, __eof)) - __err |= __ios_base::eofbit; - __in.width(0); - } - catch(__cxxabiv1::__forced_unwind&) - { - __in._M_setstate(__ios_base::badbit); - throw; - } - catch(...) - { - - - - __in._M_setstate(__ios_base::badbit); - } - } - - if (!__extracted) - __err |= __ios_base::failbit; - if (__err) - __in.setstate(__err); - return __in; - } - - template - basic_istream<_CharT, _Traits>& - getline(basic_istream<_CharT, _Traits>& __in, - basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef basic_string<_CharT, _Traits, _Alloc> __string_type; - typedef typename __istream_type::ios_base __ios_base; - typedef typename __istream_type::int_type __int_type; - typedef typename __string_type::size_type __size_type; - - __size_type __extracted = 0; - const __size_type __n = __str.max_size(); - typename __ios_base::iostate __err = __ios_base::goodbit; - typename __istream_type::sentry __cerb(__in, true); - if (__cerb) - { - try - { - __str.erase(); - const __int_type __idelim = _Traits::to_int_type(__delim); - const __int_type __eof = _Traits::eof(); - __int_type __c = __in.rdbuf()->sgetc(); - - while (__extracted < __n - && !_Traits::eq_int_type(__c, __eof) - && !_Traits::eq_int_type(__c, __idelim)) - { - __str += _Traits::to_char_type(__c); - ++__extracted; - __c = __in.rdbuf()->snextc(); - } - - if (_Traits::eq_int_type(__c, __eof)) - __err |= __ios_base::eofbit; - else if (_Traits::eq_int_type(__c, __idelim)) - { - ++__extracted; - __in.rdbuf()->sbumpc(); - } - else - __err |= __ios_base::failbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - __in._M_setstate(__ios_base::badbit); - throw; - } - catch(...) - { - - - - __in._M_setstate(__ios_base::badbit); - } - } - if (!__extracted) - __err |= __ios_base::failbit; - if (__err) - __in.setstate(__err); - return __in; - } -# 963 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 - extern template class basic_string; -# 976 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 - extern template - basic_istream& - operator>>(basic_istream&, string&); - extern template - basic_ostream& - operator<<(basic_ostream&, const string&); - extern template - basic_istream& - getline(basic_istream&, string&, char); - extern template - basic_istream& - getline(basic_istream&, string&); - - - - extern template class basic_string; -# 1002 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_string.tcc" 3 - extern template - basic_istream& - operator>>(basic_istream&, wstring&); - extern template - basic_ostream& - operator<<(basic_ostream&, const wstring&); - extern template - basic_istream& - getline(basic_istream&, wstring&, wchar_t); - extern template - basic_istream& - getline(basic_istream&, wstring&); - - - - -} -# 56 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 1 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 - - - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 -# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 2 3 - -extern "C++" -{ - -namespace std -{ - - using ::max_align_t; -} - - - -namespace std -{ - - - - - enum class byte : unsigned char {}; - - template struct __byte_operand { }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - - - - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; -# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - - template - using __byte_op_t = typename __byte_operand<_IntegerType>::__type; - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType> - operator<<(byte __b, _IntegerType __shift) noexcept - { return (byte)(unsigned char)((unsigned)__b << __shift); } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType> - operator>>(byte __b, _IntegerType __shift) noexcept - { return (byte)(unsigned char)((unsigned)__b >> __shift); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator|(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator&(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator^(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator~(byte __b) noexcept - { return (byte)(unsigned char)~(unsigned)__b; } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType>& - operator<<=(byte& __b, _IntegerType __shift) noexcept - { return __b = __b << __shift; } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType>& - operator>>=(byte& __b, _IntegerType __shift) noexcept - { return __b = __b >> __shift; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator|=(byte& __l, byte __r) noexcept - { return __l = __l | __r; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator&=(byte& __l, byte __r) noexcept - { return __l = __l & __r; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator^=(byte& __l, byte __r) noexcept - { return __l = __l ^ __r; } - - template - [[nodiscard,__gnu__::__always_inline__]] - constexpr _IntegerType - to_integer(__byte_op_t<_IntegerType> __b) noexcept - { return _IntegerType(__b); } - - -} - -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - struct __erased_type { }; - - - - - template - using __is_erased_or_convertible - = __or_, is_same<_Tp, __erased_type>>; - - - struct allocator_arg_t { explicit allocator_arg_t() = default; }; - - inline constexpr allocator_arg_t allocator_arg = - allocator_arg_t(); - - template> - struct __uses_allocator_helper - : false_type { }; - - template - struct __uses_allocator_helper<_Tp, _Alloc, - __void_t> - : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type - { }; - - - template - struct uses_allocator - : __uses_allocator_helper<_Tp, _Alloc>::type - { }; - - struct __uses_alloc_base { }; - - struct __uses_alloc0 : __uses_alloc_base - { - struct _Sink { void operator=(const void*) { } } _M_a; - }; - - template - struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; - - template - struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; - - template - struct __uses_alloc; - - template - struct __uses_alloc - : __conditional_t< - is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, - __uses_alloc1<_Alloc>, - __uses_alloc2<_Alloc>> - { - - - static_assert(__or_< - is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, - is_constructible<_Tp, _Args..., const _Alloc&>>::value, - "construction with an allocator must be possible" - " if uses_allocator is true"); - }; - - template - struct __uses_alloc - : __uses_alloc0 { }; - - template - using __uses_alloc_t = - __uses_alloc::value, _Tp, _Alloc, _Args...>; - - template - - inline __uses_alloc_t<_Tp, _Alloc, _Args...> - __use_alloc(const _Alloc& __a) - { - __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; - __ret._M_a = std::__addressof(__a); - return __ret; - } - - template - void - __use_alloc(const _Alloc&&) = delete; - - - template - inline constexpr bool uses_allocator_v = - uses_allocator<_Tp, _Alloc>::value; - - - template class _Predicate, - typename _Tp, typename _Alloc, typename... _Args> - struct __is_uses_allocator_predicate - : __conditional_t::value, - __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, - _Predicate<_Tp, _Args..., _Alloc>>, - _Predicate<_Tp, _Args...>> { }; - - template - struct __is_uses_allocator_constructible - : __is_uses_allocator_predicate - { }; - - - template - inline constexpr bool __is_uses_allocator_constructible_v = - __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; - - - template - struct __is_nothrow_uses_allocator_constructible - : __is_uses_allocator_predicate - { }; - - - - template - inline constexpr bool - __is_nothrow_uses_allocator_constructible_v = - __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; - - - template - void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr, - _Args&&... __args) - { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } - - template - void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr, - _Args&&... __args) - { - ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a, - std::forward<_Args>(__args)...); - } - - template - void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr, - _Args&&... __args) - { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); } - - template - void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr, - _Args&&... __args) - { - std::__uses_allocator_construct_impl( - std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr, - std::forward<_Args>(__args)...); - } - - - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator_args.h" 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - class tuple; - - template - struct __is_empty_non_tuple : is_empty<_Tp> { }; - - - template - struct __is_empty_non_tuple> : false_type { }; - - - template - using __empty_not_final - = __conditional_t<__is_final(_Tp), false_type, - __is_empty_non_tuple<_Tp>>; - - template::value> - struct _Head_base; - - - template - struct _Head_base<_Idx, _Head, true> - { - constexpr _Head_base() - : _M_head_impl() { } - - constexpr _Head_base(const _Head& __h) - : _M_head_impl(__h) { } - - constexpr _Head_base(const _Head_base&) = default; - constexpr _Head_base(_Head_base&&) = default; - - template - constexpr _Head_base(_UHead&& __h) - : _M_head_impl(std::forward<_UHead>(__h)) { } - - - _Head_base(allocator_arg_t, __uses_alloc0) - : _M_head_impl() { } - - template - - _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) - : _M_head_impl(allocator_arg, *__a._M_a) { } - - template - - _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) - : _M_head_impl(*__a._M_a) { } - - template - - _Head_base(__uses_alloc0, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead)) { } - - template - - _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) - { } - - template - - _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } - - static constexpr _Head& - _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } - - static constexpr const _Head& - _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } - - [[__no_unique_address__]] _Head _M_head_impl; - }; -# 187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - struct _Head_base<_Idx, _Head, false> - { - constexpr _Head_base() - : _M_head_impl() { } - - constexpr _Head_base(const _Head& __h) - : _M_head_impl(__h) { } - - constexpr _Head_base(const _Head_base&) = default; - constexpr _Head_base(_Head_base&&) = default; - - template - constexpr _Head_base(_UHead&& __h) - : _M_head_impl(std::forward<_UHead>(__h)) { } - - - _Head_base(allocator_arg_t, __uses_alloc0) - : _M_head_impl() { } - - template - - _Head_base(allocator_arg_t, __uses_alloc1<_Alloc> __a) - : _M_head_impl(allocator_arg, *__a._M_a) { } - - template - - _Head_base(allocator_arg_t, __uses_alloc2<_Alloc> __a) - : _M_head_impl(*__a._M_a) { } - - template - - _Head_base(__uses_alloc0, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead)) { } - - template - - _Head_base(__uses_alloc1<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(allocator_arg, *__a._M_a, std::forward<_UHead>(__uhead)) - { } - - template - - _Head_base(__uses_alloc2<_Alloc> __a, _UHead&& __uhead) - : _M_head_impl(std::forward<_UHead>(__uhead), *__a._M_a) { } - - static constexpr _Head& - _M_head(_Head_base& __b) noexcept { return __b._M_head_impl; } - - static constexpr const _Head& - _M_head(const _Head_base& __b) noexcept { return __b._M_head_impl; } - - _Head _M_head_impl; - }; -# 250 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - struct _Tuple_impl; - - - - - - - template - struct _Tuple_impl<_Idx, _Head, _Tail...> - : public _Tuple_impl<_Idx + 1, _Tail...>, - private _Head_base<_Idx, _Head> - { - template friend struct _Tuple_impl; - - typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited; - typedef _Head_base<_Idx, _Head> _Base; - - static constexpr _Head& - _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - static constexpr const _Head& - _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - static constexpr _Inherited& - _M_tail(_Tuple_impl& __t) noexcept { return __t; } - - static constexpr const _Inherited& - _M_tail(const _Tuple_impl& __t) noexcept { return __t; } - - constexpr _Tuple_impl() - : _Inherited(), _Base() { } - - explicit constexpr - _Tuple_impl(const _Head& __head, const _Tail&... __tail) - : _Inherited(__tail...), _Base(__head) - { } - - template> - explicit constexpr - _Tuple_impl(_UHead&& __head, _UTail&&... __tail) - : _Inherited(std::forward<_UTail>(__tail)...), - _Base(std::forward<_UHead>(__head)) - { } - - constexpr _Tuple_impl(const _Tuple_impl&) = default; - - - - _Tuple_impl& operator=(const _Tuple_impl&) = delete; - - _Tuple_impl(_Tuple_impl&&) = default; - - template - constexpr - _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in) - : _Inherited(_Tuple_impl<_Idx, _UElements...>::_M_tail(__in)), - _Base(_Tuple_impl<_Idx, _UElements...>::_M_head(__in)) - { } - - template - constexpr - _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) - : _Inherited(std::move - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), - _Base(std::forward<_UHead> - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) - { } -# 338 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) - : _Inherited(__tag, __a), - _Base(__tag, __use_alloc<_Head>(__a)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Head& __head, const _Tail&... __tail) - : _Inherited(__tag, __a, __tail...), - _Base(__use_alloc<_Head, _Alloc, _Head>(__a), __head) - { } - - template> - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _UHead&& __head, _UTail&&... __tail) - : _Inherited(__tag, __a, std::forward<_UTail>(__tail)...), - _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead>(__head)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl& __in) - : _Inherited(__tag, __a, _M_tail(__in)), - _Base(__use_alloc<_Head, _Alloc, _Head>(__a), _M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl&& __in) - : _Inherited(__tag, __a, std::move(_M_tail(__in))), - _Base(__use_alloc<_Head, _Alloc, _Head>(__a), - std::forward<_Head>(_M_head(__in))) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl<_Idx, _UHead, _UTails...>& __in) - : _Inherited(__tag, __a, - _Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in)), - _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), - _Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl<_Idx, _UHead, _UTails...>&& __in) - : _Inherited(__tag, __a, std::move - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))), - _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead> - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in))) - { } -# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - void - _M_assign(const _Tuple_impl<_Idx, _UElements...>& __in) - { - _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in); - _M_tail(*this)._M_assign( - _Tuple_impl<_Idx, _UElements...>::_M_tail(__in)); - } - - template - - void - _M_assign(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in) - { - _M_head(*this) = std::forward<_UHead> - (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in)); - _M_tail(*this)._M_assign( - std::move(_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in))); - } -# 466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - protected: - - void - _M_swap(_Tuple_impl& __in) - { - using std::swap; - swap(_M_head(*this), _M_head(__in)); - _Inherited::_M_swap(_M_tail(__in)); - } -# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - template - struct _Tuple_impl<_Idx, _Head> - : private _Head_base<_Idx, _Head> - { - template friend struct _Tuple_impl; - - typedef _Head_base<_Idx, _Head> _Base; - - static constexpr _Head& - _M_head(_Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - static constexpr const _Head& - _M_head(const _Tuple_impl& __t) noexcept { return _Base::_M_head(__t); } - - constexpr - _Tuple_impl() - : _Base() { } - - explicit constexpr - _Tuple_impl(const _Head& __head) - : _Base(__head) - { } - - template - explicit constexpr - _Tuple_impl(_UHead&& __head) - : _Base(std::forward<_UHead>(__head)) - { } - - constexpr _Tuple_impl(const _Tuple_impl&) = default; - - - - _Tuple_impl& operator=(const _Tuple_impl&) = delete; - - - - - constexpr - _Tuple_impl(_Tuple_impl&& __in) - noexcept(is_nothrow_move_constructible<_Head>::value) - : _Base(static_cast<_Base&&>(__in)) - { } - - - template - constexpr - _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in) - : _Base(_Tuple_impl<_Idx, _UHead>::_M_head(__in)) - { } - - template - constexpr - _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in) - : _Base(std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) - { } -# 559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a) - : _Base(__tag, __use_alloc<_Head>(__a)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Head& __head) - : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), __head) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _UHead&& __head) - : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead>(__head)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl& __in) - : _Base(__use_alloc<_Head, _Alloc, const _Head&>(__a), _M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl&& __in) - : _Base(__use_alloc<_Head, _Alloc, _Head>(__a), - std::forward<_Head>(_M_head(__in))) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - const _Tuple_impl<_Idx, _UHead>& __in) - : _Base(__use_alloc<_Head, _Alloc, const _UHead&>(__a), - _Tuple_impl<_Idx, _UHead>::_M_head(__in)) - { } - - template - - _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a, - _Tuple_impl<_Idx, _UHead>&& __in) - : _Base(__use_alloc<_Head, _Alloc, _UHead>(__a), - std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in))) - { } -# 629 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - void - _M_assign(const _Tuple_impl<_Idx, _UHead>& __in) - { - _M_head(*this) = _Tuple_impl<_Idx, _UHead>::_M_head(__in); - } - - template - - void - _M_assign(_Tuple_impl<_Idx, _UHead>&& __in) - { - _M_head(*this) - = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in)); - } -# 663 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - protected: - - void - _M_swap(_Tuple_impl& __in) - { - using std::swap; - swap(_M_head(*this), _M_head(__in)); - } -# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - - template - struct _TupleConstraints - { - template - using __constructible = __and_...>; - - template - using __convertible = __and_...>; - - - - - template - static constexpr bool __is_implicitly_constructible() - { - return __and_<__constructible<_UTypes...>, - __convertible<_UTypes...> - >::value; - } - - - - - template - static constexpr bool __is_explicitly_constructible() - { - return __and_<__constructible<_UTypes...>, - __not_<__convertible<_UTypes...>> - >::value; - } - - static constexpr bool __is_implicitly_default_constructible() - { - return __and_... - >::value; - } - - static constexpr bool __is_explicitly_default_constructible() - { - return __and_..., - __not_<__and_< - std::__is_implicitly_default_constructible<_Types>...> - >>::value; - } - }; - - - - template - struct _TupleConstraints - { - template - static constexpr bool __is_implicitly_constructible() - { return false; } - - template - static constexpr bool __is_explicitly_constructible() - { return false; } - }; - - - template - class tuple : public _Tuple_impl<0, _Elements...> - { - typedef _Tuple_impl<0, _Elements...> _Inherited; - - template - using _TCC = _TupleConstraints<_Cond, _Elements...>; - - - template - using _ImplicitDefaultCtor = __enable_if_t< - _TCC<_Dummy>::__is_implicitly_default_constructible(), - bool>; - - - template - using _ExplicitDefaultCtor = __enable_if_t< - _TCC<_Dummy>::__is_explicitly_default_constructible(), - bool>; - - - template - using _ImplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_implicitly_constructible<_Args...>(), - bool>; - - - template - using _ExplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_explicitly_constructible<_Args...>(), - bool>; - - template - static constexpr - __enable_if_t - __assignable() - { return __and_...>::value; } - - - template - static constexpr bool __nothrow_assignable() - { - return - __and_...>::value; - } - - - template - static constexpr bool __nothrow_constructible() - { - return - __and_...>::value; - } - - - template - static constexpr bool __valid_args() - { - return sizeof...(_Elements) == 1 - && !is_same>::value; - } - - - template - static constexpr bool __valid_args() - { return (sizeof...(_Tail) + 2) == sizeof...(_Elements); } -# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template> - struct _UseOtherCtor - : false_type - { }; - - - template - struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Up>> - : __or_, is_constructible<_Tp, _Tuple>>::type - { }; - - - template - struct _UseOtherCtor<_Tuple, tuple<_Tp>, tuple<_Tp>> - : true_type - { }; - - - - - template - static constexpr bool __use_other_ctor() - { return _UseOtherCtor<_Tuple>::value; } -# 856 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - public: - template::value> = true> - constexpr - tuple() - noexcept(__and_...>::value) - : _Inherited() { } - - template::value> = false> - explicit constexpr - tuple() - noexcept(__and_...>::value) - : _Inherited() { } - - template= 1), - _ImplicitCtor<_NotEmpty, const _Elements&...> = true> - constexpr - tuple(const _Elements&... __elements) - noexcept(__nothrow_constructible()) - : _Inherited(__elements...) { } - - template= 1), - _ExplicitCtor<_NotEmpty, const _Elements&...> = false> - explicit constexpr - tuple(const _Elements&... __elements) - noexcept(__nothrow_constructible()) - : _Inherited(__elements...) { } - - template(), - _ImplicitCtor<_Valid, _UElements...> = true> - constexpr - tuple(_UElements&&... __elements) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(std::forward<_UElements>(__elements)...) { } - - template(), - _ExplicitCtor<_Valid, _UElements...> = false> - explicit constexpr - tuple(_UElements&&... __elements) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(std::forward<_UElements>(__elements)...) { } - - constexpr tuple(const tuple&) = default; - - constexpr tuple(tuple&&) = default; - - template&>(), - _ImplicitCtor<_Valid, const _UElements&...> = true> - constexpr - tuple(const tuple<_UElements...>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) - { } - - template&>(), - _ExplicitCtor<_Valid, const _UElements&...> = false> - explicit constexpr - tuple(const tuple<_UElements...>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) - { } - - template&&>(), - _ImplicitCtor<_Valid, _UElements...> = true> - constexpr - tuple(tuple<_UElements...>&& __in) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } - - template&&>(), - _ExplicitCtor<_Valid, _UElements...> = false> - explicit constexpr - tuple(tuple<_UElements...>&& __in) - noexcept(__nothrow_constructible<_UElements...>()) - : _Inherited(static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) { } -# 968 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template::value> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a) - : _Inherited(__tag, __a) { } - - template= 1), - _ImplicitCtor<_NotEmpty, const _Elements&...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _Elements&... __elements) - : _Inherited(__tag, __a, __elements...) { } - - template= 1), - _ExplicitCtor<_NotEmpty, const _Elements&...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _Elements&... __elements) - : _Inherited(__tag, __a, __elements...) { } - - template(), - _ImplicitCtor<_Valid, _UElements...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - _UElements&&... __elements) - : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) - { } - - template(), - _ExplicitCtor<_Valid, _UElements...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - _UElements&&... __elements) - : _Inherited(__tag, __a, std::forward<_UElements>(__elements)...) - { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) - : _Inherited(__tag, __a, static_cast(__in)) { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) - : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } - - template&>(), - _ImplicitCtor<_Valid, const _UElements&...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_UElements...>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template&>(), - _ExplicitCtor<_Valid, const _UElements&...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_UElements...>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template&&>(), - _ImplicitCtor<_Valid, _UElements...> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - tuple<_UElements...>&& __in) - : _Inherited(__tag, __a, - static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) - { } - - template&&>(), - _ExplicitCtor<_Valid, _UElements...> = false> - - explicit - tuple(allocator_arg_t __tag, const _Alloc& __a, - tuple<_UElements...>&& __in) - : _Inherited(__tag, __a, - static_cast<_Tuple_impl<0, _UElements...>&&>(__in)) - { } -# 1093 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - tuple& - operator=(__conditional_t<__assignable(), - const tuple&, - const __nonesuch&> __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - - tuple& - operator=(__conditional_t<__assignable<_Elements...>(), - tuple&&, - __nonesuch&&> __in) - noexcept(__nothrow_assignable<_Elements...>()) - { - this->_M_assign(std::move(__in)); - return *this; - } - - template - - __enable_if_t<__assignable(), tuple&> - operator=(const tuple<_UElements...>& __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - template - - __enable_if_t<__assignable<_UElements...>(), tuple&> - operator=(tuple<_UElements...>&& __in) - noexcept(__nothrow_assignable<_UElements...>()) - { - this->_M_assign(std::move(__in)); - return *this; - } -# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - void - swap(tuple& __in) - noexcept(__and_<__is_nothrow_swappable<_Elements>...>::value) - { _Inherited::_M_swap(__in); } -# 1192 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - template - tuple(_UTypes...) -> tuple<_UTypes...>; - template - tuple(pair<_T1, _T2>) -> tuple<_T1, _T2>; - template - tuple(allocator_arg_t, _Alloc, _UTypes...) -> tuple<_UTypes...>; - template - tuple(allocator_arg_t, _Alloc, pair<_T1, _T2>) -> tuple<_T1, _T2>; - template - tuple(allocator_arg_t, _Alloc, tuple<_UTypes...>) -> tuple<_UTypes...>; - - - - template<> - class tuple<> - { - public: - - void swap(tuple&) noexcept { } - - - - - - tuple() = default; - - template - - tuple(allocator_arg_t, const _Alloc&) noexcept { } - template - - tuple(allocator_arg_t, const _Alloc&, const tuple&) noexcept { } - }; - - - - template - class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2> - { - typedef _Tuple_impl<0, _T1, _T2> _Inherited; - - - template - using _ImplicitDefaultCtor = __enable_if_t< - _TupleConstraints<_Dummy, _U1, _U2>:: - __is_implicitly_default_constructible(), - bool>; - - - template - using _ExplicitDefaultCtor = __enable_if_t< - _TupleConstraints<_Dummy, _U1, _U2>:: - __is_explicitly_default_constructible(), - bool>; - - template - using _TCC = _TupleConstraints<_Dummy, _T1, _T2>; - - - template - using _ImplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_implicitly_constructible<_U1, _U2>(), - bool>; - - - template - using _ExplicitCtor = __enable_if_t< - _TCC<_Cond>::template __is_explicitly_constructible<_U1, _U2>(), - bool>; - - template - static constexpr bool __assignable() - { - return __and_, - is_assignable<_T2&, _U2>>::value; - } - - template - static constexpr bool __nothrow_assignable() - { - return __and_, - is_nothrow_assignable<_T2&, _U2>>::value; - } - - template - static constexpr bool __nothrow_constructible() - { - return __and_, - is_nothrow_constructible<_T2, _U2>>::value; - } - - static constexpr bool __nothrow_default_constructible() - { - return __and_, - is_nothrow_default_constructible<_T2>>::value; - } - - template - static constexpr bool __is_alloc_arg() - { return is_same<__remove_cvref_t<_U1>, allocator_arg_t>::value; } -# 1306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - public: - template = true> - constexpr - tuple() - noexcept(__nothrow_default_constructible()) - : _Inherited() { } - - template = false> - explicit constexpr - tuple() - noexcept(__nothrow_default_constructible()) - : _Inherited() { } - - template = true> - constexpr - tuple(const _T1& __a1, const _T2& __a2) - noexcept(__nothrow_constructible()) - : _Inherited(__a1, __a2) { } - - template = false> - explicit constexpr - tuple(const _T1& __a1, const _T2& __a2) - noexcept(__nothrow_constructible()) - : _Inherited(__a1, __a2) { } - - template(), _U1, _U2> = true> - constexpr - tuple(_U1&& __a1, _U2&& __a2) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } - - template(), _U1, _U2> = false> - explicit constexpr - tuple(_U1&& __a1, _U2&& __a2) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__a1), std::forward<_U2>(__a2)) { } - - constexpr tuple(const tuple&) = default; - - constexpr tuple(tuple&&) = default; - - template = true> - constexpr - tuple(const tuple<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) { } - - template = false> - explicit constexpr - tuple(const tuple<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(static_cast&>(__in)) { } - - template = true> - constexpr - tuple(tuple<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } - - template = false> - explicit constexpr - tuple(tuple<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) { } -# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template = true> - constexpr - tuple(const pair<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(__in.first, __in.second) { } - - template = false> - explicit constexpr - tuple(const pair<_U1, _U2>& __in) - noexcept(__nothrow_constructible()) - : _Inherited(__in.first, __in.second) { } - - template = true> - constexpr - tuple(pair<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } - - template = false> - explicit constexpr - tuple(pair<_U1, _U2>&& __in) - noexcept(__nothrow_constructible<_U1, _U2>()) - : _Inherited(std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } -# 1450 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template::value, _T1, _T2> = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a) - : _Inherited(__tag, __a) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _T1& __a1, const _T2& __a2) - : _Inherited(__tag, __a, __a1, __a2) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const _T1& __a1, const _T2& __a2) - : _Inherited(__tag, __a, __a1, __a2) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, _U1&& __a1, _U2&& __a2) - : _Inherited(__tag, __a, std::forward<_U1>(__a1), - std::forward<_U2>(__a2)) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - _U1&& __a1, _U2&& __a2) - : _Inherited(__tag, __a, std::forward<_U1>(__a1), - std::forward<_U2>(__a2)) { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in) - : _Inherited(__tag, __a, static_cast(__in)) { } - - template - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in) - : _Inherited(__tag, __a, static_cast<_Inherited&&>(__in)) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_U1, _U2>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const tuple<_U1, _U2>& __in) - : _Inherited(__tag, __a, - static_cast&>(__in)) - { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) - : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) - { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, tuple<_U1, _U2>&& __in) - : _Inherited(__tag, __a, static_cast<_Tuple_impl<0, _U1, _U2>&&>(__in)) - { } -# 1553 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const pair<_U1, _U2>& __in) - : _Inherited(__tag, __a, __in.first, __in.second) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, - const pair<_U1, _U2>& __in) - : _Inherited(__tag, __a, __in.first, __in.second) { } - - template = true> - - tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) - : _Inherited(__tag, __a, std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } - - template = false> - explicit - - tuple(allocator_arg_t __tag, const _Alloc& __a, pair<_U1, _U2>&& __in) - : _Inherited(__tag, __a, std::forward<_U1>(__in.first), - std::forward<_U2>(__in.second)) { } -# 1604 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - tuple& - operator=(__conditional_t<__assignable(), - const tuple&, - const __nonesuch&> __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - - tuple& - operator=(__conditional_t<__assignable<_T1, _T2>(), - tuple&&, - __nonesuch&&> __in) - noexcept(__nothrow_assignable<_T1, _T2>()) - { - this->_M_assign(std::move(__in)); - return *this; - } - - template - - __enable_if_t<__assignable(), tuple&> - operator=(const tuple<_U1, _U2>& __in) - noexcept(__nothrow_assignable()) - { - this->_M_assign(__in); - return *this; - } - - template - - __enable_if_t<__assignable<_U1, _U2>(), tuple&> - operator=(tuple<_U1, _U2>&& __in) - noexcept(__nothrow_assignable<_U1, _U2>()) - { - this->_M_assign(std::move(__in)); - return *this; - } -# 1683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - __enable_if_t<__assignable(), tuple&> - operator=(const pair<_U1, _U2>& __in) - noexcept(__nothrow_assignable()) - { - this->_M_head(*this) = __in.first; - this->_M_tail(*this)._M_head(*this) = __in.second; - return *this; - } - - template - - __enable_if_t<__assignable<_U1, _U2>(), tuple&> - operator=(pair<_U1, _U2>&& __in) - noexcept(__nothrow_assignable<_U1, _U2>()) - { - this->_M_head(*this) = std::forward<_U1>(__in.first); - this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second); - return *this; - } -# 1730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - void - swap(tuple& __in) - noexcept(__and_<__is_nothrow_swappable<_T1>, - __is_nothrow_swappable<_T2>>::value) - { _Inherited::_M_swap(__in); } -# 1744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - }; - - - - template - struct tuple_size> - : public integral_constant { }; - - - template - inline constexpr size_t tuple_size_v> - = sizeof...(_Types); - - template - inline constexpr size_t tuple_size_v> - = sizeof...(_Types); - - - - template - struct tuple_element<__i, tuple<_Types...>> - { - static_assert(__i < sizeof...(_Types), "tuple index must be in range"); - - using type = typename _Nth_type<__i, _Types...>::type; - }; - - template - constexpr _Head& - __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept - { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } - - template - constexpr const _Head& - __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept - { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); } - - - template - __enable_if_t<(__i >= sizeof...(_Types))> - __get_helper(const tuple<_Types...>&) = delete; - - - template - constexpr __tuple_element_t<__i, tuple<_Elements...>>& - get(tuple<_Elements...>& __t) noexcept - { return std::__get_helper<__i>(__t); } - - - template - constexpr const __tuple_element_t<__i, tuple<_Elements...>>& - get(const tuple<_Elements...>& __t) noexcept - { return std::__get_helper<__i>(__t); } - - - template - constexpr __tuple_element_t<__i, tuple<_Elements...>>&& - get(tuple<_Elements...>&& __t) noexcept - { - typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; - return std::forward<__element_type>(std::__get_helper<__i>(__t)); - } - - - template - constexpr const __tuple_element_t<__i, tuple<_Elements...>>&& - get(const tuple<_Elements...>&& __t) noexcept - { - typedef __tuple_element_t<__i, tuple<_Elements...>> __element_type; - return std::forward(std::__get_helper<__i>(__t)); - } - - - - template - constexpr __enable_if_t<(__i >= sizeof...(_Elements))> - get(const tuple<_Elements...>&) = delete; - - - - - - - - template - constexpr _Tp& - get(tuple<_Types...>& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::__get_helper<__idx>(__t); - } - - - template - constexpr _Tp&& - get(tuple<_Types...>&& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::forward<_Tp>(std::__get_helper<__idx>(__t)); - } - - - template - constexpr const _Tp& - get(const tuple<_Types...>& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::__get_helper<__idx>(__t); - } - - - - template - constexpr const _Tp&& - get(const tuple<_Types...>&& __t) noexcept - { - constexpr size_t __idx = __find_uniq_type_in_pack<_Tp, _Types...>(); - static_assert(__idx < sizeof...(_Types), - "the type T in std::get must occur exactly once in the tuple"); - return std::forward(std::__get_helper<__idx>(__t)); - } - - - - template - struct __tuple_compare - { - static constexpr bool - __eq(const _Tp& __t, const _Up& __u) - { - return bool(std::get<__i>(__t) == std::get<__i>(__u)) - && __tuple_compare<_Tp, _Up, __i + 1, __size>::__eq(__t, __u); - } - - static constexpr bool - __less(const _Tp& __t, const _Up& __u) - { - return bool(std::get<__i>(__t) < std::get<__i>(__u)) - || (!bool(std::get<__i>(__u) < std::get<__i>(__t)) - && __tuple_compare<_Tp, _Up, __i + 1, __size>::__less(__t, __u)); - } - }; - - template - struct __tuple_compare<_Tp, _Up, __size, __size> - { - static constexpr bool - __eq(const _Tp&, const _Up&) { return true; } - - static constexpr bool - __less(const _Tp&, const _Up&) { return false; } - }; - - template - constexpr bool - operator==(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { - static_assert(sizeof...(_TElements) == sizeof...(_UElements), - "tuple objects can only be compared if they have equal sizes."); - using __compare = __tuple_compare, - tuple<_UElements...>, - 0, sizeof...(_TElements)>; - return __compare::__eq(__t, __u); - } -# 1945 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - constexpr bool - operator<(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { - static_assert(sizeof...(_TElements) == sizeof...(_UElements), - "tuple objects can only be compared if they have equal sizes."); - using __compare = __tuple_compare, - tuple<_UElements...>, - 0, sizeof...(_TElements)>; - return __compare::__less(__t, __u); - } - - template - constexpr bool - operator!=(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return !(__t == __u); } - - template - constexpr bool - operator>(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return __u < __t; } - - template - constexpr bool - operator<=(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return !(__u < __t); } - - template - constexpr bool - operator>=(const tuple<_TElements...>& __t, - const tuple<_UElements...>& __u) - { return !(__t < __u); } - - - - - template - constexpr tuple::__type...> - make_tuple(_Elements&&... __args) - { - typedef tuple::__type...> - __result_type; - return __result_type(std::forward<_Elements>(__args)...); - } - - - - - template - constexpr tuple<_Elements&&...> - forward_as_tuple(_Elements&&... __args) noexcept - { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); } - - - - - template struct array; - - template - constexpr _Tp& - get(array<_Tp, _Nm>&) noexcept; - - template - constexpr _Tp&& - get(array<_Tp, _Nm>&&) noexcept; - - template - constexpr const _Tp& - get(const array<_Tp, _Nm>&) noexcept; - - template - constexpr const _Tp&& - get(const array<_Tp, _Nm>&&) noexcept; - - - template - struct __make_tuple_impl; - - template - struct __make_tuple_impl<_Idx, tuple<_Tp...>, _Tuple, _Nm> - : __make_tuple_impl<_Idx + 1, - tuple<_Tp..., __tuple_element_t<_Idx, _Tuple>>, - _Tuple, _Nm> - { }; - - template - struct __make_tuple_impl<_Nm, tuple<_Tp...>, _Tuple, _Nm> - { - typedef tuple<_Tp...> __type; - }; - - template - struct __do_make_tuple - : __make_tuple_impl<0, tuple<>, _Tuple, tuple_size<_Tuple>::value> - { }; - - - template - struct __make_tuple - : public __do_make_tuple<__remove_cvref_t<_Tuple>> - { }; - - - template - struct __combine_tuples; - - template<> - struct __combine_tuples<> - { - typedef tuple<> __type; - }; - - template - struct __combine_tuples> - { - typedef tuple<_Ts...> __type; - }; - - template - struct __combine_tuples, tuple<_T2s...>, _Rem...> - { - typedef typename __combine_tuples, - _Rem...>::__type __type; - }; - - - template - struct __tuple_cat_result - { - typedef typename __combine_tuples - ::__type...>::__type __type; - }; - - - - template - struct __make_1st_indices; - - template<> - struct __make_1st_indices<> - { - typedef _Index_tuple<> __type; - }; - - template - struct __make_1st_indices<_Tp, _Tpls...> - { - typedef typename _Build_index_tuple::type>::value>::__type __type; - }; - - - - - template - struct __tuple_concater; - - template - struct __tuple_concater<_Ret, _Index_tuple<_Is...>, _Tp, _Tpls...> - { - template - static constexpr _Ret - _S_do(_Tp&& __tp, _Tpls&&... __tps, _Us&&... __us) - { - typedef typename __make_1st_indices<_Tpls...>::__type __idx; - typedef __tuple_concater<_Ret, __idx, _Tpls...> __next; - return __next::_S_do(std::forward<_Tpls>(__tps)..., - std::forward<_Us>(__us)..., - std::get<_Is>(std::forward<_Tp>(__tp))...); - } - }; - - template - struct __tuple_concater<_Ret, _Index_tuple<>> - { - template - static constexpr _Ret - _S_do(_Us&&... __us) - { - return _Ret(std::forward<_Us>(__us)...); - } - }; - - template - struct __is_tuple_like_impl> : true_type - { }; - - - - template...>::value>::type> - constexpr auto - tuple_cat(_Tpls&&... __tpls) - -> typename __tuple_cat_result<_Tpls...>::__type - { - typedef typename __tuple_cat_result<_Tpls...>::__type __ret; - typedef typename __make_1st_indices<_Tpls...>::__type __idx; - typedef __tuple_concater<__ret, __idx, _Tpls...> __concater; - return __concater::_S_do(std::forward<_Tpls>(__tpls)...); - } - - - - - template - constexpr tuple<_Elements&...> - tie(_Elements&... __args) noexcept - { return tuple<_Elements&...>(__args...); } - - - template - - inline - - - typename enable_if<__and_<__is_swappable<_Elements>...>::value - >::type - - - - swap(tuple<_Elements...>& __x, tuple<_Elements...>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } -# 2184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - - typename enable_if...>::value>::type - swap(tuple<_Elements...>&, tuple<_Elements...>&) = delete; - - - - - - - struct _Swallow_assign - { - template - constexpr const _Swallow_assign& - operator=(const _Tp&) const - { return *this; } - }; -# 2219 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - inline constexpr _Swallow_assign ignore{}; - - - template - struct uses_allocator, _Alloc> : true_type { }; -# 2234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 - template - template - - inline - pair<_T1, _T2>:: - pair(piecewise_construct_t, - tuple<_Args1...> __first, tuple<_Args2...> __second) - : pair(__first, __second, - typename _Build_index_tuple::__type(), - typename _Build_index_tuple::__type()) - { } - - template - template - inline - pair<_T1, _T2>:: - pair(tuple<_Args1...>& __tuple1, tuple<_Args2...>& __tuple2, - _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>) - : first(std::forward<_Args1>(std::get<_Indexes1>(__tuple1))...), - second(std::forward<_Args2>(std::get<_Indexes2>(__tuple2))...) - { } - - - - - - - - template class _Trait, typename _Tp, typename _Tuple> - inline constexpr bool __unpack_std_tuple = false; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>> - = _Trait<_Tp, _Up...>::value; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, tuple<_Up...>&> - = _Trait<_Tp, _Up&...>::value; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>> - = _Trait<_Tp, const _Up...>::value; - - template class _Trait, typename _Tp, typename... _Up> - inline constexpr bool __unpack_std_tuple<_Trait, _Tp, const tuple<_Up...>&> - = _Trait<_Tp, const _Up&...>::value; - - - - template - constexpr decltype(auto) - __apply_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Idx...>) - { - return std::__invoke(std::forward<_Fn>(__f), - std::get<_Idx>(std::forward<_Tuple>(__t))...); - } - - template - constexpr decltype(auto) - apply(_Fn&& __f, _Tuple&& __t) - noexcept(__unpack_std_tuple) - { - using _Indices - = make_index_sequence>>; - return std::__apply_impl(std::forward<_Fn>(__f), - std::forward<_Tuple>(__t), - _Indices{}); - } - - - - template - constexpr _Tp - __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>) - { return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...); } - - template - constexpr _Tp - make_from_tuple(_Tuple&& __t) - noexcept(__unpack_std_tuple) - { - constexpr size_t __n = tuple_size_v>; - - - - - - - - return __make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t), - make_index_sequence<__n>{}); - } -# 2345 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/tuple" 3 -} -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - -namespace pmr -{ - - - - - - - class memory_resource - { - static constexpr size_t _S_max_align = alignof(max_align_t); - - public: - memory_resource() = default; - memory_resource(const memory_resource&) = default; - virtual ~memory_resource(); - - memory_resource& operator=(const memory_resource&) = default; - - [[nodiscard]] - void* - allocate(size_t __bytes, size_t __alignment = _S_max_align) - __attribute__((__returns_nonnull__,__alloc_size__(2),__alloc_align__(3))) - { return ::operator new(__bytes, do_allocate(__bytes, __alignment)); } - - void - deallocate(void* __p, size_t __bytes, size_t __alignment = _S_max_align) - __attribute__((__nonnull__)) - { return do_deallocate(__p, __bytes, __alignment); } - - [[nodiscard]] - bool - is_equal(const memory_resource& __other) const noexcept - { return do_is_equal(__other); } - - private: - virtual void* - do_allocate(size_t __bytes, size_t __alignment) = 0; - - virtual void - do_deallocate(void* __p, size_t __bytes, size_t __alignment) = 0; - - virtual bool - do_is_equal(const memory_resource& __other) const noexcept = 0; - }; - - [[nodiscard]] - inline bool - operator==(const memory_resource& __a, const memory_resource& __b) noexcept - { return &__a == &__b || __a.is_equal(__b); } - - - [[nodiscard]] - inline bool - operator!=(const memory_resource& __a, const memory_resource& __b) noexcept - { return !(__a == __b); } -# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - class polymorphic_allocator - { - - - template - struct __not_pair { using type = void; }; - - template - struct __not_pair> { }; - - public: - using value_type = _Tp; - - polymorphic_allocator() noexcept - { - extern memory_resource* get_default_resource() noexcept - __attribute__((__returns_nonnull__)); - _M_resource = get_default_resource(); - } - - polymorphic_allocator(memory_resource* __r) noexcept - __attribute__((__nonnull__)) - : _M_resource(__r) - { ; } - - polymorphic_allocator(const polymorphic_allocator& __other) = default; - - template - polymorphic_allocator(const polymorphic_allocator<_Up>& __x) noexcept - : _M_resource(__x.resource()) - { } - - polymorphic_allocator& - operator=(const polymorphic_allocator&) = delete; - - [[nodiscard]] - _Tp* - allocate(size_t __n) - __attribute__((__returns_nonnull__)) - { - if ((__gnu_cxx::__int_traits::__max / sizeof(_Tp)) < __n) - std::__throw_bad_array_new_length(); - return static_cast<_Tp*>(_M_resource->allocate(__n * sizeof(_Tp), - alignof(_Tp))); - } - - void - deallocate(_Tp* __p, size_t __n) noexcept - __attribute__((__nonnull__)) - { _M_resource->deallocate(__p, __n * sizeof(_Tp), alignof(_Tp)); } -# 224 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - __attribute__((__nonnull__)) - typename __not_pair<_Tp1>::type - construct(_Tp1* __p, _Args&&... __args) - { - - - using __use_tag - = std::__uses_alloc_t<_Tp1, polymorphic_allocator, _Args...>; - if constexpr (is_base_of_v<__uses_alloc0, __use_tag>) - ::new(__p) _Tp1(std::forward<_Args>(__args)...); - else if constexpr (is_base_of_v<__uses_alloc1_, __use_tag>) - ::new(__p) _Tp1(allocator_arg, *this, - std::forward<_Args>(__args)...); - else - ::new(__p) _Tp1(std::forward<_Args>(__args)..., *this); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, piecewise_construct_t, - tuple<_Args1...> __x, tuple<_Args2...> __y) - { - auto __x_tag = - __use_alloc<_Tp1, polymorphic_allocator, _Args1...>(*this); - auto __y_tag = - __use_alloc<_Tp2, polymorphic_allocator, _Args2...>(*this); - index_sequence_for<_Args1...> __x_i; - index_sequence_for<_Args2...> __y_i; - - ::new(__p) pair<_Tp1, _Tp2>(piecewise_construct, - _S_construct_p(__x_tag, __x_i, __x), - _S_construct_p(__y_tag, __y_i, __y)); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p) - { this->construct(__p, piecewise_construct, tuple<>(), tuple<>()); } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, _Up&& __x, _Vp&& __y) - { - this->construct(__p, piecewise_construct, - std::forward_as_tuple(std::forward<_Up>(__x)), - std::forward_as_tuple(std::forward<_Vp>(__y))); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, const std::pair<_Up, _Vp>& __pr) - { - this->construct(__p, piecewise_construct, - std::forward_as_tuple(__pr.first), - std::forward_as_tuple(__pr.second)); - } - - template - __attribute__((__nonnull__)) - void - construct(pair<_Tp1, _Tp2>* __p, pair<_Up, _Vp>&& __pr) - { - this->construct(__p, piecewise_construct, - std::forward_as_tuple(std::forward<_Up>(__pr.first)), - std::forward_as_tuple(std::forward<_Vp>(__pr.second))); - } -# 307 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - - __attribute__((__nonnull__)) - void - destroy(_Up* __p) - { __p->~_Up(); } - - polymorphic_allocator - select_on_container_copy_construction() const noexcept - { return polymorphic_allocator(); } - - memory_resource* - resource() const noexcept - __attribute__((__returns_nonnull__)) - { return _M_resource; } - - - - [[nodiscard]] - friend bool - operator==(const polymorphic_allocator& __a, - const polymorphic_allocator& __b) noexcept - { return *__a.resource() == *__b.resource(); } - - - [[nodiscard]] - friend bool - operator!=(const polymorphic_allocator& __a, - const polymorphic_allocator& __b) noexcept - { return !(__a == __b); } - - - private: - - using __uses_alloc1_ = __uses_alloc1; - using __uses_alloc2_ = __uses_alloc2; - - template - static tuple<_Args&&...> - _S_construct_p(__uses_alloc0, _Ind, tuple<_Args...>& __t) - { return std::move(__t); } - - template - static tuple - _S_construct_p(__uses_alloc1_ __ua, index_sequence<_Ind...>, - tuple<_Args...>& __t) - { - return { - allocator_arg, *__ua._M_a, std::get<_Ind>(std::move(__t))... - }; - } - - template - static tuple<_Args&&..., polymorphic_allocator> - _S_construct_p(__uses_alloc2_ __ua, index_sequence<_Ind...>, - tuple<_Args...>& __t) - { return { std::get<_Ind>(std::move(__t))..., *__ua._M_a }; } - - - memory_resource* _M_resource; - }; - - template - [[nodiscard]] - inline bool - operator==(const polymorphic_allocator<_Tp1>& __a, - const polymorphic_allocator<_Tp2>& __b) noexcept - { return *__a.resource() == *__b.resource(); } - - - template - [[nodiscard]] - inline bool - operator!=(const polymorphic_allocator<_Tp1>& __a, - const polymorphic_allocator<_Tp2>& __b) noexcept - { return !(__a == __b); } - - -} - - template struct allocator_traits; - - - template - struct allocator_traits> - { - - using allocator_type = pmr::polymorphic_allocator<_Tp>; - - - using value_type = _Tp; - - - using pointer = _Tp*; - - - using const_pointer = const _Tp*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - - - - using propagate_on_container_copy_assignment = false_type; - using propagate_on_container_move_assignment = false_type; - using propagate_on_container_swap = false_type; - - static allocator_type - select_on_container_copy_construction(const allocator_type&) noexcept - { return allocator_type(); } - - - - using is_always_equal = false_type; - - template - using rebind_alloc = pmr::polymorphic_allocator<_Up>; - - template - using rebind_traits = allocator_traits>; -# 446 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - [[nodiscard]] static pointer - allocate(allocator_type& __a, size_type __n) - { return __a.allocate(__n); } -# 461 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - [[nodiscard]] static pointer - allocate(allocator_type& __a, size_type __n, const_void_pointer) - { return __a.allocate(__n); } -# 473 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - static void - deallocate(allocator_type& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - static void - construct(allocator_type& __a, _Up* __p, _Args&&... __args) - { __a.construct(__p, std::forward<_Args>(__args)...); } -# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - template - static void - destroy(allocator_type&, _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { __p->~_Up(); } - - - - - - static size_type - max_size(const allocator_type&) noexcept - { return size_t(-1) / sizeof(value_type); } - }; - - -} -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/string" 2 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - namespace pmr { - template> - using basic_string = std::basic_string<_CharT, _Traits, - polymorphic_allocator<_CharT>>; - using string = basic_string; - - - - using u16string = basic_string; - using u32string = basic_string; - using wstring = basic_string; - } - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - class locale - { - public: - - - typedef int category; - - - class facet; - class id; - class _Impl; - - friend class facet; - friend class _Impl; - - template - friend bool - has_facet(const locale&) throw(); - - template - friend const _Facet& - use_facet(const locale&); - - template - friend const _Facet* - __try_use_facet(const locale&) noexcept; - - template - friend struct __use_cache; -# 102 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - static const category none = 0; - static const category ctype = 1L << 0; - static const category numeric = 1L << 1; - static const category collate = 1L << 2; - static const category time = 1L << 3; - static const category monetary = 1L << 4; - static const category messages = 1L << 5; - static const category all = (ctype | numeric | collate | - time | monetary | messages); -# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - locale() throw(); -# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - locale(const locale& __other) throw(); -# 140 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - explicit - locale(const char* __s); -# 155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - locale(const locale& __base, const char* __s, category __cat); -# 166 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - explicit - locale(const std::string& __s) : locale(__s.c_str()) { } -# 181 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - locale(const locale& __base, const std::string& __s, category __cat) - : locale(__base, __s.c_str(), __cat) { } -# 196 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - locale(const locale& __base, const locale& __add, category __cat); -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - template - locale(const locale& __other, _Facet* __f); - - - ~locale() throw(); -# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - const locale& - operator=(const locale& __other) throw(); -# 238 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - template - locale - combine(const locale& __other) const; - - - - - - - __attribute ((__abi_tag__ ("cxx11"))) - string - name() const; -# 258 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - bool - operator==(const locale& __other) const throw(); -# 268 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - bool - operator!=(const locale& __other) const throw() - { return !(this->operator==(__other)); } -# 288 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - template - bool - operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, - const basic_string<_Char, _Traits, _Alloc>& __s2) const; -# 304 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - static locale - global(const locale& __loc); - - - - - static const locale& - classic(); - - private: - - _Impl* _M_impl; - - - static _Impl* _S_classic; - - - static _Impl* _S_global; - - - - - - static const char* const* const _S_categories; -# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - enum { _S_categories_size = 6 + 6 }; - - - static __gthread_once_t _S_once; - - - explicit - locale(_Impl*) throw(); - - static void - _S_initialize(); - - static void - _S_initialize_once() throw(); - - static category - _S_normalize_category(category); - - void - _M_coalesce(const locale& __base, const locale& __add, category __cat); - - - static const id* const _S_twinned_facets[]; - - }; -# 377 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - class locale::facet - { - private: - friend class locale; - friend class locale::_Impl; - - mutable _Atomic_word _M_refcount; - - - static __c_locale _S_c_locale; - - - static const char _S_c_name[2]; - - - static __gthread_once_t _S_once; - - - static void - _S_initialize_once(); - - protected: -# 408 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - explicit - facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0) - { } - - - virtual - ~facet(); - - static void - _S_create_c_locale(__c_locale& __cloc, const char* __s, - __c_locale __old = 0); - - static __c_locale - _S_clone_c_locale(__c_locale& __cloc) throw(); - - static void - _S_destroy_c_locale(__c_locale& __cloc); - - static __c_locale - _S_lc_ctype_c_locale(__c_locale __cloc, const char* __s); - - - - static __c_locale - _S_get_c_locale(); - - __attribute__ ((__const__)) static const char* - _S_get_c_name() throw(); -# 444 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - facet(const facet&) = delete; - - facet& - operator=(const facet&) = delete; - - - private: - void - _M_add_reference() const throw() - { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } - - void - _M_remove_reference() const throw() - { - - ; - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) - { - ; - try - { delete this; } - catch(...) - { } - } - } - - const facet* _M_sso_shim(const id*) const; - const facet* _M_cow_shim(const id*) const; - - protected: - class __shim; - }; -# 489 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - class locale::id - { - private: - friend class locale; - friend class locale::_Impl; - - template - friend const _Facet& - use_facet(const locale&); - - template - friend bool - has_facet(const locale&) throw(); - - template - friend const _Facet* - __try_use_facet(const locale&) noexcept; - - - - - mutable size_t _M_index; - - - static _Atomic_word _S_refcount; - - void - operator=(const id&); - - id(const id&); - - public: - - - - id() { } - - size_t - _M_id() const throw(); - }; - - - - class locale::_Impl - { - public: - - friend class locale; - friend class locale::facet; - - template - friend bool - has_facet(const locale&) throw(); - - template - friend const _Facet& - use_facet(const locale&); - - template - friend const _Facet* - __try_use_facet(const locale&) noexcept; - - template - friend struct __use_cache; - - private: - - _Atomic_word _M_refcount; - const facet** _M_facets; - size_t _M_facets_size; - const facet** _M_caches; - char** _M_names; - static const locale::id* const _S_id_ctype[]; - static const locale::id* const _S_id_numeric[]; - static const locale::id* const _S_id_collate[]; - static const locale::id* const _S_id_time[]; - static const locale::id* const _S_id_monetary[]; - static const locale::id* const _S_id_messages[]; - static const locale::id* const* const _S_facet_categories[]; - - void - _M_add_reference() throw() - { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } - - void - _M_remove_reference() throw() - { - - ; - if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) - { - ; - try - { delete this; } - catch(...) - { } - } - } - - _Impl(const _Impl&, size_t); - _Impl(const char*, size_t); - _Impl(size_t) throw(); - - ~_Impl() throw(); - - _Impl(const _Impl&); - - void - operator=(const _Impl&); - - bool - _M_check_same_name() - { - bool __ret = true; - if (_M_names[1]) - - for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i) - __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0; - return __ret; - } - - void - _M_replace_categories(const _Impl*, category); - - void - _M_replace_category(const _Impl*, const locale::id* const*); - - void - _M_replace_facet(const _Impl*, const locale::id*); - - void - _M_install_facet(const locale::id*, const facet*); - - template - void - _M_init_facet(_Facet* __facet) - { _M_install_facet(&_Facet::id, __facet); } - - template - void - _M_init_facet_unchecked(_Facet* __facet) - { - __facet->_M_add_reference(); - _M_facets[_Facet::id._M_id()] = __facet; - } - - void - _M_install_cache(const facet*, size_t); - - void _M_init_extra(facet**); - void _M_init_extra(void*, void*, const char*, const char*); - - - - - }; -# 659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - template - class __cxx11:: collate : public locale::facet - { - public: - - - - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - - protected: - - - __c_locale _M_c_locale_collate; - - public: - - static locale::id id; -# 686 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - explicit - collate(size_t __refs = 0) - : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) - { } -# 700 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - explicit - collate(__c_locale __cloc, size_t __refs = 0) - : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) - { } -# 717 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - int - compare(const _CharT* __lo1, const _CharT* __hi1, - const _CharT* __lo2, const _CharT* __hi2) const - { return this->do_compare(__lo1, __hi1, __lo2, __hi2); } -# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - string_type - transform(const _CharT* __lo, const _CharT* __hi) const - { return this->do_transform(__lo, __hi); } -# 750 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - long - hash(const _CharT* __lo, const _CharT* __hi) const - { return this->do_hash(__lo, __hi); } - - - int - _M_compare(const _CharT*, const _CharT*) const throw(); - - size_t - _M_transform(_CharT*, const _CharT*, size_t) const throw(); - - protected: - - virtual - ~collate() - { _S_destroy_c_locale(_M_c_locale_collate); } -# 779 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - virtual int - do_compare(const _CharT* __lo1, const _CharT* __hi1, - const _CharT* __lo2, const _CharT* __hi2) const; -# 793 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - virtual string_type - do_transform(const _CharT* __lo, const _CharT* __hi) const; -# 806 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 3 - virtual long - do_hash(const _CharT* __lo, const _CharT* __hi) const; - }; - - template - locale::id collate<_CharT>::id; - - - template<> - int - collate::_M_compare(const char*, const char*) const throw(); - - template<> - size_t - collate::_M_transform(char*, const char*, size_t) const throw(); - - - template<> - int - collate::_M_compare(const wchar_t*, const wchar_t*) const throw(); - - template<> - size_t - collate::_M_transform(wchar_t*, const wchar_t*, size_t) const throw(); - - - - template - class __cxx11:: collate_byname : public collate<_CharT> - { - public: - - - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - - explicit - collate_byname(const char* __s, size_t __refs = 0) - : collate<_CharT>(__refs) - { - if (__builtin_strcmp(__s, "C") != 0 - && __builtin_strcmp(__s, "POSIX") != 0) - { - this->_S_destroy_c_locale(this->_M_c_locale_collate); - this->_S_create_c_locale(this->_M_c_locale_collate, __s); - } - } - - - explicit - collate_byname(const string& __s, size_t __refs = 0) - : collate_byname(__s.c_str(), __refs) { } - - - protected: - virtual - ~collate_byname() { } - }; - - -} - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.tcc" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.tcc" 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - locale:: - locale(const locale& __other, _Facet* __f) - { - _M_impl = new _Impl(*__other._M_impl, 1); - - try - { _M_impl->_M_install_facet(&_Facet::id, __f); } - catch(...) - { - _M_impl->_M_remove_reference(); - throw; - } - delete [] _M_impl->_M_names[0]; - _M_impl->_M_names[0] = 0; - } - - template - locale - locale:: - combine(const locale& __other) const - { - _Impl* __tmp = new _Impl(*_M_impl, 1); - try - { - __tmp->_M_replace_facet(__other._M_impl, &_Facet::id); - } - catch(...) - { - __tmp->_M_remove_reference(); - throw; - } - return locale(__tmp); - } - - template - bool - locale:: - operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1, - const basic_string<_CharT, _Traits, _Alloc>& __s2) const - { - typedef std::collate<_CharT> __collate_type; - const __collate_type& __collate = use_facet<__collate_type>(*this); - return (__collate.compare(__s1.data(), __s1.data() + __s1.length(), - __s2.data(), __s2.data() + __s2.length()) < 0); - } - - template - inline const _Facet* - __try_use_facet(const locale& __loc) noexcept - { - const size_t __i = _Facet::id._M_id(); - const locale::facet** __facets = __loc._M_impl->_M_facets; - - - - - - - - if constexpr (__is_same(_Facet, ctype)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, num_get)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, num_put)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, codecvt)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, collate)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, moneypunct)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, moneypunct)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, money_get)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, money_put)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, numpunct)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, time_get)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, time_put)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, messages)) return static_cast(__facets[__i]); - - - if constexpr (__is_same(_Facet, ctype)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, num_get)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, num_put)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, codecvt)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, collate)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, moneypunct)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, moneypunct)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, money_get)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, money_put)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, numpunct)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, time_get)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, time_put)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, messages)) return static_cast(__facets[__i]); - - - if constexpr (__is_same(_Facet, codecvt)) return static_cast(__facets[__i]); - if constexpr (__is_same(_Facet, codecvt)) return static_cast(__facets[__i]); - - - - - if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i]) - return 0; - - - return dynamic_cast(__facets[__i]); - - - - } -# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.tcc" 3 - template - inline bool - has_facet(const locale& __loc) throw() - { - - static_assert(__is_base_of(locale::facet, _Facet), - "template argument must be derived from locale::facet"); - - - - return std::__try_use_facet<_Facet>(__loc) != 0; - } -# 188 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.tcc" 3 -#pragma GCC diagnostic push - - template - inline const _Facet& - use_facet(const locale& __loc) - { - - static_assert(__is_base_of(locale::facet, _Facet), - "template argument must be derived from locale::facet"); - - - - if (const _Facet* __f = std::__try_use_facet<_Facet>(__loc)) - return *__f; - __throw_bad_cast(); - } -#pragma GCC diagnostic pop - - - - template - int - collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const throw () - { return 0; } - - - template - size_t - collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const throw () - { return 0; } - - template - int - collate<_CharT>:: - do_compare(const _CharT* __lo1, const _CharT* __hi1, - const _CharT* __lo2, const _CharT* __hi2) const - { - - - const string_type __one(__lo1, __hi1); - const string_type __two(__lo2, __hi2); - - const _CharT* __p = __one.c_str(); - const _CharT* __pend = __one.data() + __one.length(); - const _CharT* __q = __two.c_str(); - const _CharT* __qend = __two.data() + __two.length(); - - - - - for (;;) - { - const int __res = _M_compare(__p, __q); - if (__res) - return __res; - - __p += char_traits<_CharT>::length(__p); - __q += char_traits<_CharT>::length(__q); - if (__p == __pend && __q == __qend) - return 0; - else if (__p == __pend) - return -1; - else if (__q == __qend) - return 1; - - __p++; - __q++; - } - } - - template - typename collate<_CharT>::string_type - collate<_CharT>:: - do_transform(const _CharT* __lo, const _CharT* __hi) const - { - string_type __ret; - - - const string_type __str(__lo, __hi); - - const _CharT* __p = __str.c_str(); - const _CharT* __pend = __str.data() + __str.length(); - - size_t __len = (__hi - __lo) * 2; - - _CharT* __c = new _CharT[__len]; - - try - { - - - - for (;;) - { - - size_t __res = _M_transform(__c, __p, __len); - - - if (__res >= __len) - { - __len = __res + 1; - delete [] __c, __c = 0; - __c = new _CharT[__len]; - __res = _M_transform(__c, __p, __len); - } - - __ret.append(__c, __res); - __p += char_traits<_CharT>::length(__p); - if (__p == __pend) - break; - - __p++; - __ret.push_back(_CharT()); - } - } - catch(...) - { - delete [] __c; - throw; - } - - delete [] __c; - - return __ret; - } - - template - long - collate<_CharT>:: - do_hash(const _CharT* __lo, const _CharT* __hi) const - { - unsigned long __val = 0; - for (; __lo < __hi; ++__lo) - __val = - *__lo + ((__val << 7) - | (__val >> (__gnu_cxx::__numeric_traits:: - __digits - 7))); - return static_cast(__val); - } - - - - - extern template class collate; - extern template class collate_byname; - - extern template - const collate* - __try_use_facet >(const locale&) noexcept; - - extern template - const collate& - use_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - - extern template class collate; - extern template class collate_byname; - - extern template - const collate* - __try_use_facet >(const locale&) noexcept; - - extern template - const collate& - use_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - - - -} -# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_classes.h" 2 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - - - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/error_constants.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/error_constants.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/error_constants.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - enum class errc - { - address_family_not_supported = 97, - address_in_use = 98, - address_not_available = 99, - already_connected = 106, - argument_list_too_long = 7, - argument_out_of_domain = 33, - bad_address = 14, - bad_file_descriptor = 9, - - - bad_message = 74, - - - broken_pipe = 32, - connection_aborted = 103, - connection_already_in_progress = 114, - connection_refused = 111, - connection_reset = 104, - cross_device_link = 18, - destination_address_required = 89, - device_or_resource_busy = 16, - directory_not_empty = 39, - executable_format_error = 8, - file_exists = 17, - file_too_large = 27, - filename_too_long = 36, - function_not_supported = 38, - host_unreachable = 113, - - - identifier_removed = 43, - - - illegal_byte_sequence = 84, - inappropriate_io_control_operation = 25, - interrupted = 4, - invalid_argument = 22, - invalid_seek = 29, - io_error = 5, - is_a_directory = 21, - message_size = 90, - network_down = 100, - network_reset = 102, - network_unreachable = 101, - no_buffer_space = 105, - no_child_process = 10, - - - no_link = 67, - - - no_lock_available = 37, - - - no_message_available = 61, - - - no_message = 42, - no_protocol_option = 92, - no_space_on_device = 28, - - - no_stream_resources = 63, - - - no_such_device_or_address = 6, - no_such_device = 19, - no_such_file_or_directory = 2, - no_such_process = 3, - not_a_directory = 20, - not_a_socket = 88, - - - not_a_stream = 60, - - - not_connected = 107, - not_enough_memory = 12, - - - not_supported = 95, - - - - operation_canceled = 125, - - - operation_in_progress = 115, - operation_not_permitted = 1, - operation_not_supported = 95, - operation_would_block = 11, - - - owner_dead = 130, - - - permission_denied = 13, - - - protocol_error = 71, - - - protocol_not_supported = 93, - read_only_file_system = 30, - resource_deadlock_would_occur = 35, - resource_unavailable_try_again = 11, - result_out_of_range = 34, - - - state_not_recoverable = 131, - - - - stream_timeout = 62, - - - - text_file_busy = 26, - - - timed_out = 110, - too_many_files_open_in_system = 23, - too_many_files_open = 24, - too_many_links = 31, - too_many_symbolic_link_levels = 40, - - - value_too_large = 75, - - - - - wrong_protocol_type = 91 - }; - - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdexcept" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdexcept" 3 - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - struct __cow_string - { - union { - const char* _M_p; - char _M_bytes[sizeof(const char*)]; - }; - - __cow_string(); - __cow_string(const std::string&); - __cow_string(const char*, size_t); - __cow_string(const __cow_string&) noexcept; - __cow_string& operator=(const __cow_string&) noexcept; - ~__cow_string(); - - __cow_string(__cow_string&&) noexcept; - __cow_string& operator=(__cow_string&&) noexcept; - - }; - - typedef basic_string __sso_string; -# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdexcept" 3 - class logic_error : public exception - { - __cow_string _M_msg; - - public: - - explicit - logic_error(const string& __arg) ; - - - explicit - logic_error(const char*) ; - - logic_error(logic_error&&) noexcept; - logic_error& operator=(logic_error&&) noexcept; - - - - logic_error(const logic_error&) noexcept; - logic_error& operator=(const logic_error&) noexcept; - - - - - - virtual ~logic_error() noexcept; - - - - virtual const char* - what() const noexcept; - - - - - - }; - - - - class domain_error : public logic_error - { - public: - explicit domain_error(const string& __arg) ; - - explicit domain_error(const char*) ; - domain_error(const domain_error&) = default; - domain_error& operator=(const domain_error&) = default; - domain_error(domain_error&&) = default; - domain_error& operator=(domain_error&&) = default; - - virtual ~domain_error() noexcept; - }; - - - class invalid_argument : public logic_error - { - public: - explicit invalid_argument(const string& __arg) ; - - explicit invalid_argument(const char*) ; - invalid_argument(const invalid_argument&) = default; - invalid_argument& operator=(const invalid_argument&) = default; - invalid_argument(invalid_argument&&) = default; - invalid_argument& operator=(invalid_argument&&) = default; - - virtual ~invalid_argument() noexcept; - }; - - - - class length_error : public logic_error - { - public: - explicit length_error(const string& __arg) ; - - explicit length_error(const char*) ; - length_error(const length_error&) = default; - length_error& operator=(const length_error&) = default; - length_error(length_error&&) = default; - length_error& operator=(length_error&&) = default; - - virtual ~length_error() noexcept; - }; - - - - class out_of_range : public logic_error - { - public: - explicit out_of_range(const string& __arg) ; - - explicit out_of_range(const char*) ; - out_of_range(const out_of_range&) = default; - out_of_range& operator=(const out_of_range&) = default; - out_of_range(out_of_range&&) = default; - out_of_range& operator=(out_of_range&&) = default; - - virtual ~out_of_range() noexcept; - }; - - - - - - - class runtime_error : public exception - { - __cow_string _M_msg; - - public: - - explicit - runtime_error(const string& __arg) ; - - - explicit - runtime_error(const char*) ; - - runtime_error(runtime_error&&) noexcept; - runtime_error& operator=(runtime_error&&) noexcept; - - - - runtime_error(const runtime_error&) noexcept; - runtime_error& operator=(const runtime_error&) noexcept; - - - - - - virtual ~runtime_error() noexcept; - - - - virtual const char* - what() const noexcept; - - - - - - }; - - - class range_error : public runtime_error - { - public: - explicit range_error(const string& __arg) ; - - explicit range_error(const char*) ; - range_error(const range_error&) = default; - range_error& operator=(const range_error&) = default; - range_error(range_error&&) = default; - range_error& operator=(range_error&&) = default; - - virtual ~range_error() noexcept; - }; - - - class overflow_error : public runtime_error - { - public: - explicit overflow_error(const string& __arg) ; - - explicit overflow_error(const char*) ; - overflow_error(const overflow_error&) = default; - overflow_error& operator=(const overflow_error&) = default; - overflow_error(overflow_error&&) = default; - overflow_error& operator=(overflow_error&&) = default; - - virtual ~overflow_error() noexcept; - }; - - - class underflow_error : public runtime_error - { - public: - explicit underflow_error(const string& __arg) ; - - explicit underflow_error(const char*) ; - underflow_error(const underflow_error&) = default; - underflow_error& operator=(const underflow_error&) = default; - underflow_error(underflow_error&&) = default; - underflow_error& operator=(underflow_error&&) = default; - - virtual ~underflow_error() noexcept; - }; - - - - -} -# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 2 3 - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - class error_code; - class error_condition; - class system_error; - - - template - struct is_error_code_enum : public false_type { }; - - - template - struct is_error_condition_enum : public false_type { }; - - template<> - struct is_error_condition_enum - : public true_type { }; - - - template - inline constexpr bool is_error_code_enum_v = - is_error_code_enum<_Tp>::value; - template - inline constexpr bool is_error_condition_enum_v = - is_error_condition_enum<_Tp>::value; - - - -inline namespace _V2 { -# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - class error_category - { - public: - constexpr error_category() noexcept = default; - - virtual ~error_category(); - - error_category(const error_category&) = delete; - error_category& operator=(const error_category&) = delete; - - - virtual const char* - name() const noexcept = 0; - - - - - - - private: - __attribute ((__abi_tag__ ("cxx11"))) - virtual __cow_string - _M_message(int) const; - - public: - - __attribute ((__abi_tag__ ("cxx11"))) - virtual string - message(int) const = 0; -# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - public: - - virtual error_condition - default_error_condition(int __i) const noexcept; - - - virtual bool - equivalent(int __i, const error_condition& __cond) const noexcept; - - - virtual bool - equivalent(const error_code& __code, int __i) const noexcept; - - - [[__nodiscard__]] - bool - operator==(const error_category& __other) const noexcept - { return this == &__other; } -# 170 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - bool - operator<(const error_category& __other) const noexcept - { return less()(this, &__other); } - - bool - operator!=(const error_category& __other) const noexcept - { return this != &__other; } - - }; - - - - - [[__nodiscard__, __gnu__::__const__]] - const error_category& - generic_category() noexcept; - - - [[__nodiscard__, __gnu__::__const__]] - const error_category& - system_category() noexcept; - - - -} - - - - - -namespace __adl_only -{ - void make_error_code() = delete; - void make_error_condition() = delete; -} -# 223 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - class error_code - { - template - using _Check - = __enable_if_t::value>; - - public: - error_code() noexcept - : _M_value(0), _M_cat(&system_category()) { } - - error_code(int __v, const error_category& __cat) noexcept - : _M_value(__v), _M_cat(&__cat) { } - - - template> - error_code(_ErrorCodeEnum __e) noexcept - { - using __adl_only::make_error_code; - *this = make_error_code(__e); - } - - error_code(const error_code&) = default; - error_code& operator=(const error_code&) = default; - - void - assign(int __v, const error_category& __cat) noexcept - { - _M_value = __v; - _M_cat = &__cat; - } - - void - clear() noexcept - { assign(0, system_category()); } - - - [[__nodiscard__]] - int - value() const noexcept { return _M_value; } - - - [[__nodiscard__]] - const error_category& - category() const noexcept { return *_M_cat; } - - - error_condition - default_error_condition() const noexcept; - - - __attribute ((__abi_tag__ ("cxx11"))) - string - message() const - { return category().message(value()); } - - - [[__nodiscard__]] - explicit operator bool() const noexcept - { return _M_value != 0; } - - - private: - int _M_value; - const error_category* _M_cat; - }; -# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - [[__nodiscard__]] - inline error_code - make_error_code(errc __e) noexcept - { return error_code(static_cast(__e), generic_category()); } -# 323 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - inline bool - operator<(const error_code& __lhs, const error_code& __rhs) noexcept - { - return (__lhs.category() < __rhs.category() - || (__lhs.category() == __rhs.category() - && __lhs.value() < __rhs.value())); - } - - - - - - - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __os, const error_code& __e) - { return (__os << __e.category().name() << ':' << __e.value()); } -# 354 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - class error_condition - { - template - using _Check - = __enable_if_t::value>; - - public: - - error_condition() noexcept - : _M_value(0), _M_cat(&generic_category()) { } - - - error_condition(int __v, const error_category& __cat) noexcept - : _M_value(__v), _M_cat(&__cat) { } - - - template> - error_condition(_ErrorConditionEnum __e) noexcept - { - using __adl_only::make_error_condition; - *this = make_error_condition(__e); - } - - error_condition(const error_condition&) = default; - error_condition& operator=(const error_condition&) = default; - - - void - assign(int __v, const error_category& __cat) noexcept - { - _M_value = __v; - _M_cat = &__cat; - } - - - void - clear() noexcept - { assign(0, generic_category()); } - - - - - [[__nodiscard__]] - int - value() const noexcept { return _M_value; } - - - [[__nodiscard__]] - const error_category& - category() const noexcept { return *_M_cat; } - - - __attribute ((__abi_tag__ ("cxx11"))) - string - message() const - { return category().message(value()); } - - - [[__nodiscard__]] - explicit operator bool() const noexcept - { return _M_value != 0; } - - - private: - int _M_value; - const error_category* _M_cat; - }; -# 433 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - [[__nodiscard__]] - inline error_condition - make_error_condition(errc __e) noexcept - { return error_condition(static_cast(__e), generic_category()); } -# 447 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - [[__nodiscard__]] - inline bool - operator==(const error_code& __lhs, const error_code& __rhs) noexcept - { - return __lhs.category() == __rhs.category() - && __lhs.value() == __rhs.value(); - } -# 463 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - [[__nodiscard__]] - inline bool - operator==(const error_code& __lhs, const error_condition& __rhs) noexcept - { - return __lhs.category().equivalent(__lhs.value(), __rhs) - || __rhs.category().equivalent(__lhs, __rhs.value()); - } -# 478 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - [[__nodiscard__]] - inline bool - operator==(const error_condition& __lhs, - const error_condition& __rhs) noexcept - { - return __lhs.category() == __rhs.category() - && __lhs.value() == __rhs.value(); - } -# 506 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - inline bool - operator<(const error_condition& __lhs, - const error_condition& __rhs) noexcept - { - return (__lhs.category() < __rhs.category() - || (__lhs.category() == __rhs.category() - && __lhs.value() < __rhs.value())); - } - - - inline bool - operator==(const error_condition& __lhs, const error_code& __rhs) noexcept - { - return (__rhs.category().equivalent(__rhs.value(), __lhs) - || __lhs.category().equivalent(__rhs, __lhs.value())); - } - - - inline bool - operator!=(const error_code& __lhs, const error_code& __rhs) noexcept - { return !(__lhs == __rhs); } - - - inline bool - operator!=(const error_code& __lhs, const error_condition& __rhs) noexcept - { return !(__lhs == __rhs); } - - - inline bool - operator!=(const error_condition& __lhs, const error_code& __rhs) noexcept - { return !(__lhs == __rhs); } - - - inline bool - operator!=(const error_condition& __lhs, - const error_condition& __rhs) noexcept - { return !(__lhs == __rhs); } -# 556 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/system_error" 3 - class system_error : public std::runtime_error - { - private: - error_code _M_code; - - public: - system_error(error_code __ec = error_code()) - : runtime_error(__ec.message()), _M_code(__ec) { } - - system_error(error_code __ec, const string& __what) - : runtime_error(__what + ": " + __ec.message()), _M_code(__ec) { } - - system_error(error_code __ec, const char* __what) - : runtime_error(__what + (": " + __ec.message())), _M_code(__ec) { } - - system_error(int __v, const error_category& __ecat, const char* __what) - : system_error(error_code(__v, __ecat), __what) { } - - system_error(int __v, const error_category& __ecat) - : runtime_error(error_code(__v, __ecat).message()), - _M_code(__v, __ecat) { } - - system_error(int __v, const error_category& __ecat, const string& __what) - : runtime_error(__what + ": " + error_code(__v, __ecat).message()), - _M_code(__v, __ecat) { } - - - system_error (const system_error &) = default; - system_error &operator= (const system_error &) = default; - - - virtual ~system_error() noexcept; - - const error_code& - code() const noexcept { return _M_code; } - }; - - -} - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - template<> - struct hash - : public __hash_base - { - size_t - operator()(const error_code& __e) const noexcept - { - const size_t __tmp = std::_Hash_impl::hash(__e.value()); - return std::_Hash_impl::__hash_combine(&__e.category(), __tmp); - } - }; - - - - - - - template<> - struct hash - : public __hash_base - { - size_t - operator()(const error_condition& __e) const noexcept - { - const size_t __tmp = std::_Hash_impl::hash(__e.value()); - return std::_Hash_impl::__hash_combine(&__e.category(), __tmp); - } - }; - - - -} -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - enum _Ios_Fmtflags - { - _S_boolalpha = 1L << 0, - _S_dec = 1L << 1, - _S_fixed = 1L << 2, - _S_hex = 1L << 3, - _S_internal = 1L << 4, - _S_left = 1L << 5, - _S_oct = 1L << 6, - _S_right = 1L << 7, - _S_scientific = 1L << 8, - _S_showbase = 1L << 9, - _S_showpoint = 1L << 10, - _S_showpos = 1L << 11, - _S_skipws = 1L << 12, - _S_unitbuf = 1L << 13, - _S_uppercase = 1L << 14, - _S_adjustfield = _S_left | _S_right | _S_internal, - _S_basefield = _S_dec | _S_oct | _S_hex, - _S_floatfield = _S_scientific | _S_fixed, - _S_ios_fmtflags_end = 1L << 16, - _S_ios_fmtflags_max = 2147483647, - _S_ios_fmtflags_min = ~2147483647 - }; - - inline constexpr _Ios_Fmtflags - operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) - { return _Ios_Fmtflags(static_cast(__a) & static_cast(__b)); } - - inline constexpr _Ios_Fmtflags - operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) - { return _Ios_Fmtflags(static_cast(__a) | static_cast(__b)); } - - inline constexpr _Ios_Fmtflags - operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) - { return _Ios_Fmtflags(static_cast(__a) ^ static_cast(__b)); } - - inline constexpr _Ios_Fmtflags - operator~(_Ios_Fmtflags __a) - { return _Ios_Fmtflags(~static_cast(__a)); } - - inline const _Ios_Fmtflags& - operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) - { return __a = __a | __b; } - - inline const _Ios_Fmtflags& - operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) - { return __a = __a & __b; } - - inline const _Ios_Fmtflags& - operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) - { return __a = __a ^ __b; } - - - enum _Ios_Openmode - { - _S_app = 1L << 0, - _S_ate = 1L << 1, - _S_bin = 1L << 2, - _S_in = 1L << 3, - _S_out = 1L << 4, - _S_trunc = 1L << 5, - _S_noreplace = 1L << 6, - _S_ios_openmode_end = 1L << 16, - _S_ios_openmode_max = 2147483647, - _S_ios_openmode_min = ~2147483647 - }; - - inline constexpr _Ios_Openmode - operator&(_Ios_Openmode __a, _Ios_Openmode __b) - { return _Ios_Openmode(static_cast(__a) & static_cast(__b)); } - - inline constexpr _Ios_Openmode - operator|(_Ios_Openmode __a, _Ios_Openmode __b) - { return _Ios_Openmode(static_cast(__a) | static_cast(__b)); } - - inline constexpr _Ios_Openmode - operator^(_Ios_Openmode __a, _Ios_Openmode __b) - { return _Ios_Openmode(static_cast(__a) ^ static_cast(__b)); } - - inline constexpr _Ios_Openmode - operator~(_Ios_Openmode __a) - { return _Ios_Openmode(~static_cast(__a)); } - - inline const _Ios_Openmode& - operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) - { return __a = __a | __b; } - - inline const _Ios_Openmode& - operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) - { return __a = __a & __b; } - - inline const _Ios_Openmode& - operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) - { return __a = __a ^ __b; } - - - enum _Ios_Iostate - { - _S_goodbit = 0, - _S_badbit = 1L << 0, - _S_eofbit = 1L << 1, - _S_failbit = 1L << 2, - _S_ios_iostate_end = 1L << 16, - _S_ios_iostate_max = 2147483647, - _S_ios_iostate_min = ~2147483647 - }; - - inline constexpr _Ios_Iostate - operator&(_Ios_Iostate __a, _Ios_Iostate __b) - { return _Ios_Iostate(static_cast(__a) & static_cast(__b)); } - - inline constexpr _Ios_Iostate - operator|(_Ios_Iostate __a, _Ios_Iostate __b) - { return _Ios_Iostate(static_cast(__a) | static_cast(__b)); } - - inline constexpr _Ios_Iostate - operator^(_Ios_Iostate __a, _Ios_Iostate __b) - { return _Ios_Iostate(static_cast(__a) ^ static_cast(__b)); } - - inline constexpr _Ios_Iostate - operator~(_Ios_Iostate __a) - { return _Ios_Iostate(~static_cast(__a)); } - - inline const _Ios_Iostate& - operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) - { return __a = __a | __b; } - - inline const _Ios_Iostate& - operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) - { return __a = __a & __b; } - - inline const _Ios_Iostate& - operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) - { return __a = __a ^ __b; } - - - enum _Ios_Seekdir - { - _S_beg = 0, - _S_cur = 1, - _S_end = 2, - _S_ios_seekdir_end = 1L << 16 - }; - - - - enum class io_errc { stream = 1 }; - - template <> struct is_error_code_enum : public true_type { }; - - [[__nodiscard__, __gnu__::__const__]] - const error_category& - iostream_category() noexcept; - - [[__nodiscard__]] - inline error_code - make_error_code(io_errc __e) noexcept - { return error_code(static_cast(__e), iostream_category()); } - - [[__nodiscard__]] - inline error_condition - make_error_condition(io_errc __e) noexcept - { return error_condition(static_cast(__e), iostream_category()); } -# 233 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - class ios_base - { -# 251 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - public: -# 260 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - class __attribute ((__abi_tag__ ("cxx11"))) failure : public system_error - { - public: - explicit - failure(const string& __str); - - - explicit - failure(const string&, const error_code&); - - explicit - failure(const char*, const error_code& = io_errc::stream); - - - virtual - ~failure() throw(); - - virtual const char* - what() const throw(); - }; -# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - typedef _Ios_Fmtflags fmtflags; - - - static const fmtflags boolalpha = _S_boolalpha; - - - static const fmtflags dec = _S_dec; - - - static const fmtflags fixed = _S_fixed; - - - static const fmtflags hex = _S_hex; - - - - - static const fmtflags internal = _S_internal; - - - - static const fmtflags left = _S_left; - - - static const fmtflags oct = _S_oct; - - - - static const fmtflags right = _S_right; - - - static const fmtflags scientific = _S_scientific; - - - - static const fmtflags showbase = _S_showbase; - - - - static const fmtflags showpoint = _S_showpoint; - - - static const fmtflags showpos = _S_showpos; - - - static const fmtflags skipws = _S_skipws; - - - static const fmtflags unitbuf = _S_unitbuf; - - - - static const fmtflags uppercase = _S_uppercase; - - - static const fmtflags adjustfield = _S_adjustfield; - - - static const fmtflags basefield = _S_basefield; - - - static const fmtflags floatfield = _S_floatfield; -# 421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - typedef _Ios_Iostate iostate; - - - - static const iostate badbit = _S_badbit; - - - static const iostate eofbit = _S_eofbit; - - - - - static const iostate failbit = _S_failbit; - - - static const iostate goodbit = _S_goodbit; -# 452 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - typedef _Ios_Openmode openmode; - - - static const openmode app = _S_app; - - - static const openmode ate = _S_ate; - - - - - static const openmode binary = _S_bin; - - - static const openmode in = _S_in; - - - static const openmode out = _S_out; - - - static const openmode trunc = _S_trunc; - - static const openmode __noreplace = _S_noreplace; -# 492 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - typedef _Ios_Seekdir seekdir; - - - static const seekdir beg = _S_beg; - - - static const seekdir cur = _S_cur; - - - static const seekdir end = _S_end; -# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - enum event - { - erase_event, - imbue_event, - copyfmt_event - }; -# 542 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - typedef void (*event_callback) (event __e, ios_base& __b, int __i); -# 554 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - void - register_callback(event_callback __fn, int __index); - - protected: - streamsize _M_precision; - streamsize _M_width; - fmtflags _M_flags; - iostate _M_exception; - iostate _M_streambuf_state; - - - - struct _Callback_list - { - - _Callback_list* _M_next; - ios_base::event_callback _M_fn; - int _M_index; - _Atomic_word _M_refcount; - - _Callback_list(ios_base::event_callback __fn, int __index, - _Callback_list* __cb) - : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { } - - void - _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } - - - int - _M_remove_reference() - { - - ; - int __res = __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); - if (__res == 0) - { - ; - } - return __res; - } - }; - - _Callback_list* _M_callbacks; - - void - _M_call_callbacks(event __ev) throw(); - - void - _M_dispose_callbacks(void) throw(); - - - struct _Words - { - void* _M_pword; - long _M_iword; - _Words() : _M_pword(0), _M_iword(0) { } - }; - - - _Words _M_word_zero; - - - - enum { _S_local_word_size = 8 }; - _Words _M_local_word[_S_local_word_size]; - - - int _M_word_size; - _Words* _M_word; - - _Words& - _M_grow_words(int __index, bool __iword); - - - locale _M_ios_locale; - - void - _M_init() throw(); - - public: - - - - - - class Init - { - friend class ios_base; - public: - Init(); - ~Init(); - - - Init(const Init&) = default; - Init& operator=(const Init&) = default; - - - private: - static _Atomic_word _S_refcount; - static bool _S_synced_with_stdio; - }; - - - - - - - fmtflags - flags() const - { return _M_flags; } -# 672 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - fmtflags - flags(fmtflags __fmtfl) - { - fmtflags __old = _M_flags; - _M_flags = __fmtfl; - return __old; - } -# 688 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - fmtflags - setf(fmtflags __fmtfl) - { - fmtflags __old = _M_flags; - _M_flags |= __fmtfl; - return __old; - } -# 705 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - fmtflags - setf(fmtflags __fmtfl, fmtflags __mask) - { - fmtflags __old = _M_flags; - _M_flags &= ~__mask; - _M_flags |= (__fmtfl & __mask); - return __old; - } - - - - - - - - void - unsetf(fmtflags __mask) - { _M_flags &= ~__mask; } -# 731 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - streamsize - precision() const - { return _M_precision; } - - - - - - - streamsize - precision(streamsize __prec) - { - streamsize __old = _M_precision; - _M_precision = __prec; - return __old; - } - - - - - - - - streamsize - width() const - { return _M_width; } - - - - - - - streamsize - width(streamsize __wide) - { - streamsize __old = _M_width; - _M_width = __wide; - return __old; - } -# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - static bool - sync_with_stdio(bool __sync = true); -# 794 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - locale - imbue(const locale& __loc) throw(); -# 805 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - locale - getloc() const - { return _M_ios_locale; } -# 816 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - const locale& - _M_getloc() const - { return _M_ios_locale; } -# 835 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - static int - xalloc() throw(); -# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - long& - iword(int __ix) - { - _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size) - ? _M_word[__ix] : _M_grow_words(__ix, true); - return __word._M_iword; - } -# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - void*& - pword(int __ix) - { - _Words& __word = ((unsigned)__ix < (unsigned)_M_word_size) - ? _M_word[__ix] : _M_grow_words(__ix, false); - return __word._M_pword; - } -# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - virtual ~ios_base(); - - protected: - ios_base() throw (); -# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ios_base.h" 3 - public: - ios_base(const ios_base&) = delete; - - ios_base& - operator=(const ios_base&) = delete; - - protected: - void - _M_move(ios_base&) noexcept; - - void - _M_swap(ios_base& __rhs) noexcept; - - }; - - - - inline ios_base& - boolalpha(ios_base& __base) - { - __base.setf(ios_base::boolalpha); - return __base; - } - - - inline ios_base& - noboolalpha(ios_base& __base) - { - __base.unsetf(ios_base::boolalpha); - return __base; - } - - - inline ios_base& - showbase(ios_base& __base) - { - __base.setf(ios_base::showbase); - return __base; - } - - - inline ios_base& - noshowbase(ios_base& __base) - { - __base.unsetf(ios_base::showbase); - return __base; - } - - - inline ios_base& - showpoint(ios_base& __base) - { - __base.setf(ios_base::showpoint); - return __base; - } - - - inline ios_base& - noshowpoint(ios_base& __base) - { - __base.unsetf(ios_base::showpoint); - return __base; - } - - - inline ios_base& - showpos(ios_base& __base) - { - __base.setf(ios_base::showpos); - return __base; - } - - - inline ios_base& - noshowpos(ios_base& __base) - { - __base.unsetf(ios_base::showpos); - return __base; - } - - - inline ios_base& - skipws(ios_base& __base) - { - __base.setf(ios_base::skipws); - return __base; - } - - - inline ios_base& - noskipws(ios_base& __base) - { - __base.unsetf(ios_base::skipws); - return __base; - } - - - inline ios_base& - uppercase(ios_base& __base) - { - __base.setf(ios_base::uppercase); - return __base; - } - - - inline ios_base& - nouppercase(ios_base& __base) - { - __base.unsetf(ios_base::uppercase); - return __base; - } - - - inline ios_base& - unitbuf(ios_base& __base) - { - __base.setf(ios_base::unitbuf); - return __base; - } - - - inline ios_base& - nounitbuf(ios_base& __base) - { - __base.unsetf(ios_base::unitbuf); - return __base; - } - - - - inline ios_base& - internal(ios_base& __base) - { - __base.setf(ios_base::internal, ios_base::adjustfield); - return __base; - } - - - inline ios_base& - left(ios_base& __base) - { - __base.setf(ios_base::left, ios_base::adjustfield); - return __base; - } - - - inline ios_base& - right(ios_base& __base) - { - __base.setf(ios_base::right, ios_base::adjustfield); - return __base; - } - - - - inline ios_base& - dec(ios_base& __base) - { - __base.setf(ios_base::dec, ios_base::basefield); - return __base; - } - - - inline ios_base& - hex(ios_base& __base) - { - __base.setf(ios_base::hex, ios_base::basefield); - return __base; - } - - - inline ios_base& - oct(ios_base& __base) - { - __base.setf(ios_base::oct, ios_base::basefield); - return __base; - } - - - - inline ios_base& - fixed(ios_base& __base) - { - __base.setf(ios_base::fixed, ios_base::floatfield); - return __base; - } - - - inline ios_base& - scientific(ios_base& __base) - { - __base.setf(ios_base::scientific, ios_base::floatfield); - return __base; - } - - - - - - - inline ios_base& - hexfloat(ios_base& __base) - { - __base.setf(ios_base::fixed | ios_base::scientific, ios_base::floatfield); - return __base; - } - - - inline ios_base& - defaultfloat(ios_base& __base) - { - __base.unsetf(ios_base::floatfield); - return __base; - } - - - -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template - streamsize - __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, - basic_streambuf<_CharT, _Traits>*, bool&); -# 123 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - template - class basic_streambuf - { - public: - - - - - - - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - - - - typedef basic_streambuf __streambuf_type; - - - friend class basic_ios; - friend class basic_istream; - friend class basic_ostream; - friend class istreambuf_iterator; - friend class ostreambuf_iterator; - - friend streamsize - __copy_streambufs_eof<>(basic_streambuf*, basic_streambuf*, bool&); - - template - friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, - _CharT2*>::__type - __copy_move_a2(istreambuf_iterator<_CharT2>, - istreambuf_iterator<_CharT2>, _CharT2*); - - template - friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, - istreambuf_iterator<_CharT2> >::__type - find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, - const _CharT2&); - - template - friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, - void>::__type - advance(istreambuf_iterator<_CharT2>&, _Distance); - - friend void __istream_extract(istream&, char*, streamsize); - - template - friend basic_istream<_CharT2, _Traits2>& - operator>>(basic_istream<_CharT2, _Traits2>&, - basic_string<_CharT2, _Traits2, _Alloc>&); - - template - friend basic_istream<_CharT2, _Traits2>& - getline(basic_istream<_CharT2, _Traits2>&, - basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); - - protected: - - - - - - - - char_type* _M_in_beg; - char_type* _M_in_cur; - char_type* _M_in_end; - char_type* _M_out_beg; - char_type* _M_out_cur; - char_type* _M_out_end; - - - locale _M_buf_locale; - - public: - - virtual - ~basic_streambuf() - { } -# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - locale - pubimbue(const locale& __loc) - { - locale __tmp(this->getloc()); - this->imbue(__loc); - _M_buf_locale = __loc; - return __tmp; - } -# 232 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - locale - getloc() const - { return _M_buf_locale; } -# 245 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - basic_streambuf* - pubsetbuf(char_type* __s, streamsize __n) - { return this->setbuf(__s, __n); } -# 257 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - pos_type - pubseekoff(off_type __off, ios_base::seekdir __way, - ios_base::openmode __mode = ios_base::in | ios_base::out) - { return this->seekoff(__off, __way, __mode); } -# 269 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - pos_type - pubseekpos(pos_type __sp, - ios_base::openmode __mode = ios_base::in | ios_base::out) - { return this->seekpos(__sp, __mode); } - - - - - int - pubsync() { return this->sync(); } -# 290 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - streamsize - in_avail() - { - const streamsize __ret = this->egptr() - this->gptr(); - return __ret ? __ret : this->showmanyc(); - } -# 304 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - int_type - snextc() - { - int_type __ret = traits_type::eof(); - if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), - __ret), true)) - __ret = this->sgetc(); - return __ret; - } -# 322 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - int_type - sbumpc() - { - int_type __ret; - if (__builtin_expect(this->gptr() < this->egptr(), true)) - { - __ret = traits_type::to_int_type(*this->gptr()); - this->gbump(1); - } - else - __ret = this->uflow(); - return __ret; - } -# 344 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - int_type - sgetc() - { - int_type __ret; - if (__builtin_expect(this->gptr() < this->egptr(), true)) - __ret = traits_type::to_int_type(*this->gptr()); - else - __ret = this->underflow(); - return __ret; - } -# 363 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - streamsize - sgetn(char_type* __s, streamsize __n) - { return this->xsgetn(__s, __n); } -# 378 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - int_type - sputbackc(char_type __c) - { - int_type __ret; - const bool __testpos = this->eback() < this->gptr(); - if (__builtin_expect(!__testpos || - !traits_type::eq(__c, this->gptr()[-1]), false)) - __ret = this->pbackfail(traits_type::to_int_type(__c)); - else - { - this->gbump(-1); - __ret = traits_type::to_int_type(*this->gptr()); - } - return __ret; - } -# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - int_type - sungetc() - { - int_type __ret; - if (__builtin_expect(this->eback() < this->gptr(), true)) - { - this->gbump(-1); - __ret = traits_type::to_int_type(*this->gptr()); - } - else - __ret = this->pbackfail(); - return __ret; - } -# 430 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - int_type - sputc(char_type __c) - { - int_type __ret; - if (__builtin_expect(this->pptr() < this->epptr(), true)) - { - *this->pptr() = __c; - this->pbump(1); - __ret = traits_type::to_int_type(__c); - } - else - __ret = this->overflow(traits_type::to_int_type(__c)); - return __ret; - } -# 456 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - streamsize - sputn(const char_type* __s, streamsize __n) - { return this->xsputn(__s, __n); } - - protected: -# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - basic_streambuf() - : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), - _M_out_beg(0), _M_out_cur(0), _M_out_end(0), - _M_buf_locale(locale()) - { } -# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - char_type* - eback() const { return _M_in_beg; } - - char_type* - gptr() const { return _M_in_cur; } - - char_type* - egptr() const { return _M_in_end; } -# 504 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - void - gbump(int __n) { _M_in_cur += __n; } -# 515 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - void - setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) - { - _M_in_beg = __gbeg; - _M_in_cur = __gnext; - _M_in_end = __gend; - } -# 535 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - char_type* - pbase() const { return _M_out_beg; } - - char_type* - pptr() const { return _M_out_cur; } - - char_type* - epptr() const { return _M_out_end; } -# 551 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - void - pbump(int __n) { _M_out_cur += __n; } -# 561 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - void - setp(char_type* __pbeg, char_type* __pend) - { - _M_out_beg = _M_out_cur = __pbeg; - _M_out_end = __pend; - } -# 582 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual void - imbue(const locale& __loc __attribute__ ((__unused__))) - { } -# 597 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual basic_streambuf* - setbuf(char_type*, streamsize) - { return this; } -# 608 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual pos_type - seekoff(off_type, ios_base::seekdir, - ios_base::openmode = ios_base::in | ios_base::out) - { return pos_type(off_type(-1)); } -# 620 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual pos_type - seekpos(pos_type, - ios_base::openmode = ios_base::in | ios_base::out) - { return pos_type(off_type(-1)); } -# 633 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual int - sync() { return 0; } -# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual streamsize - showmanyc() { return 0; } -# 671 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual streamsize - xsgetn(char_type* __s, streamsize __n); -# 693 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual int_type - underflow() - { return traits_type::eof(); } -# 706 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual int_type - uflow() - { - int_type __ret = traits_type::eof(); - const bool __testeof = traits_type::eq_int_type(this->underflow(), - __ret); - if (!__testeof) - { - __ret = traits_type::to_int_type(*this->gptr()); - this->gbump(1); - } - return __ret; - } -# 730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual int_type - pbackfail(int_type __c __attribute__ ((__unused__)) = traits_type::eof()) - { return traits_type::eof(); } -# 748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual streamsize - xsputn(const char_type* __s, streamsize __n); -# 774 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - virtual int_type - overflow(int_type __c __attribute__ ((__unused__)) = traits_type::eof()) - { return traits_type::eof(); } -# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 3 - void - __safe_gbump(streamsize __n) { _M_in_cur += __n; } - - void - __safe_pbump(streamsize __n) { _M_out_cur += __n; } - - - - - protected: - - basic_streambuf(const basic_streambuf&); - - basic_streambuf& - operator=(const basic_streambuf&); - - - void - swap(basic_streambuf& __sb) - { - std::swap(_M_in_beg, __sb._M_in_beg); - std::swap(_M_in_cur, __sb._M_in_cur); - std::swap(_M_in_end, __sb._M_in_end); - std::swap(_M_out_beg, __sb._M_out_beg); - std::swap(_M_out_cur, __sb._M_out_cur); - std::swap(_M_out_end, __sb._M_out_end); - std::swap(_M_buf_locale, __sb._M_buf_locale); - } - - }; - - - template - std::basic_streambuf<_CharT, _Traits>:: - basic_streambuf(const basic_streambuf&) = default; - - template - std::basic_streambuf<_CharT, _Traits>& - std::basic_streambuf<_CharT, _Traits>:: - operator=(const basic_streambuf&) = default; - - - - template<> - streamsize - __copy_streambufs_eof(basic_streambuf* __sbin, - basic_streambuf* __sbout, bool& __ineof); - - template<> - streamsize - __copy_streambufs_eof(basic_streambuf* __sbin, - basic_streambuf* __sbout, bool& __ineof); - - - - - -} - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf.tcc" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf.tcc" 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - streamsize - basic_streambuf<_CharT, _Traits>:: - xsgetn(char_type* __s, streamsize __n) - { - streamsize __ret = 0; - while (__ret < __n) - { - const streamsize __buf_len = this->egptr() - this->gptr(); - if (__buf_len) - { - const streamsize __remaining = __n - __ret; - const streamsize __len = std::min(__buf_len, __remaining); - traits_type::copy(__s, this->gptr(), __len); - __ret += __len; - __s += __len; - this->__safe_gbump(__len); - } - - if (__ret < __n) - { - const int_type __c = this->uflow(); - if (!traits_type::eq_int_type(__c, traits_type::eof())) - { - traits_type::assign(*__s++, traits_type::to_char_type(__c)); - ++__ret; - } - else - break; - } - } - return __ret; - } - - template - streamsize - basic_streambuf<_CharT, _Traits>:: - xsputn(const char_type* __s, streamsize __n) - { - streamsize __ret = 0; - while (__ret < __n) - { - const streamsize __buf_len = this->epptr() - this->pptr(); - if (__buf_len) - { - const streamsize __remaining = __n - __ret; - const streamsize __len = std::min(__buf_len, __remaining); - traits_type::copy(this->pptr(), __s, __len); - __ret += __len; - __s += __len; - this->__safe_pbump(__len); - } - - if (__ret < __n) - { - int_type __c = this->overflow(traits_type::to_int_type(*__s)); - if (!traits_type::eq_int_type(__c, traits_type::eof())) - { - ++__ret; - ++__s; - } - else - break; - } - } - return __ret; - } - - - - - template - streamsize - __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin, - basic_streambuf<_CharT, _Traits>* __sbout, - bool& __ineof) - { - streamsize __ret = 0; - __ineof = true; - typename _Traits::int_type __c = __sbin->sgetc(); - while (!_Traits::eq_int_type(__c, _Traits::eof())) - { - __c = __sbout->sputc(_Traits::to_char_type(__c)); - if (_Traits::eq_int_type(__c, _Traits::eof())) - { - __ineof = false; - break; - } - ++__ret; - __c = __sbin->snextc(); - } - return __ret; - } - - template - inline streamsize - __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin, - basic_streambuf<_CharT, _Traits>* __sbout) - { - bool __ineof; - return __copy_streambufs_eof(__sbin, __sbout, __ineof); - } - - - - - extern template class basic_streambuf; - - extern template - streamsize - __copy_streambufs(basic_streambuf*, - basic_streambuf*); - - - extern template class basic_streambuf; - - extern template - streamsize - __copy_streambufs(basic_streambuf*, - basic_streambuf*); - - - - -} -# 861 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/streambuf" 2 3 -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 3 -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 3 -# 1 "/usr/include/wctype.h" 1 3 4 -# 38 "/usr/include/wctype.h" 3 4 -# 1 "/usr/include/bits/wctype-wchar.h" 1 3 4 -# 38 "/usr/include/bits/wctype-wchar.h" 3 4 -typedef unsigned long int wctype_t; -# 56 "/usr/include/bits/wctype-wchar.h" 3 4 -enum -{ - __ISwupper = 0, - __ISwlower = 1, - __ISwalpha = 2, - __ISwdigit = 3, - __ISwxdigit = 4, - __ISwspace = 5, - __ISwprint = 6, - __ISwgraph = 7, - __ISwblank = 8, - __ISwcntrl = 9, - __ISwpunct = 10, - __ISwalnum = 11, - - _ISwupper = ((__ISwupper) < 8 ? (int) ((1UL << (__ISwupper)) << 24) : ((__ISwupper) < 16 ? (int) ((1UL << (__ISwupper)) << 8) : ((__ISwupper) < 24 ? (int) ((1UL << (__ISwupper)) >> 8) : (int) ((1UL << (__ISwupper)) >> 24)))), - _ISwlower = ((__ISwlower) < 8 ? (int) ((1UL << (__ISwlower)) << 24) : ((__ISwlower) < 16 ? (int) ((1UL << (__ISwlower)) << 8) : ((__ISwlower) < 24 ? (int) ((1UL << (__ISwlower)) >> 8) : (int) ((1UL << (__ISwlower)) >> 24)))), - _ISwalpha = ((__ISwalpha) < 8 ? (int) ((1UL << (__ISwalpha)) << 24) : ((__ISwalpha) < 16 ? (int) ((1UL << (__ISwalpha)) << 8) : ((__ISwalpha) < 24 ? (int) ((1UL << (__ISwalpha)) >> 8) : (int) ((1UL << (__ISwalpha)) >> 24)))), - _ISwdigit = ((__ISwdigit) < 8 ? (int) ((1UL << (__ISwdigit)) << 24) : ((__ISwdigit) < 16 ? (int) ((1UL << (__ISwdigit)) << 8) : ((__ISwdigit) < 24 ? (int) ((1UL << (__ISwdigit)) >> 8) : (int) ((1UL << (__ISwdigit)) >> 24)))), - _ISwxdigit = ((__ISwxdigit) < 8 ? (int) ((1UL << (__ISwxdigit)) << 24) : ((__ISwxdigit) < 16 ? (int) ((1UL << (__ISwxdigit)) << 8) : ((__ISwxdigit) < 24 ? (int) ((1UL << (__ISwxdigit)) >> 8) : (int) ((1UL << (__ISwxdigit)) >> 24)))), - _ISwspace = ((__ISwspace) < 8 ? (int) ((1UL << (__ISwspace)) << 24) : ((__ISwspace) < 16 ? (int) ((1UL << (__ISwspace)) << 8) : ((__ISwspace) < 24 ? (int) ((1UL << (__ISwspace)) >> 8) : (int) ((1UL << (__ISwspace)) >> 24)))), - _ISwprint = ((__ISwprint) < 8 ? (int) ((1UL << (__ISwprint)) << 24) : ((__ISwprint) < 16 ? (int) ((1UL << (__ISwprint)) << 8) : ((__ISwprint) < 24 ? (int) ((1UL << (__ISwprint)) >> 8) : (int) ((1UL << (__ISwprint)) >> 24)))), - _ISwgraph = ((__ISwgraph) < 8 ? (int) ((1UL << (__ISwgraph)) << 24) : ((__ISwgraph) < 16 ? (int) ((1UL << (__ISwgraph)) << 8) : ((__ISwgraph) < 24 ? (int) ((1UL << (__ISwgraph)) >> 8) : (int) ((1UL << (__ISwgraph)) >> 24)))), - _ISwblank = ((__ISwblank) < 8 ? (int) ((1UL << (__ISwblank)) << 24) : ((__ISwblank) < 16 ? (int) ((1UL << (__ISwblank)) << 8) : ((__ISwblank) < 24 ? (int) ((1UL << (__ISwblank)) >> 8) : (int) ((1UL << (__ISwblank)) >> 24)))), - _ISwcntrl = ((__ISwcntrl) < 8 ? (int) ((1UL << (__ISwcntrl)) << 24) : ((__ISwcntrl) < 16 ? (int) ((1UL << (__ISwcntrl)) << 8) : ((__ISwcntrl) < 24 ? (int) ((1UL << (__ISwcntrl)) >> 8) : (int) ((1UL << (__ISwcntrl)) >> 24)))), - _ISwpunct = ((__ISwpunct) < 8 ? (int) ((1UL << (__ISwpunct)) << 24) : ((__ISwpunct) < 16 ? (int) ((1UL << (__ISwpunct)) << 8) : ((__ISwpunct) < 24 ? (int) ((1UL << (__ISwpunct)) >> 8) : (int) ((1UL << (__ISwpunct)) >> 24)))), - _ISwalnum = ((__ISwalnum) < 8 ? (int) ((1UL << (__ISwalnum)) << 24) : ((__ISwalnum) < 16 ? (int) ((1UL << (__ISwalnum)) << 8) : ((__ISwalnum) < 24 ? (int) ((1UL << (__ISwalnum)) >> 8) : (int) ((1UL << (__ISwalnum)) >> 24)))) -}; - - - -extern "C" { - - - - - - - -extern int iswalnum (wint_t __wc) noexcept (true); - - - - - -extern int iswalpha (wint_t __wc) noexcept (true); - - -extern int iswcntrl (wint_t __wc) noexcept (true); - - - -extern int iswdigit (wint_t __wc) noexcept (true); - - - -extern int iswgraph (wint_t __wc) noexcept (true); - - - - -extern int iswlower (wint_t __wc) noexcept (true); - - -extern int iswprint (wint_t __wc) noexcept (true); - - - - -extern int iswpunct (wint_t __wc) noexcept (true); - - - - -extern int iswspace (wint_t __wc) noexcept (true); - - - - -extern int iswupper (wint_t __wc) noexcept (true); - - - - -extern int iswxdigit (wint_t __wc) noexcept (true); - - - - - -extern int iswblank (wint_t __wc) noexcept (true); -# 155 "/usr/include/bits/wctype-wchar.h" 3 4 -extern wctype_t wctype (const char *__property) noexcept (true); - - - -extern int iswctype (wint_t __wc, wctype_t __desc) noexcept (true); - - - - - - -extern wint_t towlower (wint_t __wc) noexcept (true); - - -extern wint_t towupper (wint_t __wc) noexcept (true); - -} -# 39 "/usr/include/wctype.h" 2 3 4 - - - - - -extern "C" { - - - -typedef const __int32_t *wctrans_t; - - - -extern wctrans_t wctrans (const char *__property) noexcept (true); - - -extern wint_t towctrans (wint_t __wc, wctrans_t __desc) noexcept (true); - - - - - - - -extern int iswalnum_l (wint_t __wc, locale_t __locale) noexcept (true); - - - - - -extern int iswalpha_l (wint_t __wc, locale_t __locale) noexcept (true); - - -extern int iswcntrl_l (wint_t __wc, locale_t __locale) noexcept (true); - - - -extern int iswdigit_l (wint_t __wc, locale_t __locale) noexcept (true); - - - -extern int iswgraph_l (wint_t __wc, locale_t __locale) noexcept (true); - - - - -extern int iswlower_l (wint_t __wc, locale_t __locale) noexcept (true); - - -extern int iswprint_l (wint_t __wc, locale_t __locale) noexcept (true); - - - - -extern int iswpunct_l (wint_t __wc, locale_t __locale) noexcept (true); - - - - -extern int iswspace_l (wint_t __wc, locale_t __locale) noexcept (true); - - - - -extern int iswupper_l (wint_t __wc, locale_t __locale) noexcept (true); - - - - -extern int iswxdigit_l (wint_t __wc, locale_t __locale) noexcept (true); - - - - -extern int iswblank_l (wint_t __wc, locale_t __locale) noexcept (true); - - - -extern wctype_t wctype_l (const char *__property, locale_t __locale) - noexcept (true); - - - -extern int iswctype_l (wint_t __wc, wctype_t __desc, locale_t __locale) - noexcept (true); - - - - - - -extern wint_t towlower_l (wint_t __wc, locale_t __locale) noexcept (true); - - -extern wint_t towupper_l (wint_t __wc, locale_t __locale) noexcept (true); - - - -extern wctrans_t wctrans_l (const char *__property, locale_t __locale) - noexcept (true); - - -extern wint_t towctrans_l (wint_t __wc, wctrans_t __desc, - locale_t __locale) noexcept (true); - - - -} -# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 2 3 -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cwctype" 3 -namespace std -{ - using ::wctrans_t; - using ::wctype_t; - using ::wint_t; - - using ::iswalnum; - using ::iswalpha; - - using ::iswblank; - - using ::iswcntrl; - using ::iswctype; - using ::iswdigit; - using ::iswgraph; - using ::iswlower; - using ::iswprint; - using ::iswpunct; - using ::iswspace; - using ::iswupper; - using ::iswxdigit; - using ::towctrans; - using ::towlower; - using ::towupper; - using ::wctrans; - using ::wctype; -} -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cctype" 3 -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/ctype_base.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/ctype_base.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - struct ctype_base - { - - typedef const int* __to_type; - - - - typedef unsigned short mask; - static const mask upper = _ISupper; - static const mask lower = _ISlower; - static const mask alpha = _ISalpha; - static const mask digit = _ISdigit; - static const mask xdigit = _ISxdigit; - static const mask space = _ISspace; - static const mask print = _ISprint; - static const mask graph = _ISalpha | _ISdigit | _ISpunct; - static const mask cntrl = _IScntrl; - static const mask punct = _ISpunct; - static const mask alnum = _ISalpha | _ISdigit; - - static const mask blank = _ISblank; - - }; - - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - class istreambuf_iterator - : public iterator - { - public: -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 3 - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename _Traits::int_type int_type; - typedef basic_streambuf<_CharT, _Traits> streambuf_type; - typedef basic_istream<_CharT, _Traits> istream_type; - - - template - friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, - ostreambuf_iterator<_CharT2> >::__type - copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, - ostreambuf_iterator<_CharT2>); - - template - friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, - _CharT2*>::__type - __copy_move_a2(istreambuf_iterator<_CharT2>, - istreambuf_iterator<_CharT2>, _CharT2*); - - template - friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, - _CharT2*>::__type - __copy_n_a(istreambuf_iterator<_CharT2>, _Size, _CharT2*, bool); - - template - friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, - istreambuf_iterator<_CharT2> >::__type - find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, - const _CharT2&); - - template - friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, - void>::__type - advance(istreambuf_iterator<_CharT2>&, _Distance); - - private: - - - - - - - - mutable streambuf_type* _M_sbuf; - int_type _M_c; - - public: - - constexpr istreambuf_iterator() noexcept - : _M_sbuf(0), _M_c(traits_type::eof()) { } - - - - - - - - istreambuf_iterator(const istreambuf_iterator&) noexcept = default; - - ~istreambuf_iterator() = default; - - - - istreambuf_iterator(istream_type& __s) noexcept - : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { } - - - istreambuf_iterator(streambuf_type* __s) noexcept - : _M_sbuf(__s), _M_c(traits_type::eof()) { } - - - istreambuf_iterator& - operator=(const istreambuf_iterator&) noexcept = default; - - - - - - [[__nodiscard__]] - char_type - operator*() const - { - int_type __c = _M_get(); -# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 3 - return traits_type::to_char_type(__c); - } - - - istreambuf_iterator& - operator++() - { - - - - ; - - _M_sbuf->sbumpc(); - _M_c = traits_type::eof(); - return *this; - } - - - istreambuf_iterator - operator++(int) - { - - - - ; - - istreambuf_iterator __old = *this; - __old._M_c = _M_sbuf->sbumpc(); - _M_c = traits_type::eof(); - return __old; - } - - - - - - [[__nodiscard__]] - bool - equal(const istreambuf_iterator& __b) const - { return _M_at_eof() == __b._M_at_eof(); } - - private: - int_type - _M_get() const - { - int_type __ret = _M_c; - if (_M_sbuf && _S_is_eof(__ret) && _S_is_eof(__ret = _M_sbuf->sgetc())) - _M_sbuf = 0; - return __ret; - } - - bool - _M_at_eof() const - { return _S_is_eof(_M_get()); } - - static bool - _S_is_eof(int_type __c) - { - const int_type __eof = traits_type::eof(); - return traits_type::eq_int_type(__c, __eof); - } - - - - - - - - }; - - template - [[__nodiscard__]] - inline bool - operator==(const istreambuf_iterator<_CharT, _Traits>& __a, - const istreambuf_iterator<_CharT, _Traits>& __b) - { return __a.equal(__b); } - - - template - [[__nodiscard__]] - inline bool - operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, - const istreambuf_iterator<_CharT, _Traits>& __b) - { return !__a.equal(__b); } - - - - template - class ostreambuf_iterator - : public iterator - { - public: - - - - - - - typedef _CharT char_type; - typedef _Traits traits_type; - typedef basic_streambuf<_CharT, _Traits> streambuf_type; - typedef basic_ostream<_CharT, _Traits> ostream_type; - - - template - friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, - ostreambuf_iterator<_CharT2> >::__type - copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, - ostreambuf_iterator<_CharT2>); - - private: - streambuf_type* _M_sbuf; - bool _M_failed; - - public: -# 284 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/streambuf_iterator.h" 3 - ostreambuf_iterator(ostream_type& __s) noexcept - : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { } - - - ostreambuf_iterator(streambuf_type* __s) noexcept - : _M_sbuf(__s), _M_failed(!_M_sbuf) { } - - - ostreambuf_iterator& - operator=(_CharT __c) - { - if (!_M_failed && - _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) - _M_failed = true; - return *this; - } - - - [[__nodiscard__]] - ostreambuf_iterator& - operator*() - { return *this; } - - - ostreambuf_iterator& - operator++(int) - { return *this; } - - - ostreambuf_iterator& - operator++() - { return *this; } - - - [[__nodiscard__]] - bool - failed() const noexcept - { return _M_failed; } - - ostreambuf_iterator& - _M_put(const _CharT* __ws, streamsize __len) - { - if (__builtin_expect(!_M_failed, true) - && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, - false)) - _M_failed = true; - return *this; - } - }; -#pragma GCC diagnostic pop - - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT> >::__type - copy(istreambuf_iterator<_CharT> __first, - istreambuf_iterator<_CharT> __last, - ostreambuf_iterator<_CharT> __result) - { - if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed) - { - bool __ineof; - __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof); - if (!__ineof) - __result._M_failed = true; - } - return __result; - } - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT> >::__type - __copy_move_a2(_CharT* __first, _CharT* __last, - ostreambuf_iterator<_CharT> __result) - { - const streamsize __num = __last - __first; - if (__num > 0) - __result._M_put(__first, __num); - return __result; - } - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT> >::__type - __copy_move_a2(const _CharT* __first, const _CharT* __last, - ostreambuf_iterator<_CharT> __result) - { - const streamsize __num = __last - __first; - if (__num > 0) - __result._M_put(__first, __num); - return __result; - } - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - _CharT*>::__type - __copy_move_a2(istreambuf_iterator<_CharT> __first, - istreambuf_iterator<_CharT> __last, _CharT* __result) - { - typedef istreambuf_iterator<_CharT> __is_iterator_type; - typedef typename __is_iterator_type::traits_type traits_type; - typedef typename __is_iterator_type::streambuf_type streambuf_type; - typedef typename traits_type::int_type int_type; - - if (__first._M_sbuf && !__last._M_sbuf) - { - streambuf_type* __sb = __first._M_sbuf; - int_type __c = __sb->sgetc(); - while (!traits_type::eq_int_type(__c, traits_type::eof())) - { - const streamsize __n = __sb->egptr() - __sb->gptr(); - if (__n > 1) - { - traits_type::copy(__result, __sb->gptr(), __n); - __sb->__safe_gbump(__n); - __result += __n; - __c = __sb->underflow(); - } - else - { - *__result++ = traits_type::to_char_type(__c); - __c = __sb->snextc(); - } - } - } - return __result; - } - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - _CharT*>::__type - __copy_n_a(istreambuf_iterator<_CharT> __it, _Size __n, _CharT* __result, - bool __strict __attribute__((__unused__))) - { - if (__n == 0) - return __result; - - - - ; - _CharT* __beg = __result; - __result += __it._M_sbuf->sgetn(__beg, __n); - - - ; - return __result; - } - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - istreambuf_iterator<_CharT> >::__type - find(istreambuf_iterator<_CharT> __first, - istreambuf_iterator<_CharT> __last, const _CharT& __val) - { - typedef istreambuf_iterator<_CharT> __is_iterator_type; - typedef typename __is_iterator_type::traits_type traits_type; - typedef typename __is_iterator_type::streambuf_type streambuf_type; - typedef typename traits_type::int_type int_type; - const int_type __eof = traits_type::eof(); - - if (__first._M_sbuf && !__last._M_sbuf) - { - const int_type __ival = traits_type::to_int_type(__val); - streambuf_type* __sb = __first._M_sbuf; - int_type __c = __sb->sgetc(); - while (!traits_type::eq_int_type(__c, __eof) - && !traits_type::eq_int_type(__c, __ival)) - { - streamsize __n = __sb->egptr() - __sb->gptr(); - if (__n > 1) - { - const _CharT* __p = traits_type::find(__sb->gptr(), - __n, __val); - if (__p) - __n = __p - __sb->gptr(); - __sb->__safe_gbump(__n); - __c = __sb->sgetc(); - } - else - __c = __sb->snextc(); - } - - __first._M_c = __eof; - } - - return __first; - } - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - void>::__type - advance(istreambuf_iterator<_CharT>& __i, _Distance __n) - { - if (__n == 0) - return; - - do { if (std::__is_constant_evaluated() && !bool(__n > 0)) __builtin_unreachable(); } while (false); - - - ; - - typedef istreambuf_iterator<_CharT> __is_iterator_type; - typedef typename __is_iterator_type::traits_type traits_type; - typedef typename __is_iterator_type::streambuf_type streambuf_type; - typedef typename traits_type::int_type int_type; - const int_type __eof = traits_type::eof(); - - streambuf_type* __sb = __i._M_sbuf; - while (__n > 0) - { - streamsize __size = __sb->egptr() - __sb->gptr(); - if (__size > __n) - { - __sb->__safe_gbump(__n); - break; - } - - __sb->__safe_gbump(__size); - __n -= __size; - if (traits_type::eq_int_type(__sb->underflow(), __eof)) - { - - - ; - break; - } - } - - __i._M_c = __eof; - } - - - - -} -# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - template - void - __convert_to_v(const char*, _Tp&, ios_base::iostate&, - const __c_locale&) throw(); - - - template<> - void - __convert_to_v(const char*, float&, ios_base::iostate&, - const __c_locale&) throw(); - - template<> - void - __convert_to_v(const char*, double&, ios_base::iostate&, - const __c_locale&) throw(); - - template<> - void - __convert_to_v(const char*, long double&, ios_base::iostate&, - const __c_locale&) throw(); - - - - template - struct __pad - { - static void - _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, - const _CharT* __olds, streamsize __newlen, streamsize __oldlen); - }; - - - - - - - template - _CharT* - __add_grouping(_CharT* __s, _CharT __sep, - const char* __gbeg, size_t __gsize, - const _CharT* __first, const _CharT* __last); - - - - - template - inline - ostreambuf_iterator<_CharT> - __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) - { - __s._M_put(__ws, __len); - return __s; - } - - - template - inline - _OutIter - __write(_OutIter __s, const _CharT* __ws, int __len) - { - for (int __j = 0; __j < __len; __j++, ++__s) - *__s = __ws[__j]; - return __s; - } -# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - template - class __ctype_abstract_base : public locale::facet, public ctype_base - { - public: - - - typedef _CharT char_type; -# 171 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - bool - is(mask __m, char_type __c) const - { return this->do_is(__m, __c); } -# 188 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char_type* - is(const char_type *__lo, const char_type *__hi, mask *__vec) const - { return this->do_is(__lo, __hi, __vec); } -# 204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char_type* - scan_is(mask __m, const char_type* __lo, const char_type* __hi) const - { return this->do_scan_is(__m, __lo, __hi); } -# 220 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char_type* - scan_not(mask __m, const char_type* __lo, const char_type* __hi) const - { return this->do_scan_not(__m, __lo, __hi); } -# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char_type - toupper(char_type __c) const - { return this->do_toupper(__c); } -# 249 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char_type* - toupper(char_type *__lo, const char_type* __hi) const - { return this->do_toupper(__lo, __hi); } -# 263 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char_type - tolower(char_type __c) const - { return this->do_tolower(__c); } -# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char_type* - tolower(char_type* __lo, const char_type* __hi) const - { return this->do_tolower(__lo, __hi); } -# 295 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char_type - widen(char __c) const - { return this->do_widen(__c); } -# 314 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char* - widen(const char* __lo, const char* __hi, char_type* __to) const - { return this->do_widen(__lo, __hi, __to); } -# 333 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char - narrow(char_type __c, char __dfault) const - { return this->do_narrow(__c, __dfault); } -# 355 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char_type* - narrow(const char_type* __lo, const char_type* __hi, - char __dfault, char* __to) const - { return this->do_narrow(__lo, __hi, __dfault, __to); } - - protected: - explicit - __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } - - virtual - ~__ctype_abstract_base() { } -# 380 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual bool - do_is(mask __m, char_type __c) const = 0; -# 399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_is(const char_type* __lo, const char_type* __hi, - mask* __vec) const = 0; -# 418 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_scan_is(mask __m, const char_type* __lo, - const char_type* __hi) const = 0; -# 437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_scan_not(mask __m, const char_type* __lo, - const char_type* __hi) const = 0; -# 455 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_toupper(char_type __c) const = 0; -# 472 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_toupper(char_type* __lo, const char_type* __hi) const = 0; -# 488 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_tolower(char_type __c) const = 0; -# 505 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_tolower(char_type* __lo, const char_type* __hi) const = 0; -# 524 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_widen(char __c) const = 0; -# 545 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char* - do_widen(const char* __lo, const char* __hi, char_type* __to) const = 0; -# 566 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char - do_narrow(char_type __c, char __dfault) const = 0; -# 591 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_narrow(const char_type* __lo, const char_type* __hi, - char __dfault, char* __to) const = 0; - }; -# 614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - template - class ctype : public __ctype_abstract_base<_CharT> - { - public: - - typedef _CharT char_type; - typedef typename __ctype_abstract_base<_CharT>::mask mask; - - - static locale::id id; - - explicit - ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } - - protected: - virtual - ~ctype(); - - virtual bool - do_is(mask __m, char_type __c) const; - - virtual const char_type* - do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; - - virtual const char_type* - do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; - - virtual const char_type* - do_scan_not(mask __m, const char_type* __lo, - const char_type* __hi) const; - - virtual char_type - do_toupper(char_type __c) const; - - virtual const char_type* - do_toupper(char_type* __lo, const char_type* __hi) const; - - virtual char_type - do_tolower(char_type __c) const; - - virtual const char_type* - do_tolower(char_type* __lo, const char_type* __hi) const; - - virtual char_type - do_widen(char __c) const; - - virtual const char* - do_widen(const char* __lo, const char* __hi, char_type* __dest) const; - - virtual char - do_narrow(char_type, char __dfault) const; - - virtual const char_type* - do_narrow(const char_type* __lo, const char_type* __hi, - char __dfault, char* __to) const; - }; - - template - locale::id ctype<_CharT>::id; - - - - template - class ctype >; -# 688 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - template<> - class ctype : public locale::facet, public ctype_base - { - public: - - - typedef char char_type; - - protected: - - __c_locale _M_c_locale_ctype; - bool _M_del; - __to_type _M_toupper; - __to_type _M_tolower; - const mask* _M_table; - mutable char _M_widen_ok; - mutable char _M_widen[1 + static_cast(-1)]; - mutable char _M_narrow[1 + static_cast(-1)]; - mutable char _M_narrow_ok; - - - public: - - static locale::id id; - - static const size_t table_size = 1 + static_cast(-1); -# 725 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - explicit - ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); -# 738 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - explicit - ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, - size_t __refs = 0); -# 751 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - inline bool - is(mask __m, char __c) const; -# 766 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - inline const char* - is(const char* __lo, const char* __hi, mask* __vec) const; -# 780 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - inline const char* - scan_is(mask __m, const char* __lo, const char* __hi) const; -# 794 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - inline const char* - scan_not(mask __m, const char* __lo, const char* __hi) const; -# 809 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char_type - toupper(char_type __c) const - { return this->do_toupper(__c); } -# 826 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char_type* - toupper(char_type *__lo, const char_type* __hi) const - { return this->do_toupper(__lo, __hi); } -# 842 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char_type - tolower(char_type __c) const - { return this->do_tolower(__c); } -# 859 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char_type* - tolower(char_type* __lo, const char_type* __hi) const - { return this->do_tolower(__lo, __hi); } -# 879 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char_type - widen(char __c) const - { - if (_M_widen_ok) - return _M_widen[static_cast(__c)]; - this->_M_widen_init(); - return this->do_widen(__c); - } -# 906 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char* - widen(const char* __lo, const char* __hi, char_type* __to) const - { - if (_M_widen_ok == 1) - { - if (__builtin_expect(__hi != __lo, true)) - __builtin_memcpy(__to, __lo, __hi - __lo); - return __hi; - } - if (!_M_widen_ok) - _M_widen_init(); - return this->do_widen(__lo, __hi, __to); - } -# 938 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char - narrow(char_type __c, char __dfault) const - { - if (_M_narrow[static_cast(__c)]) - return _M_narrow[static_cast(__c)]; - const char __t = do_narrow(__c, __dfault); - if (__t != __dfault) - _M_narrow[static_cast(__c)] = __t; - return __t; - } -# 971 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - const char_type* - narrow(const char_type* __lo, const char_type* __hi, - char __dfault, char* __to) const - { - if (__builtin_expect(_M_narrow_ok == 1, true)) - { - if (__builtin_expect(__hi != __lo, true)) - __builtin_memcpy(__to, __lo, __hi - __lo); - return __hi; - } - if (!_M_narrow_ok) - _M_narrow_init(); - return this->do_narrow(__lo, __hi, __dfault, __to); - } - - - - - - const mask* - table() const throw() - { return _M_table; } - - - static const mask* - classic_table() throw(); - protected: - - - - - - - - virtual - ~ctype(); -# 1021 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_toupper(char_type __c) const; -# 1038 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_toupper(char_type* __lo, const char_type* __hi) const; -# 1054 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_tolower(char_type __c) const; -# 1071 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_tolower(char_type* __lo, const char_type* __hi) const; -# 1091 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_widen(char __c) const - { return __c; } -# 1114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char* - do_widen(const char* __lo, const char* __hi, char_type* __to) const - { - if (__builtin_expect(__hi != __lo, true)) - __builtin_memcpy(__to, __lo, __hi - __lo); - return __hi; - } -# 1141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char - do_narrow(char_type __c, char __dfault __attribute__((__unused__))) const - { return __c; } -# 1167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_narrow(const char_type* __lo, const char_type* __hi, - char __dfault __attribute__((__unused__)), char* __to) const - { - if (__builtin_expect(__hi != __lo, true)) - __builtin_memcpy(__to, __lo, __hi - __lo); - return __hi; - } - - private: - void _M_narrow_init() const; - void _M_widen_init() const; - }; -# 1193 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - template<> - class ctype : public __ctype_abstract_base - { - public: - - - typedef wchar_t char_type; - typedef wctype_t __wmask_type; - - protected: - __c_locale _M_c_locale_ctype; - - - bool _M_narrow_ok; - char _M_narrow[128]; - wint_t _M_widen[1 + static_cast(-1)]; - - - mask _M_bit[16]; - __wmask_type _M_wmask[16]; - - public: - - - static locale::id id; -# 1226 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - explicit - ctype(size_t __refs = 0); -# 1237 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - explicit - ctype(__c_locale __cloc, size_t __refs = 0); - - protected: - __wmask_type - _M_convert_to_wmask(const mask __m) const throw(); - - - virtual - ~ctype(); -# 1261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual bool - do_is(mask __m, char_type __c) const; -# 1280 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; -# 1298 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; -# 1316 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_scan_not(mask __m, const char_type* __lo, - const char_type* __hi) const; -# 1333 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_toupper(char_type __c) const; -# 1350 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_toupper(char_type* __lo, const char_type* __hi) const; -# 1366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_tolower(char_type __c) const; -# 1383 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_tolower(char_type* __lo, const char_type* __hi) const; -# 1403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_widen(char __c) const; -# 1425 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char* - do_widen(const char* __lo, const char* __hi, char_type* __to) const; -# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char - do_narrow(char_type __c, char __dfault) const; -# 1474 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual const char_type* - do_narrow(const char_type* __lo, const char_type* __hi, - char __dfault, char* __to) const; - - - void - _M_initialize_ctype() throw(); - }; - - - - template - class ctype_byname : public ctype<_CharT> - { - public: - typedef typename ctype<_CharT>::mask mask; - - explicit - ctype_byname(const char* __s, size_t __refs = 0); - - - explicit - ctype_byname(const string& __s, size_t __refs = 0) - : ctype_byname(__s.c_str(), __refs) { } - - - protected: - virtual - ~ctype_byname() { } - }; - - - template<> - class ctype_byname : public ctype - { - public: - explicit - ctype_byname(const char* __s, size_t __refs = 0); - - - explicit - ctype_byname(const string& __s, size_t __refs = 0); - - - protected: - virtual - ~ctype_byname(); - }; - - - template<> - class ctype_byname : public ctype - { - public: - explicit - ctype_byname(const char* __s, size_t __refs = 0); - - - explicit - ctype_byname(const string& __s, size_t __refs = 0); - - - protected: - virtual - ~ctype_byname(); - }; - - - -} - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/ctype_inline.h" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/ctype_inline.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - bool - ctype:: - is(mask __m, char __c) const - { return _M_table[static_cast(__c)] & __m; } - - const char* - ctype:: - is(const char* __low, const char* __high, mask* __vec) const - { - while (__low < __high) - *__vec++ = _M_table[static_cast(*__low++)]; - return __high; - } - - const char* - ctype:: - scan_is(mask __m, const char* __low, const char* __high) const - { - while (__low < __high - && !(_M_table[static_cast(*__low)] & __m)) - ++__low; - return __low; - } - - const char* - ctype:: - scan_not(mask __m, const char* __low, const char* __high) const - { - while (__low < __high - && (_M_table[static_cast(*__low)] & __m) != 0) - ++__low; - return __low; - } - - -} -# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - class __num_base - { - public: - - - enum - { - _S_ominus, - _S_oplus, - _S_ox, - _S_oX, - _S_odigits, - _S_odigits_end = _S_odigits + 16, - _S_oudigits = _S_odigits_end, - _S_oudigits_end = _S_oudigits + 16, - _S_oe = _S_odigits + 14, - _S_oE = _S_oudigits + 14, - _S_oend = _S_oudigits_end - }; - - - - - - - static const char* _S_atoms_out; - - - - static const char* _S_atoms_in; - - enum - { - _S_iminus, - _S_iplus, - _S_ix, - _S_iX, - _S_izero, - _S_ie = _S_izero + 14, - _S_iE = _S_izero + 20, - _S_iend = 26 - }; - - - - static void - _S_format_float(const ios_base& __io, char* __fptr, char __mod) throw(); - }; - - template - struct __numpunct_cache : public locale::facet - { - const char* _M_grouping; - size_t _M_grouping_size; - bool _M_use_grouping; - const _CharT* _M_truename; - size_t _M_truename_size; - const _CharT* _M_falsename; - size_t _M_falsename_size; - _CharT _M_decimal_point; - _CharT _M_thousands_sep; - - - - - - _CharT _M_atoms_out[__num_base::_S_oend]; - - - - - - _CharT _M_atoms_in[__num_base::_S_iend]; - - bool _M_allocated; - - __numpunct_cache(size_t __refs = 0) - : facet(__refs), _M_grouping(0), _M_grouping_size(0), - _M_use_grouping(false), - _M_truename(0), _M_truename_size(0), _M_falsename(0), - _M_falsename_size(0), _M_decimal_point(_CharT()), - _M_thousands_sep(_CharT()), _M_allocated(false) - { } - - ~__numpunct_cache(); - - void - _M_cache(const locale& __loc); - - private: - __numpunct_cache& - operator=(const __numpunct_cache&); - - explicit - __numpunct_cache(const __numpunct_cache&); - }; - - template - __numpunct_cache<_CharT>::~__numpunct_cache() - { - if (_M_allocated) - { - delete [] _M_grouping; - delete [] _M_truename; - delete [] _M_falsename; - } - } - -namespace __cxx11 { -# 1677 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - template - class numpunct : public locale::facet - { - public: - - - - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - typedef __numpunct_cache<_CharT> __cache_type; - - protected: - __cache_type* _M_data; - - public: - - static locale::id id; - - - - - - - explicit - numpunct(size_t __refs = 0) - : facet(__refs), _M_data(0) - { _M_initialize_numpunct(); } -# 1715 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - explicit - numpunct(__cache_type* __cache, size_t __refs = 0) - : facet(__refs), _M_data(__cache) - { _M_initialize_numpunct(); } -# 1729 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - explicit - numpunct(__c_locale __cloc, size_t __refs = 0) - : facet(__refs), _M_data(0) - { _M_initialize_numpunct(__cloc); } -# 1743 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char_type - decimal_point() const - { return this->do_decimal_point(); } -# 1756 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - char_type - thousands_sep() const - { return this->do_thousands_sep(); } -# 1787 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - string - grouping() const - { return this->do_grouping(); } -# 1800 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - string_type - truename() const - { return this->do_truename(); } -# 1813 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - string_type - falsename() const - { return this->do_falsename(); } - - protected: - - virtual - ~numpunct(); -# 1830 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_decimal_point() const - { return _M_data->_M_decimal_point; } -# 1842 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual char_type - do_thousands_sep() const - { return _M_data->_M_thousands_sep; } -# 1855 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual string - do_grouping() const - { return _M_data->_M_grouping; } -# 1868 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual string_type - do_truename() const - { return _M_data->_M_truename; } -# 1881 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual string_type - do_falsename() const - { return _M_data->_M_falsename; } - - - void - _M_initialize_numpunct(__c_locale __cloc = 0); - }; - - template - locale::id numpunct<_CharT>::id; - - template<> - numpunct::~numpunct(); - - template<> - void - numpunct::_M_initialize_numpunct(__c_locale __cloc); - - - template<> - numpunct::~numpunct(); - - template<> - void - numpunct::_M_initialize_numpunct(__c_locale __cloc); - - - - template - class numpunct_byname : public numpunct<_CharT> - { - public: - typedef _CharT char_type; - typedef basic_string<_CharT> string_type; - - explicit - numpunct_byname(const char* __s, size_t __refs = 0) - : numpunct<_CharT>(__refs) - { - if (__builtin_strcmp(__s, "C") != 0 - && __builtin_strcmp(__s, "POSIX") != 0) - { - __c_locale __tmp; - this->_S_create_c_locale(__tmp, __s); - this->_M_initialize_numpunct(__tmp); - this->_S_destroy_c_locale(__tmp); - } - } - - - explicit - numpunct_byname(const string& __s, size_t __refs = 0) - : numpunct_byname(__s.c_str(), __refs) { } - - - protected: - virtual - ~numpunct_byname() { } - }; - -} -# 1959 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - template - class num_get : public locale::facet - { - public: - - - - typedef _CharT char_type; - typedef _InIter iter_type; - - - - static locale::id id; -# 1980 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - explicit - num_get(size_t __refs = 0) : facet(__refs) { } -# 2006 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, bool& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } -# 2043 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned short& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned int& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned long& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } - - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long long& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned long long& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } -# 2103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, float& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, double& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } - - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long double& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } -# 2146 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - iter_type - get(iter_type __in, iter_type __end, ios_base& __io, - ios_base::iostate& __err, void*& __v) const - { return this->do_get(__in, __end, __io, __err, __v); } - - protected: - - virtual ~num_get() { } - - __attribute ((__abi_tag__ ("cxx11"))) - iter_type - _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&, - string&) const; - - template - __attribute ((__abi_tag__ ("cxx11"))) - iter_type - _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, - _ValueT&) const; - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type - _M_find(const _CharT2*, size_t __len, _CharT2 __c) const - { - int __ret = -1; - if (__len <= 10) - { - if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len)) - __ret = __c - _CharT2('0'); - } - else - { - if (__c >= _CharT2('0') && __c <= _CharT2('9')) - __ret = __c - _CharT2('0'); - else if (__c >= _CharT2('a') && __c <= _CharT2('f')) - __ret = 10 + (__c - _CharT2('a')); - else if (__c >= _CharT2('A') && __c <= _CharT2('F')) - __ret = 10 + (__c - _CharT2('A')); - } - return __ret; - } - - template - typename __gnu_cxx::__enable_if::__value, - int>::__type - _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const - { - int __ret = -1; - const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); - if (__q) - { - __ret = __q - __zero; - if (__ret > 15) - __ret -= 6; - } - return __ret; - } -# 2219 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; - - virtual iter_type - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long& __v) const - { return _M_extract_int(__beg, __end, __io, __err, __v); } - - virtual iter_type - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned short& __v) const - { return _M_extract_int(__beg, __end, __io, __err, __v); } - - virtual iter_type - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned int& __v) const - { return _M_extract_int(__beg, __end, __io, __err, __v); } - - virtual iter_type - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned long& __v) const - { return _M_extract_int(__beg, __end, __io, __err, __v); } - - - virtual iter_type - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long long& __v) const - { return _M_extract_int(__beg, __end, __io, __err, __v); } - - virtual iter_type - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, unsigned long long& __v) const - { return _M_extract_int(__beg, __end, __io, __err, __v); } - - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, float&) const; - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, - double&) const; -# 2271 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, - long double&) const; - - - virtual iter_type - do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, void*&) const; -# 2299 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - }; - - template - locale::id num_get<_CharT, _InIter>::id; -# 2317 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - template - class num_put : public locale::facet - { - public: - - - - typedef _CharT char_type; - typedef _OutIter iter_type; - - - - static locale::id id; -# 2338 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - explicit - num_put(size_t __refs = 0) : facet(__refs) { } -# 2356 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - iter_type - put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const - { return this->do_put(__s, __io, __fill, __v); } -# 2398 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - iter_type - put(iter_type __s, ios_base& __io, char_type __fill, long __v) const - { return this->do_put(__s, __io, __fill, __v); } - - iter_type - put(iter_type __s, ios_base& __io, char_type __fill, - unsigned long __v) const - { return this->do_put(__s, __io, __fill, __v); } - - - iter_type - put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const - { return this->do_put(__s, __io, __fill, __v); } - - iter_type - put(iter_type __s, ios_base& __io, char_type __fill, - unsigned long long __v) const - { return this->do_put(__s, __io, __fill, __v); } -# 2461 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - iter_type - put(iter_type __s, ios_base& __io, char_type __fill, double __v) const - { return this->do_put(__s, __io, __fill, __v); } - - iter_type - put(iter_type __s, ios_base& __io, char_type __fill, - long double __v) const - { return this->do_put(__s, __io, __fill, __v); } -# 2486 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - iter_type - put(iter_type __s, ios_base& __io, char_type __fill, - const void* __v) const - { return this->do_put(__s, __io, __fill, __v); } - - protected: - template - iter_type - _M_insert_float(iter_type, ios_base& __io, char_type __fill, - char __mod, _ValueT __v) const; - - void - _M_group_float(const char* __grouping, size_t __grouping_size, - char_type __sep, const char_type* __p, char_type* __new, - char_type* __cs, int& __len) const; - - template - iter_type - _M_insert_int(iter_type, ios_base& __io, char_type __fill, - _ValueT __v) const; - - void - _M_group_int(const char* __grouping, size_t __grouping_size, - char_type __sep, ios_base& __io, char_type* __new, - char_type* __cs, int& __len) const; - - void - _M_pad(char_type __fill, streamsize __w, ios_base& __io, - char_type* __new, const char_type* __cs, int& __len) const; - - - virtual - ~num_put() { } -# 2534 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - virtual iter_type - do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const; - - virtual iter_type - do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const - { return _M_insert_int(__s, __io, __fill, __v); } - - virtual iter_type - do_put(iter_type __s, ios_base& __io, char_type __fill, - unsigned long __v) const - { return _M_insert_int(__s, __io, __fill, __v); } - - - virtual iter_type - do_put(iter_type __s, ios_base& __io, char_type __fill, - long long __v) const - { return _M_insert_int(__s, __io, __fill, __v); } - - virtual iter_type - do_put(iter_type __s, ios_base& __io, char_type __fill, - unsigned long long __v) const - { return _M_insert_int(__s, __io, __fill, __v); } - - - virtual iter_type - do_put(iter_type, ios_base&, char_type, double) const; - - - - - - - virtual iter_type - do_put(iter_type, ios_base&, char_type, long double) const; - - - virtual iter_type - do_put(iter_type, ios_base&, char_type, const void*) const; -# 2586 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - }; - - template - locale::id num_put<_CharT, _OutIter>::id; -# 2599 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 3 - template - inline bool - isspace(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::space, __c); } - - - template - inline bool - isprint(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::print, __c); } - - - template - inline bool - iscntrl(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::cntrl, __c); } - - - template - inline bool - isupper(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::upper, __c); } - - - template - inline bool - islower(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::lower, __c); } - - - template - inline bool - isalpha(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::alpha, __c); } - - - template - inline bool - isdigit(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::digit, __c); } - - - template - inline bool - ispunct(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::punct, __c); } - - - template - inline bool - isxdigit(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::xdigit, __c); } - - - template - inline bool - isalnum(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::alnum, __c); } - - - template - inline bool - isgraph(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::graph, __c); } - - - - template - inline bool - isblank(_CharT __c, const locale& __loc) - { return use_facet >(__loc).is(ctype_base::blank, __c); } - - - - template - inline _CharT - toupper(_CharT __c, const locale& __loc) - { return use_facet >(__loc).toupper(__c); } - - - template - inline _CharT - tolower(_CharT __c, const locale& __loc) - { return use_facet >(__loc).tolower(__c); } - - -} - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template - struct __use_cache - { - const _Facet* - operator() (const locale& __loc) const; - }; - - - template - struct __use_cache<__numpunct_cache<_CharT> > - { - const __numpunct_cache<_CharT>* - operator() (const locale& __loc) const - { - const size_t __i = numpunct<_CharT>::id._M_id(); - const locale::facet** __caches = __loc._M_impl->_M_caches; - if (!__caches[__i]) - { - __numpunct_cache<_CharT>* __tmp = 0; - try - { - __tmp = new __numpunct_cache<_CharT>; - __tmp->_M_cache(__loc); - } - catch(...) - { - delete __tmp; - throw; - } - __loc._M_impl->_M_install_cache(__tmp, __i); - } - return static_cast*>(__caches[__i]); - } - }; - - template - void - __numpunct_cache<_CharT>::_M_cache(const locale& __loc) - { - const numpunct<_CharT>& __np = use_facet >(__loc); - - char* __grouping = 0; - _CharT* __truename = 0; - _CharT* __falsename = 0; - try - { - const string& __g = __np.grouping(); - _M_grouping_size = __g.size(); - __grouping = new char[_M_grouping_size]; - __g.copy(__grouping, _M_grouping_size); - _M_use_grouping = (_M_grouping_size - && static_cast(__grouping[0]) > 0 - && (__grouping[0] - != __gnu_cxx::__numeric_traits::__max)); - - const basic_string<_CharT>& __tn = __np.truename(); - _M_truename_size = __tn.size(); - __truename = new _CharT[_M_truename_size]; - __tn.copy(__truename, _M_truename_size); - - const basic_string<_CharT>& __fn = __np.falsename(); - _M_falsename_size = __fn.size(); - __falsename = new _CharT[_M_falsename_size]; - __fn.copy(__falsename, _M_falsename_size); - - _M_decimal_point = __np.decimal_point(); - _M_thousands_sep = __np.thousands_sep(); - - const ctype<_CharT>& __ct = use_facet >(__loc); - __ct.widen(__num_base::_S_atoms_out, - __num_base::_S_atoms_out - + __num_base::_S_oend, _M_atoms_out); - __ct.widen(__num_base::_S_atoms_in, - __num_base::_S_atoms_in - + __num_base::_S_iend, _M_atoms_in); - - _M_grouping = __grouping; - _M_truename = __truename; - _M_falsename = __falsename; - _M_allocated = true; - } - catch(...) - { - delete [] __grouping; - delete [] __truename; - delete [] __falsename; - throw; - } - } -# 139 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 - __attribute__ ((__pure__)) bool - __verify_grouping(const char* __grouping, size_t __grouping_size, - const string& __grouping_tmp) throw (); - - - - template - __attribute ((__abi_tag__ ("cxx11"))) - _InIter - num_get<_CharT, _InIter>:: - _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io, - ios_base::iostate& __err, string& __xtrc) const - { - typedef char_traits<_CharT> __traits_type; - typedef __numpunct_cache<_CharT> __cache_type; - __use_cache<__cache_type> __uc; - const locale& __loc = __io._M_getloc(); - const __cache_type* __lc = __uc(__loc); - const _CharT* __lit = __lc->_M_atoms_in; - char_type __c = char_type(); - - - bool __testeof = __beg == __end; - - - if (!__testeof) - { - __c = *__beg; - const bool __plus = __c == __lit[__num_base::_S_iplus]; - if ((__plus || __c == __lit[__num_base::_S_iminus]) - && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) - && !(__c == __lc->_M_decimal_point)) - { - __xtrc += __plus ? '+' : '-'; - if (++__beg != __end) - __c = *__beg; - else - __testeof = true; - } - } - - - bool __found_mantissa = false; - int __sep_pos = 0; - while (!__testeof) - { - if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) - || __c == __lc->_M_decimal_point) - break; - else if (__c == __lit[__num_base::_S_izero]) - { - if (!__found_mantissa) - { - __xtrc += '0'; - __found_mantissa = true; - } - ++__sep_pos; - - if (++__beg != __end) - __c = *__beg; - else - __testeof = true; - } - else - break; - } - - - bool __found_dec = false; - bool __found_sci = false; - string __found_grouping; - if (__lc->_M_use_grouping) - __found_grouping.reserve(32); - const char_type* __lit_zero = __lit + __num_base::_S_izero; - - if (!__lc->_M_allocated) - - while (!__testeof) - { - const int __digit = _M_find(__lit_zero, 10, __c); - if (__digit != -1) - { - __xtrc += '0' + __digit; - __found_mantissa = true; - } - else if (__c == __lc->_M_decimal_point - && !__found_dec && !__found_sci) - { - __xtrc += '.'; - __found_dec = true; - } - else if ((__c == __lit[__num_base::_S_ie] - || __c == __lit[__num_base::_S_iE]) - && !__found_sci && __found_mantissa) - { - - __xtrc += 'e'; - __found_sci = true; - - - if (++__beg != __end) - { - __c = *__beg; - const bool __plus = __c == __lit[__num_base::_S_iplus]; - if (__plus || __c == __lit[__num_base::_S_iminus]) - __xtrc += __plus ? '+' : '-'; - else - continue; - } - else - { - __testeof = true; - break; - } - } - else - break; - - if (++__beg != __end) - __c = *__beg; - else - __testeof = true; - } - else - while (!__testeof) - { - - - if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) - { - if (!__found_dec && !__found_sci) - { - - - if (__sep_pos) - { - __found_grouping += static_cast(__sep_pos); - __sep_pos = 0; - } - else - { - - - __xtrc.clear(); - break; - } - } - else - break; - } - else if (__c == __lc->_M_decimal_point) - { - if (!__found_dec && !__found_sci) - { - - - - if (__found_grouping.size()) - __found_grouping += static_cast(__sep_pos); - __xtrc += '.'; - __found_dec = true; - } - else - break; - } - else - { - const char_type* __q = - __traits_type::find(__lit_zero, 10, __c); - if (__q) - { - __xtrc += '0' + (__q - __lit_zero); - __found_mantissa = true; - ++__sep_pos; - } - else if ((__c == __lit[__num_base::_S_ie] - || __c == __lit[__num_base::_S_iE]) - && !__found_sci && __found_mantissa) - { - - if (__found_grouping.size() && !__found_dec) - __found_grouping += static_cast(__sep_pos); - __xtrc += 'e'; - __found_sci = true; - - - if (++__beg != __end) - { - __c = *__beg; - const bool __plus = __c == __lit[__num_base::_S_iplus]; - if ((__plus || __c == __lit[__num_base::_S_iminus]) - && !(__lc->_M_use_grouping - && __c == __lc->_M_thousands_sep) - && !(__c == __lc->_M_decimal_point)) - __xtrc += __plus ? '+' : '-'; - else - continue; - } - else - { - __testeof = true; - break; - } - } - else - break; - } - - if (++__beg != __end) - __c = *__beg; - else - __testeof = true; - } - - - - if (__found_grouping.size()) - { - - if (!__found_dec && !__found_sci) - __found_grouping += static_cast(__sep_pos); - - if (!std::__verify_grouping(__lc->_M_grouping, - __lc->_M_grouping_size, - __found_grouping)) - __err = ios_base::failbit; - } - - return __beg; - } - - template - template - __attribute ((__abi_tag__ ("cxx11"))) - _InIter - num_get<_CharT, _InIter>:: - _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io, - ios_base::iostate& __err, _ValueT& __v) const - { - typedef char_traits<_CharT> __traits_type; - using __gnu_cxx::__add_unsigned; - typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; - typedef __numpunct_cache<_CharT> __cache_type; - __use_cache<__cache_type> __uc; - const locale& __loc = __io._M_getloc(); - const __cache_type* __lc = __uc(__loc); - const _CharT* __lit = __lc->_M_atoms_in; - char_type __c = char_type(); - - - const ios_base::fmtflags __basefield = __io.flags() - & ios_base::basefield; - const bool __oct = __basefield == ios_base::oct; - int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10); - - - bool __testeof = __beg == __end; - - - bool __negative = false; - if (!__testeof) - { - __c = *__beg; - __negative = __c == __lit[__num_base::_S_iminus]; - if ((__negative || __c == __lit[__num_base::_S_iplus]) - && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) - && !(__c == __lc->_M_decimal_point)) - { - if (++__beg != __end) - __c = *__beg; - else - __testeof = true; - } - } - - - - bool __found_zero = false; - int __sep_pos = 0; - while (!__testeof) - { - if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) - || __c == __lc->_M_decimal_point) - break; - else if (__c == __lit[__num_base::_S_izero] - && (!__found_zero || __base == 10)) - { - __found_zero = true; - ++__sep_pos; - if (__basefield == 0) - __base = 8; - if (__base == 8) - __sep_pos = 0; - } - else if (__found_zero - && (__c == __lit[__num_base::_S_ix] - || __c == __lit[__num_base::_S_iX])) - { - if (__basefield == 0) - __base = 16; - if (__base == 16) - { - __found_zero = false; - __sep_pos = 0; - } - else - break; - } - else - break; - - if (++__beg != __end) - { - __c = *__beg; - if (!__found_zero) - break; - } - else - __testeof = true; - } - - - - const size_t __len = (__base == 16 ? __num_base::_S_iend - - __num_base::_S_izero : __base); - - - typedef __gnu_cxx::__numeric_traits<_ValueT> __num_traits; - string __found_grouping; - if (__lc->_M_use_grouping) - __found_grouping.reserve(32); - bool __testfail = false; - bool __testoverflow = false; - const __unsigned_type __max = - (__negative && __num_traits::__is_signed) - ? -static_cast<__unsigned_type>(__num_traits::__min) - : __num_traits::__max; - const __unsigned_type __smax = __max / __base; - __unsigned_type __result = 0; - int __digit = 0; - const char_type* __lit_zero = __lit + __num_base::_S_izero; - - if (!__lc->_M_allocated) - - while (!__testeof) - { - __digit = _M_find(__lit_zero, __len, __c); - if (__digit == -1) - break; - - if (__result > __smax) - __testoverflow = true; - else - { - __result *= __base; - __testoverflow |= __result > __max - __digit; - __result += __digit; - ++__sep_pos; - } - - if (++__beg != __end) - __c = *__beg; - else - __testeof = true; - } - else - while (!__testeof) - { - - - if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) - { - - - if (__sep_pos) - { - __found_grouping += static_cast(__sep_pos); - __sep_pos = 0; - } - else - { - __testfail = true; - break; - } - } - else if (__c == __lc->_M_decimal_point) - break; - else - { - const char_type* __q = - __traits_type::find(__lit_zero, __len, __c); - if (!__q) - break; - - __digit = __q - __lit_zero; - if (__digit > 15) - __digit -= 6; - if (__result > __smax) - __testoverflow = true; - else - { - __result *= __base; - __testoverflow |= __result > __max - __digit; - __result += __digit; - ++__sep_pos; - } - } - - if (++__beg != __end) - __c = *__beg; - else - __testeof = true; - } - - - - if (__found_grouping.size()) - { - - __found_grouping += static_cast(__sep_pos); - - if (!std::__verify_grouping(__lc->_M_grouping, - __lc->_M_grouping_size, - __found_grouping)) - __err = ios_base::failbit; - } - - - - if ((!__sep_pos && !__found_zero && !__found_grouping.size()) - || __testfail) - { - __v = 0; - __err = ios_base::failbit; - } - else if (__testoverflow) - { - if (__negative && __num_traits::__is_signed) - __v = __num_traits::__min; - else - __v = __num_traits::__max; - __err = ios_base::failbit; - } - else - __v = __negative ? -__result : __result; - - if (__testeof) - __err |= ios_base::eofbit; - return __beg; - } - - - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, bool& __v) const - { - if (!(__io.flags() & ios_base::boolalpha)) - { - - - - long __l = -1; - __beg = _M_extract_int(__beg, __end, __io, __err, __l); - if (__l == 0 || __l == 1) - __v = bool(__l); - else - { - - - __v = true; - __err = ios_base::failbit; - if (__beg == __end) - __err |= ios_base::eofbit; - } - } - else - { - - typedef __numpunct_cache<_CharT> __cache_type; - __use_cache<__cache_type> __uc; - const locale& __loc = __io._M_getloc(); - const __cache_type* __lc = __uc(__loc); - - bool __testf = true; - bool __testt = true; - bool __donef = __lc->_M_falsename_size == 0; - bool __donet = __lc->_M_truename_size == 0; - bool __testeof = false; - size_t __n = 0; - while (!__donef || !__donet) - { - if (__beg == __end) - { - __testeof = true; - break; - } - - const char_type __c = *__beg; - - if (!__donef) - __testf = __c == __lc->_M_falsename[__n]; - - if (!__testf && __donet) - break; - - if (!__donet) - __testt = __c == __lc->_M_truename[__n]; - - if (!__testt && __donef) - break; - - if (!__testt && !__testf) - break; - - ++__n; - ++__beg; - - __donef = !__testf || __n >= __lc->_M_falsename_size; - __donet = !__testt || __n >= __lc->_M_truename_size; - } - if (__testf && __n == __lc->_M_falsename_size && __n) - { - __v = false; - if (__testt && __n == __lc->_M_truename_size) - __err = ios_base::failbit; - else - __err = __testeof ? ios_base::eofbit : ios_base::goodbit; - } - else if (__testt && __n == __lc->_M_truename_size && __n) - { - __v = true; - __err = __testeof ? ios_base::eofbit : ios_base::goodbit; - } - else - { - - - __v = false; - __err = ios_base::failbit; - if (__testeof) - __err |= ios_base::eofbit; - } - } - return __beg; - } - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, float& __v) const - { - string __xtrc; - __xtrc.reserve(32); - __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); - std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); - if (__beg == __end) - __err |= ios_base::eofbit; - return __beg; - } - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, double& __v) const - { - string __xtrc; - __xtrc.reserve(32); - __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); - std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); - if (__beg == __end) - __err |= ios_base::eofbit; - return __beg; - } -# 735 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, long double& __v) const - { - string __xtrc; - __xtrc.reserve(32); - __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); - std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); - if (__beg == __end) - __err |= ios_base::eofbit; - return __beg; - } - - template - _InIter - num_get<_CharT, _InIter>:: - do_get(iter_type __beg, iter_type __end, ios_base& __io, - ios_base::iostate& __err, void*& __v) const - { - - typedef ios_base::fmtflags fmtflags; - const fmtflags __fmt = __io.flags(); - __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex); - - typedef __gnu_cxx::__conditional_type<(sizeof(void*) - <= sizeof(unsigned long)), - unsigned long, unsigned long long>::__type _UIntPtrType; - - _UIntPtrType __ul; - __beg = _M_extract_int(__beg, __end, __io, __err, __ul); - - - __io.flags(__fmt); - - __v = reinterpret_cast(__ul); - return __beg; - } -# 795 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 - template - void - num_put<_CharT, _OutIter>:: - _M_pad(_CharT __fill, streamsize __w, ios_base& __io, - _CharT* __new, const _CharT* __cs, int& __len) const - { - - - __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, - __cs, __w, __len); - __len = static_cast(__w); - } - - - - template - int - __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit, - ios_base::fmtflags __flags, bool __dec) - { - _CharT* __buf = __bufend; - if (__builtin_expect(__dec, true)) - { - - do - { - *--__buf = __lit[(__v % 10) + __num_base::_S_odigits]; - __v /= 10; - } - while (__v != 0); - } - else if ((__flags & ios_base::basefield) == ios_base::oct) - { - - do - { - *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits]; - __v >>= 3; - } - while (__v != 0); - } - else - { - - const bool __uppercase = __flags & ios_base::uppercase; - const int __case_offset = __uppercase ? __num_base::_S_oudigits - : __num_base::_S_odigits; - do - { - *--__buf = __lit[(__v & 0xf) + __case_offset]; - __v >>= 4; - } - while (__v != 0); - } - return __bufend - __buf; - } - - - - template - void - num_put<_CharT, _OutIter>:: - _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep, - ios_base&, _CharT* __new, _CharT* __cs, int& __len) const - { - _CharT* __p = std::__add_grouping(__new, __sep, __grouping, - __grouping_size, __cs, __cs + __len); - __len = __p - __new; - } - - template - template - _OutIter - num_put<_CharT, _OutIter>:: - _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill, - _ValueT __v) const - { - using __gnu_cxx::__add_unsigned; - typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; - typedef __numpunct_cache<_CharT> __cache_type; - __use_cache<__cache_type> __uc; - const locale& __loc = __io._M_getloc(); - const __cache_type* __lc = __uc(__loc); - const _CharT* __lit = __lc->_M_atoms_out; - const ios_base::fmtflags __flags = __io.flags(); - - - const int __ilen = 5 * sizeof(_ValueT); - _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __ilen)); - - - - const ios_base::fmtflags __basefield = __flags & ios_base::basefield; - const bool __dec = (__basefield != ios_base::oct - && __basefield != ios_base::hex); - const __unsigned_type __u = ((__v > 0 || !__dec) - ? __unsigned_type(__v) - : -__unsigned_type(__v)); - int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec); - __cs += __ilen - __len; - - - if (__lc->_M_use_grouping) - { - - - _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * (__len + 1) - * 2)); - _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size, - __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len); - __cs = __cs2 + 2; - } - - - if (__builtin_expect(__dec, true)) - { - - if (__v >= 0) - { - if (bool(__flags & ios_base::showpos) - && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) - *--__cs = __lit[__num_base::_S_oplus], ++__len; - } - else - *--__cs = __lit[__num_base::_S_ominus], ++__len; - } - else if (bool(__flags & ios_base::showbase) && __v) - { - if (__basefield == ios_base::oct) - *--__cs = __lit[__num_base::_S_odigits], ++__len; - else - { - - const bool __uppercase = __flags & ios_base::uppercase; - *--__cs = __lit[__num_base::_S_ox + __uppercase]; - - *--__cs = __lit[__num_base::_S_odigits]; - __len += 2; - } - } - - - const streamsize __w = __io.width(); - if (__w > static_cast(__len)) - { - _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __w)); - _M_pad(__fill, __w, __io, __cs3, __cs, __len); - __cs = __cs3; - } - __io.width(0); - - - - return std::__write(__s, __cs, __len); - } - - template - void - num_put<_CharT, _OutIter>:: - _M_group_float(const char* __grouping, size_t __grouping_size, - _CharT __sep, const _CharT* __p, _CharT* __new, - _CharT* __cs, int& __len) const - { - - - - const int __declen = __p ? __p - __cs : __len; - _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping, - __grouping_size, - __cs, __cs + __declen); - - - int __newlen = __p2 - __new; - if (__p) - { - char_traits<_CharT>::copy(__p2, __p, __len - __declen); - __newlen += __len - __declen; - } - __len = __newlen; - } -# 989 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 - template - template - _OutIter - num_put<_CharT, _OutIter>:: - _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, - _ValueT __v) const - { - typedef __numpunct_cache<_CharT> __cache_type; - __use_cache<__cache_type> __uc; - const locale& __loc = __io._M_getloc(); - const __cache_type* __lc = __uc(__loc); - - - const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision(); - - const int __max_digits = - __gnu_cxx::__numeric_traits<_ValueT>::__digits10; - - - int __len; - - char __fbuf[16]; - __num_base::_S_format_float(__io, __fbuf, __mod); - - - - const bool __use_prec = - (__io.flags() & ios_base::floatfield) != ios_base::floatfield; - - - - int __cs_size = __max_digits * 3; - char* __cs = static_cast(__builtin_alloca(__cs_size)); - if (__use_prec) - __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, - __fbuf, __prec, __v); - else - __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, - __fbuf, __v); - - - if (__len >= __cs_size) - { - __cs_size = __len + 1; - __cs = static_cast(__builtin_alloca(__cs_size)); - if (__use_prec) - __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, - __fbuf, __prec, __v); - else - __len = std::__convert_from_v(_S_get_c_locale(), __cs, __cs_size, - __fbuf, __v); - } -# 1062 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 - const ctype<_CharT>& __ctype = use_facet >(__loc); - - _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __len)); - __ctype.widen(__cs, __cs + __len, __ws); - - - _CharT* __wp = 0; - const char* __p = char_traits::find(__cs, __len, '.'); - if (__p) - { - __wp = __ws + (__p - __cs); - *__wp = __lc->_M_decimal_point; - } - - - - - if (__lc->_M_use_grouping - && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9' - && __cs[1] >= '0' && __cs[2] >= '0'))) - { - - - _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __len * 2)); - - streamsize __off = 0; - if (__cs[0] == '-' || __cs[0] == '+') - { - __off = 1; - __ws2[0] = __ws[0]; - __len -= 1; - } - - _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size, - __lc->_M_thousands_sep, __wp, __ws2 + __off, - __ws + __off, __len); - __len += __off; - - __ws = __ws2; - } - - - const streamsize __w = __io.width(); - if (__w > static_cast(__len)) - { - _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __w)); - _M_pad(__fill, __w, __io, __ws3, __ws, __len); - __ws = __ws3; - } - __io.width(0); - - - - return std::__write(__s, __ws, __len); - } - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const - { - const ios_base::fmtflags __flags = __io.flags(); - if ((__flags & ios_base::boolalpha) == 0) - { - const long __l = __v; - __s = _M_insert_int(__s, __io, __fill, __l); - } - else - { - typedef __numpunct_cache<_CharT> __cache_type; - __use_cache<__cache_type> __uc; - const locale& __loc = __io._M_getloc(); - const __cache_type* __lc = __uc(__loc); - - const _CharT* __name = __v ? __lc->_M_truename - : __lc->_M_falsename; - int __len = __v ? __lc->_M_truename_size - : __lc->_M_falsename_size; - - const streamsize __w = __io.width(); - if (__w > static_cast(__len)) - { - const streamsize __plen = __w - __len; - _CharT* __ps - = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) - * __plen)); - - char_traits<_CharT>::assign(__ps, __plen, __fill); - __io.width(0); - - if ((__flags & ios_base::adjustfield) == ios_base::left) - { - __s = std::__write(__s, __name, __len); - __s = std::__write(__s, __ps, __plen); - } - else - { - __s = std::__write(__s, __ps, __plen); - __s = std::__write(__s, __name, __len); - } - return __s; - } - __io.width(0); - __s = std::__write(__s, __name, __len); - } - return __s; - } - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const - { return _M_insert_float(__s, __io, __fill, char(), __v); } -# 1187 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, - long double __v) const - { return _M_insert_float(__s, __io, __fill, 'L', __v); } - - template - _OutIter - num_put<_CharT, _OutIter>:: - do_put(iter_type __s, ios_base& __io, char_type __fill, - const void* __v) const - { - const ios_base::fmtflags __flags = __io.flags(); - const ios_base::fmtflags __fmt = ~(ios_base::basefield - | ios_base::uppercase); - __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase)); - - typedef __gnu_cxx::__conditional_type<(sizeof(const void*) - <= sizeof(unsigned long)), - unsigned long, unsigned long long>::__type _UIntPtrType; - - __s = _M_insert_int(__s, __io, __fill, - reinterpret_cast<_UIntPtrType>(__v)); - __io.flags(__flags); - return __s; - } -# 1233 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.tcc" 3 - template - void - __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill, - _CharT* __news, const _CharT* __olds, - streamsize __newlen, streamsize __oldlen) - { - const size_t __plen = static_cast(__newlen - __oldlen); - const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield; - - - if (__adjust == ios_base::left) - { - _Traits::copy(__news, __olds, __oldlen); - _Traits::assign(__news + __oldlen, __plen, __fill); - return; - } - - size_t __mod = 0; - if (__adjust == ios_base::internal) - { - - - - const locale& __loc = __io._M_getloc(); - const ctype<_CharT>& __ctype = use_facet >(__loc); - - if (__ctype.widen('-') == __olds[0] - || __ctype.widen('+') == __olds[0]) - { - __news[0] = __olds[0]; - __mod = 1; - ++__news; - } - else if (__ctype.widen('0') == __olds[0] - && __oldlen > 1 - && (__ctype.widen('x') == __olds[1] - || __ctype.widen('X') == __olds[1])) - { - __news[0] = __olds[0]; - __news[1] = __olds[1]; - __mod = 2; - __news += 2; - } - - } - _Traits::assign(__news, __plen, __fill); - _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod); - } - - template - _CharT* - __add_grouping(_CharT* __s, _CharT __sep, - const char* __gbeg, size_t __gsize, - const _CharT* __first, const _CharT* __last) - { - size_t __idx = 0; - size_t __ctr = 0; - - while (__last - __first > __gbeg[__idx] - && static_cast(__gbeg[__idx]) > 0 - && __gbeg[__idx] != __gnu_cxx::__numeric_traits::__max) - { - __last -= __gbeg[__idx]; - __idx < __gsize - 1 ? ++__idx : ++__ctr; - } - - while (__first != __last) - *__s++ = *__first++; - - while (__ctr--) - { - *__s++ = __sep; - for (char __i = __gbeg[__idx]; __i > 0; --__i) - *__s++ = *__first++; - } - - while (__idx--) - { - *__s++ = __sep; - for (char __i = __gbeg[__idx]; __i > 0; --__i) - *__s++ = *__first++; - } - - return __s; - } - - - - - extern template class __cxx11:: numpunct; - extern template class __cxx11:: numpunct_byname; - extern template class num_get; - extern template class num_put; - extern template class ctype_byname; - - extern template - const ctype* - __try_use_facet >(const locale&) noexcept; - - extern template - const numpunct* - __try_use_facet >(const locale&) noexcept; - - extern template - const num_put* - __try_use_facet >(const locale&) noexcept; - - extern template - const num_get* - __try_use_facet >(const locale&) noexcept; - - extern template - const ctype& - use_facet >(const locale&); - - extern template - const numpunct& - use_facet >(const locale&); - - extern template - const num_put& - use_facet >(const locale&); - - extern template - const num_get& - use_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - - extern template class __cxx11:: numpunct; - extern template class __cxx11:: numpunct_byname; - extern template class num_get; - extern template class num_put; - extern template class ctype_byname; - - extern template - const ctype* - __try_use_facet >(const locale&) noexcept; - - extern template - const numpunct* - __try_use_facet >(const locale&) noexcept; - - extern template - const num_put* - __try_use_facet >(const locale&) noexcept; - - extern template - const num_get* - __try_use_facet >(const locale&) noexcept; - - extern template - const ctype& - use_facet >(const locale&); - - extern template - const numpunct& - use_facet >(const locale&); - - extern template - const num_put& - use_facet >(const locale&); - - extern template - const num_get& - use_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - - - -} -# 2688 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/locale_facets.h" 2 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 2 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - inline const _Facet& - __check_facet(const _Facet* __f) - { - if (!__f) - __throw_bad_cast(); - return *__f; - } -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - template - class basic_ios : public ios_base - { - public: - - - - - - - typedef _CharT char_type; - typedef typename _Traits::int_type int_type; - typedef typename _Traits::pos_type pos_type; - typedef typename _Traits::off_type off_type; - typedef _Traits traits_type; - - - - - - - typedef ctype<_CharT> __ctype_type; - typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > - __num_put_type; - typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > - __num_get_type; - - - - protected: - basic_ostream<_CharT, _Traits>* _M_tie; - mutable char_type _M_fill; - mutable bool _M_fill_init; - basic_streambuf<_CharT, _Traits>* _M_streambuf; - - - const __ctype_type* _M_ctype; - - const __num_put_type* _M_num_put; - - const __num_get_type* _M_num_get; - - public: -# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - explicit operator bool() const - { return !this->fail(); } - - - - - - bool - operator!() const - { return this->fail(); } -# 136 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - iostate - rdstate() const - { return _M_streambuf_state; } -# 147 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - void - clear(iostate __state = goodbit); - - - - - - - - void - setstate(iostate __state) - { this->clear(this->rdstate() | __state); } - - - - - void - _M_setstate(iostate __state) - { - - - _M_streambuf_state |= __state; - if (this->exceptions() & __state) - throw; - } - - - - - - - - bool - good() const - { return this->rdstate() == 0; } - - - - - - - - bool - eof() const - { return (this->rdstate() & eofbit) != 0; } -# 200 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - bool - fail() const - { return (this->rdstate() & (badbit | failbit)) != 0; } - - - - - - - - bool - bad() const - { return (this->rdstate() & badbit) != 0; } -# 221 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - iostate - exceptions() const - { return _M_exception; } -# 256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - void - exceptions(iostate __except) - { - _M_exception = __except; - this->clear(_M_streambuf_state); - } - - - - - - - - explicit - basic_ios(basic_streambuf<_CharT, _Traits>* __sb) - : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0), - _M_ctype(0), _M_num_put(0), _M_num_get(0) - { this->init(__sb); } - - - - - - - - virtual - ~basic_ios() { } -# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - basic_ostream<_CharT, _Traits>* - tie() const - { return _M_tie; } -# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - basic_ostream<_CharT, _Traits>* - tie(basic_ostream<_CharT, _Traits>* __tiestr) - { - basic_ostream<_CharT, _Traits>* __old = _M_tie; - _M_tie = __tiestr; - return __old; - } - - - - - - - - basic_streambuf<_CharT, _Traits>* - rdbuf() const - { return _M_streambuf; } -# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - basic_streambuf<_CharT, _Traits>* - rdbuf(basic_streambuf<_CharT, _Traits>* __sb); -# 360 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - basic_ios& - copyfmt(const basic_ios& __rhs); - - - - - - - - char_type - fill() const - { - if (!_M_fill_init) - { - _M_fill = this->widen(' '); - _M_fill_init = true; - } - return _M_fill; - } -# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - char_type - fill(char_type __ch) - { - char_type __old = this->fill(); - _M_fill = __ch; - return __old; - } -# 409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - locale - imbue(const locale& __loc); -# 429 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - char - narrow(char_type __c, char __dfault) const - { return __check_facet(_M_ctype).narrow(__c, __dfault); } -# 448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 3 - char_type - widen(char __c) const - { return __check_facet(_M_ctype).widen(__c); } - - protected: - - - - - - - - basic_ios() - : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), - _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) - { } - - - - - - - - void - init(basic_streambuf<_CharT, _Traits>* __sb); - - - basic_ios(const basic_ios&) = delete; - basic_ios& operator=(const basic_ios&) = delete; - - void - move(basic_ios& __rhs) - { - ios_base::_M_move(__rhs); - _M_cache_locale(_M_ios_locale); - this->tie(__rhs.tie(nullptr)); - _M_fill = __rhs._M_fill; - _M_fill_init = __rhs._M_fill_init; - _M_streambuf = nullptr; - } - - void - move(basic_ios&& __rhs) - { this->move(__rhs); } - - void - swap(basic_ios& __rhs) noexcept - { - ios_base::_M_swap(__rhs); - _M_cache_locale(_M_ios_locale); - __rhs._M_cache_locale(__rhs._M_ios_locale); - std::swap(_M_tie, __rhs._M_tie); - std::swap(_M_fill, __rhs._M_fill); - std::swap(_M_fill_init, __rhs._M_fill_init); - } - - void - set_rdbuf(basic_streambuf<_CharT, _Traits>* __sb) - { _M_streambuf = __sb; } - - - void - _M_cache_locale(const locale& __loc); - }; - - -} - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.tcc" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.tcc" 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - void - basic_ios<_CharT, _Traits>::clear(iostate __state) - { - if (this->rdbuf()) - _M_streambuf_state = __state; - else - _M_streambuf_state = __state | badbit; - if (this->exceptions() & this->rdstate()) - __throw_ios_failure(("basic_ios::clear")); - } - - template - basic_streambuf<_CharT, _Traits>* - basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb) - { - basic_streambuf<_CharT, _Traits>* __old = _M_streambuf; - _M_streambuf = __sb; - this->clear(); - return __old; - } - - template - basic_ios<_CharT, _Traits>& - basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) - { - - - if (this != std::__addressof(__rhs)) - { - - - - - _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ? - _M_local_word : new _Words[__rhs._M_word_size]; - - - _Callback_list* __cb = __rhs._M_callbacks; - if (__cb) - __cb->_M_add_reference(); - _M_call_callbacks(erase_event); - if (_M_word != _M_local_word) - { - delete [] _M_word; - _M_word = 0; - } - _M_dispose_callbacks(); - - - _M_callbacks = __cb; - for (int __i = 0; __i < __rhs._M_word_size; ++__i) - __words[__i] = __rhs._M_word[__i]; - _M_word = __words; - _M_word_size = __rhs._M_word_size; - - this->flags(__rhs.flags()); - this->width(__rhs.width()); - this->precision(__rhs.precision()); - this->tie(__rhs.tie()); - this->fill(__rhs.fill()); - _M_ios_locale = __rhs.getloc(); - _M_cache_locale(_M_ios_locale); - - _M_call_callbacks(copyfmt_event); - - - this->exceptions(__rhs.exceptions()); - } - return *this; - } - - - template - locale - basic_ios<_CharT, _Traits>::imbue(const locale& __loc) - { - locale __old(this->getloc()); - ios_base::imbue(__loc); - _M_cache_locale(__loc); - if (this->rdbuf() != 0) - this->rdbuf()->pubimbue(__loc); - return __old; - } - - template - void - basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) - { - - ios_base::_M_init(); - - - _M_cache_locale(_M_ios_locale); -# 146 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.tcc" 3 - _M_fill = _CharT(); - _M_fill_init = false; - - _M_tie = 0; - _M_exception = goodbit; - _M_streambuf = __sb; - _M_streambuf_state = __sb ? goodbit : badbit; - } - - template - void - basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) - { - _M_ctype = std::__try_use_facet<__ctype_type>(__loc); - _M_num_put = std::__try_use_facet<__num_put_type>(__loc); - _M_num_get = std::__try_use_facet<__num_get_type>(__loc); - } - - - - - extern template class basic_ios; - - - extern template class basic_ios; - - - - -} -# 517 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/basic_ios.h" 2 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ios" 2 3 -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - template - class basic_ostream : virtual public basic_ios<_CharT, _Traits> - { - public: - - typedef _CharT char_type; - typedef typename _Traits::int_type int_type; - typedef typename _Traits::pos_type pos_type; - typedef typename _Traits::off_type off_type; - typedef _Traits traits_type; - - - typedef basic_streambuf<_CharT, _Traits> __streambuf_type; - typedef basic_ios<_CharT, _Traits> __ios_type; - typedef basic_ostream<_CharT, _Traits> __ostream_type; - typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > - __num_put_type; - typedef ctype<_CharT> __ctype_type; -# 85 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - explicit - basic_ostream(__streambuf_type* __sb) - { this->init(__sb); } - - - - - - - virtual - ~basic_ostream() { } - - - class sentry; - friend class sentry; -# 109 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - operator<<(__ostream_type& (*__pf)(__ostream_type&)) - { - - - - return __pf(*this); - } - - __ostream_type& - operator<<(__ios_type& (*__pf)(__ios_type&)) - { - - - - __pf(*this); - return *this; - } - - __ostream_type& - operator<<(ios_base& (*__pf) (ios_base&)) - { - - - - __pf(*this); - return *this; - } -# 167 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - operator<<(long __n) - { return _M_insert(__n); } - - __ostream_type& - operator<<(unsigned long __n) - { return _M_insert(__n); } - - __ostream_type& - operator<<(bool __n) - { return _M_insert(__n); } - - __ostream_type& - operator<<(short __n); - - __ostream_type& - operator<<(unsigned short __n) - { - - - return _M_insert(static_cast(__n)); - } - - __ostream_type& - operator<<(int __n); - - __ostream_type& - operator<<(unsigned int __n) - { - - - return _M_insert(static_cast(__n)); - } - - - __ostream_type& - operator<<(long long __n) - { return _M_insert(__n); } - - __ostream_type& - operator<<(unsigned long long __n) - { return _M_insert(__n); } -# 221 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - operator<<(double __f) - { return _M_insert(__f); } - - __ostream_type& - operator<<(float __f) - { - - - return _M_insert(static_cast(__f)); - } - - __ostream_type& - operator<<(long double __f) - { return _M_insert(__f); } -# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - operator<<(const void* __p) - { return _M_insert(__p); } - - - __ostream_type& - operator<<(nullptr_t) - { return *this << "nullptr"; } -# 329 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - operator<<(__streambuf_type* __sb); -# 362 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - put(char_type __c); -# 381 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - write(const char_type* __s, streamsize __n); -# 394 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - flush(); -# 404 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - pos_type - tellp(); -# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - seekp(pos_type); -# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - __ostream_type& - seekp(off_type, ios_base::seekdir); - - protected: - basic_ostream() - { this->init(0); } - - - - basic_ostream(basic_iostream<_CharT, _Traits>&) { } - - basic_ostream(const basic_ostream&) = delete; - - basic_ostream(basic_ostream&& __rhs) - : __ios_type() - { __ios_type::move(__rhs); } - - - - basic_ostream& operator=(const basic_ostream&) = delete; - - basic_ostream& - operator=(basic_ostream&& __rhs) - { - swap(__rhs); - return *this; - } - - void - swap(basic_ostream& __rhs) - { __ios_type::swap(__rhs); } - - - template - __ostream_type& - _M_insert(_ValueT __v); - - private: - - void - _M_write(const char_type* __s, streamsize __n) - { std::__ostream_insert(*this, __s, __n); } - - }; -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - template - class basic_ostream<_CharT, _Traits>::sentry - { - - bool _M_ok; - basic_ostream<_CharT, _Traits>& _M_os; - - public: -# 498 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - explicit - sentry(basic_ostream<_CharT, _Traits>& __os); - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - - - - - - ~sentry() - { - - if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception()) - { - - if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1) - _M_os.setstate(ios_base::badbit); - } - } -#pragma GCC diagnostic pop -# 530 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - explicit - - operator bool() const - { return _M_ok; } - }; -# 552 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - template - inline basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) - { - if (__out.width() != 0) - return __ostream_insert(__out, &__c, 1); - __out.put(__c); - return __out; - } - - template - inline basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) - { return (__out << __out.widen(__c)); } - - - template - inline basic_ostream& - operator<<(basic_ostream& __out, char __c) - { - if (__out.width() != 0) - return __ostream_insert(__out, &__c, 1); - __out.put(__c); - return __out; - } - - - template - inline basic_ostream& - operator<<(basic_ostream& __out, signed char __c) - { return (__out << static_cast(__c)); } - - template - inline basic_ostream& - operator<<(basic_ostream& __out, unsigned char __c) - { return (__out << static_cast(__c)); } -# 643 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - template - inline basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) - { - if (!__s) - __out.setstate(ios_base::badbit); - else - __ostream_insert(__out, __s, - static_cast(_Traits::length(__s))); - return __out; - } - - template - basic_ostream<_CharT, _Traits> & - operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); - - - template - inline basic_ostream& - operator<<(basic_ostream& __out, const char* __s) - { - if (!__s) - __out.setstate(ios_base::badbit); - else - __ostream_insert(__out, __s, - static_cast(_Traits::length(__s))); - return __out; - } - - - template - inline basic_ostream& - operator<<(basic_ostream& __out, const signed char* __s) - { return (__out << reinterpret_cast(__s)); } - - template - inline basic_ostream & - operator<<(basic_ostream& __out, const unsigned char* __s) - { return (__out << reinterpret_cast(__s)); } -# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - template - inline basic_ostream<_CharT, _Traits>& - endl(basic_ostream<_CharT, _Traits>& __os) - { return flush(__os.put(__os.widen('\n'))); } -# 745 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - template - inline basic_ostream<_CharT, _Traits>& - ends(basic_ostream<_CharT, _Traits>& __os) - { return __os.put(_CharT()); } - - - - - - - template - inline basic_ostream<_CharT, _Traits>& - flush(basic_ostream<_CharT, _Traits>& __os) - { return __os.flush(); } -# 777 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - template - using _Require_derived_from_ios_base - = _Require, __not_>, - is_convertible::type, ios_base*>>; - - template, - typename - = decltype(std::declval<_Os&>() << std::declval())> - using __rvalue_stream_insertion_t = _Os&&; -# 799 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 - template - inline __rvalue_stream_insertion_t<_Ostream, _Tp> - operator<<(_Ostream&& __os, const _Tp& __x) - { - __os << __x; - return std::move(__os); - } -# 878 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 3 -} - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream.tcc" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ostream.tcc" 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - basic_ostream<_CharT, _Traits>::sentry:: - sentry(basic_ostream<_CharT, _Traits>& __os) - : _M_ok(false), _M_os(__os) - { - - if (__os.tie() && __os.good()) - __os.tie()->flush(); - - if (__os.good()) - _M_ok = true; - else if (__os.bad()) - __os.setstate(ios_base::failbit); - } - - template - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - _M_insert(_ValueT __v) - { - sentry __cerb(*this); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - - const __num_put_type& __np = __check_facet(this->_M_num_put); - - - - - if (__np.put(*this, *this, this->fill(), __v).failed()) - __err |= ios_base::badbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - operator<<(short __n) - { - - - const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; - if (__fmt == ios_base::oct || __fmt == ios_base::hex) - return _M_insert(static_cast(static_cast(__n))); - else - return _M_insert(static_cast(__n)); - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - operator<<(int __n) - { - - - const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; - if (__fmt == ios_base::oct || __fmt == ios_base::hex) - return _M_insert(static_cast(static_cast(__n))); - else - return _M_insert(static_cast(__n)); - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - operator<<(__streambuf_type* __sbin) - { - ios_base::iostate __err = ios_base::goodbit; - sentry __cerb(*this); - if (__cerb && __sbin) - { - try - { - if (!__copy_streambufs(__sbin, this->rdbuf())) - __err |= ios_base::failbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::failbit); } - } - else if (!__sbin) - __err |= ios_base::badbit; - if (__err) - this->setstate(__err); - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - put(char_type __c) - { - - - - - - - sentry __cerb(*this); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - const int_type __put = this->rdbuf()->sputc(__c); - if (traits_type::eq_int_type(__put, traits_type::eof())) - __err |= ios_base::badbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - write(const _CharT* __s, streamsize __n) - { - - - - - - - - sentry __cerb(*this); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - if (this->rdbuf()->sputn(__s, __n) != __n) - __err = ios_base::badbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(ios_base::badbit); - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - flush() - { - - - - - - if (__streambuf_type* __buf = this->rdbuf()) - { - sentry __cerb(*this); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - if (this->rdbuf()->pubsync() == -1) - __err |= ios_base::badbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - } - return *this; - } - - template - typename basic_ostream<_CharT, _Traits>::pos_type - basic_ostream<_CharT, _Traits>:: - tellp() - { - sentry __cerb(*this); - pos_type __ret = pos_type(-1); - if (!this->fail()) - __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); - return __ret; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - seekp(pos_type __pos) - { - sentry __cerb(*this); - if (!this->fail()) - { - - - const pos_type __p = this->rdbuf()->pubseekpos(__pos, ios_base::out); - - - if (__p == pos_type(off_type(-1))) - this->setstate(ios_base::failbit); - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - basic_ostream<_CharT, _Traits>:: - seekp(off_type __off, ios_base::seekdir __dir) - { - sentry __cerb(*this); - if (!this->fail()) - { - - - const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, - ios_base::out); - - - if (__p == pos_type(off_type(-1))) - this->setstate(ios_base::failbit); - } - return *this; - } - - template - basic_ostream<_CharT, _Traits>& - operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s) - { - if (!__s) - __out.setstate(ios_base::badbit); - else - { - - - const size_t __clen = char_traits::length(__s); - try - { - struct __ptr_guard - { - _CharT *__p; - __ptr_guard (_CharT *__ip): __p(__ip) { } - ~__ptr_guard() { delete[] __p; } - _CharT* __get() { return __p; } - } __pg (new _CharT[__clen]); - - _CharT *__ws = __pg.__get(); - for (size_t __i = 0; __i < __clen; ++__i) - __ws[__i] = __out.widen(__s[__i]); - __ostream_insert(__out, __ws, __clen); - } - catch(__cxxabiv1::__forced_unwind&) - { - __out._M_setstate(ios_base::badbit); - throw; - } - catch(...) - { __out._M_setstate(ios_base::badbit); } - } - return __out; - } - - - - - extern template class basic_ostream; - extern template ostream& endl(ostream&); - extern template ostream& ends(ostream&); - extern template ostream& flush(ostream&); - extern template ostream& operator<<(ostream&, char); - extern template ostream& operator<<(ostream&, unsigned char); - extern template ostream& operator<<(ostream&, signed char); - extern template ostream& operator<<(ostream&, const char*); - extern template ostream& operator<<(ostream&, const unsigned char*); - extern template ostream& operator<<(ostream&, const signed char*); - - extern template ostream& ostream::_M_insert(long); - extern template ostream& ostream::_M_insert(unsigned long); - extern template ostream& ostream::_M_insert(bool); - - extern template ostream& ostream::_M_insert(long long); - extern template ostream& ostream::_M_insert(unsigned long long); - - extern template ostream& ostream::_M_insert(double); - extern template ostream& ostream::_M_insert(long double); - extern template ostream& ostream::_M_insert(const void*); - - - extern template class basic_ostream; - extern template wostream& endl(wostream&); - extern template wostream& ends(wostream&); - extern template wostream& flush(wostream&); - extern template wostream& operator<<(wostream&, wchar_t); - extern template wostream& operator<<(wostream&, char); - extern template wostream& operator<<(wostream&, const wchar_t*); - extern template wostream& operator<<(wostream&, const char*); - - extern template wostream& wostream::_M_insert(long); - extern template wostream& wostream::_M_insert(unsigned long); - extern template wostream& wostream::_M_insert(bool); - - extern template wostream& wostream::_M_insert(long long); - extern template wostream& wostream::_M_insert(unsigned long long); - - extern template wostream& wostream::_M_insert(double); - extern template wostream& wostream::_M_insert(long double); - extern template wostream& wostream::_M_insert(const void*); - - - - -} -# 881 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ostream" 2 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - template - class basic_istream : virtual public basic_ios<_CharT, _Traits> - { - public: - - typedef _CharT char_type; - typedef typename _Traits::int_type int_type; - typedef typename _Traits::pos_type pos_type; - typedef typename _Traits::off_type off_type; - typedef _Traits traits_type; - - - typedef basic_streambuf<_CharT, _Traits> __streambuf_type; - typedef basic_ios<_CharT, _Traits> __ios_type; - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > - __num_get_type; - typedef ctype<_CharT> __ctype_type; - - protected: - - - - - - streamsize _M_gcount; - - public: - - - - - - - - explicit - basic_istream(__streambuf_type* __sb) - : _M_gcount(streamsize(0)) - { this->init(__sb); } - - - - - - - virtual - ~basic_istream() - { _M_gcount = streamsize(0); } - - - class sentry; - friend class sentry; -# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - operator>>(__istream_type& (*__pf)(__istream_type&)) - { return __pf(*this); } - - __istream_type& - operator>>(__ios_type& (*__pf)(__ios_type&)) - { - __pf(*this); - return *this; - } - - __istream_type& - operator>>(ios_base& (*__pf)(ios_base&)) - { - __pf(*this); - return *this; - } -# 169 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - operator>>(bool& __n) - { return _M_extract(__n); } - - __istream_type& - operator>>(short& __n); - - __istream_type& - operator>>(unsigned short& __n) - { return _M_extract(__n); } - - __istream_type& - operator>>(int& __n); - - __istream_type& - operator>>(unsigned int& __n) - { return _M_extract(__n); } - - __istream_type& - operator>>(long& __n) - { return _M_extract(__n); } - - __istream_type& - operator>>(unsigned long& __n) - { return _M_extract(__n); } - - - __istream_type& - operator>>(long long& __n) - { return _M_extract(__n); } - - __istream_type& - operator>>(unsigned long long& __n) - { return _M_extract(__n); } -# 215 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - operator>>(float& __f) - { return _M_extract(__f); } - - __istream_type& - operator>>(double& __f) - { return _M_extract(__f); } - - __istream_type& - operator>>(long double& __f) - { return _M_extract(__f); } -# 324 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - operator>>(void*& __p) - { return _M_extract(__p); } -# 348 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - operator>>(__streambuf_type* __sb); -# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - streamsize - gcount() const - { return _M_gcount; } -# 391 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - int_type - get(); -# 405 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - get(char_type& __c); -# 432 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - get(char_type* __s, streamsize __n, char_type __delim); -# 443 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - get(char_type* __s, streamsize __n) - { return this->get(__s, __n, this->widen('\n')); } -# 466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - get(__streambuf_type& __sb, char_type __delim); -# 476 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - get(__streambuf_type& __sb) - { return this->get(__sb, this->widen('\n')); } -# 505 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - getline(char_type* __s, streamsize __n, char_type __delim); -# 516 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - getline(char_type* __s, streamsize __n) - { return this->getline(__s, __n, this->widen('\n')); } -# 540 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - ignore(streamsize __n, int_type __delim); - - __istream_type& - ignore(streamsize __n); - - __istream_type& - ignore(); -# 557 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - int_type - peek(); -# 575 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - read(char_type* __s, streamsize __n); -# 594 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - streamsize - readsome(char_type* __s, streamsize __n); -# 611 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - putback(char_type __c); -# 627 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - unget(); -# 645 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - int - sync(); -# 660 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - pos_type - tellg(); -# 675 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - seekg(pos_type); -# 691 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - __istream_type& - seekg(off_type, ios_base::seekdir); - - - protected: - basic_istream() - : _M_gcount(streamsize(0)) - { this->init(0); } - - - basic_istream(const basic_istream&) = delete; - - basic_istream(basic_istream&& __rhs) - : __ios_type(), _M_gcount(__rhs._M_gcount) - { - __ios_type::move(__rhs); - __rhs._M_gcount = 0; - } - - - - basic_istream& operator=(const basic_istream&) = delete; - - basic_istream& - operator=(basic_istream&& __rhs) - { - swap(__rhs); - return *this; - } - - void - swap(basic_istream& __rhs) - { - __ios_type::swap(__rhs); - std::swap(_M_gcount, __rhs._M_gcount); - } - - - template - __istream_type& - _M_extract(_ValueT& __v); - }; - - - template<> - basic_istream& - basic_istream:: - getline(char_type* __s, streamsize __n, char_type __delim); - - template<> - basic_istream& - basic_istream:: - ignore(streamsize __n); - - template<> - basic_istream& - basic_istream:: - ignore(streamsize __n, int_type __delim); - - - template<> - basic_istream& - basic_istream:: - getline(char_type* __s, streamsize __n, char_type __delim); - - template<> - basic_istream& - basic_istream:: - ignore(streamsize __n); - - template<> - basic_istream& - basic_istream:: - ignore(streamsize __n, int_type __delim); -# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - template - class basic_istream<_CharT, _Traits>::sentry - { - - bool _M_ok; - - public: - - typedef _Traits traits_type; - typedef basic_streambuf<_CharT, _Traits> __streambuf_type; - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef typename __istream_type::__ctype_type __ctype_type; - typedef typename _Traits::int_type __int_type; -# 811 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - explicit - sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); -# 822 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - explicit - - operator bool() const - { return _M_ok; } - }; -# 840 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); - - template - inline basic_istream& - operator>>(basic_istream& __in, unsigned char& __c) - { return (__in >> reinterpret_cast(__c)); } - - template - inline basic_istream& - operator>>(basic_istream& __in, signed char& __c) - { return (__in >> reinterpret_cast(__c)); } - - - - template - void - __istream_extract(basic_istream<_CharT, _Traits>&, _CharT*, streamsize); - - void __istream_extract(istream&, char*, streamsize); -# 890 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - template - __attribute__((__nonnull__(2), __access__(__write_only__, 2))) - inline basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) - { - - - - size_t __n = __builtin_object_size(__s, 0); - if (__n < sizeof(_CharT)) - { - - do { if (std::__is_constant_evaluated() && !bool(__n >= sizeof(_CharT))) __builtin_unreachable(); } while (false); - - __in.width(0); - __in.setstate(ios_base::failbit); - } - else if (__n != (size_t)-1) - { - __n /= sizeof(_CharT); - streamsize __w = __in.width(); - std::__istream_extract(__in, __s, __n); - if (__in.good() && (__w <= 0 || __n < __w)) - { - - - const typename _Traits::int_type __c = __in.rdbuf()->sgetc(); - const bool __eof = _Traits::eq_int_type(__c, _Traits::eof()); - if (__builtin_expect(__eof, true)) - __in.setstate(ios_base::eofbit); - } - } - else - - { - - streamsize __n = __gnu_cxx::__numeric_traits::__max; - __n /= sizeof(_CharT); - std::__istream_extract(__in, __s, __n); - } - return __in; - } - - template - __attribute__((__nonnull__(2), __access__(__write_only__, 2))) - inline basic_istream& - operator>>(basic_istream& __in, unsigned char* __s) - { return __in >> reinterpret_cast(__s); } - - template - __attribute__((__nonnull__(2), __access__(__write_only__, 2))) - inline basic_istream& - operator>>(basic_istream& __in, signed char* __s) - { return __in >> reinterpret_cast(__s); } -# 979 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - template - class basic_iostream - : public basic_istream<_CharT, _Traits>, - public basic_ostream<_CharT, _Traits> - { - public: - - - - typedef _CharT char_type; - typedef typename _Traits::int_type int_type; - typedef typename _Traits::pos_type pos_type; - typedef typename _Traits::off_type off_type; - typedef _Traits traits_type; - - - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef basic_ostream<_CharT, _Traits> __ostream_type; - - - - - - - - explicit - basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) - : __istream_type(__sb), __ostream_type(__sb) { } - - - - - virtual - ~basic_iostream() { } - - protected: - basic_iostream() - : __istream_type(), __ostream_type() { } - - - basic_iostream(const basic_iostream&) = delete; - - basic_iostream(basic_iostream&& __rhs) - : __istream_type(std::move(__rhs)), __ostream_type(*this) - { } - - - - basic_iostream& operator=(const basic_iostream&) = delete; - - basic_iostream& - operator=(basic_iostream&& __rhs) - { - swap(__rhs); - return *this; - } - - void - swap(basic_iostream& __rhs) - { __istream_type::swap(__rhs); } - - }; -# 1062 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - template - basic_istream<_CharT, _Traits>& - ws(basic_istream<_CharT, _Traits>& __is); -# 1078 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - template, - typename = decltype(std::declval<_Is&>() >> std::declval<_Tp>())> - using __rvalue_stream_extraction_t = _Is&&; -# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 3 - template - inline __rvalue_stream_extraction_t<_Istream, _Tp> - operator>>(_Istream&& __is, _Tp&& __x) - { - __is >> std::forward<_Tp>(__x); - return std::move(__is); - } - - - -} - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/istream.tcc" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/istream.tcc" 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - basic_istream<_CharT, _Traits>::sentry:: - sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) - { - ios_base::iostate __err = ios_base::goodbit; - if (__in.good()) - { - try - { - if (__in.tie()) - __in.tie()->flush(); - if (!__noskip && bool(__in.flags() & ios_base::skipws)) - { - const __int_type __eof = traits_type::eof(); - __streambuf_type* __sb = __in.rdbuf(); - __int_type __c = __sb->sgetc(); - - const __ctype_type& __ct = __check_facet(__in._M_ctype); - while (!traits_type::eq_int_type(__c, __eof) - && __ct.is(ctype_base::space, - traits_type::to_char_type(__c))) - __c = __sb->snextc(); - - - - - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - } - } - catch(__cxxabiv1::__forced_unwind&) - { - __in._M_setstate(ios_base::badbit); - throw; - } - catch(...) - { __in._M_setstate(ios_base::badbit); } - } - - if (__in.good() && __err == ios_base::goodbit) - _M_ok = true; - else - { - __err |= ios_base::failbit; - __in.setstate(__err); - } - } - - template - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - _M_extract(_ValueT& __v) - { - sentry __cerb(*this, false); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - - const __num_get_type& __ng = __check_facet(this->_M_num_get); - - - - - __ng.get(*this, 0, *this, __err, __v); - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(short& __n) - { - - - sentry __cerb(*this, false); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - long __l; - - const __num_get_type& __ng = __check_facet(this->_M_num_get); - - - - - __ng.get(*this, 0, *this, __err, __l); - - - - if (__l < __gnu_cxx::__numeric_traits::__min) - { - __err |= ios_base::failbit; - __n = __gnu_cxx::__numeric_traits::__min; - } - else if (__l > __gnu_cxx::__numeric_traits::__max) - { - __err |= ios_base::failbit; - __n = __gnu_cxx::__numeric_traits::__max; - } - else - __n = short(__l); - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(int& __n) - { - - - sentry __cerb(*this, false); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - long __l; - - const __num_get_type& __ng = __check_facet(this->_M_num_get); - - - - - __ng.get(*this, 0, *this, __err, __l); - - - - if (__l < __gnu_cxx::__numeric_traits::__min) - { - __err |= ios_base::failbit; - __n = __gnu_cxx::__numeric_traits::__min; - } - else if (__l > __gnu_cxx::__numeric_traits::__max) - { - __err |= ios_base::failbit; - __n = __gnu_cxx::__numeric_traits::__max; - } - else - __n = int(__l); - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - operator>>(__streambuf_type* __sbout) - { - ios_base::iostate __err = ios_base::goodbit; - sentry __cerb(*this, false); - if (__cerb && __sbout) - { - try - { - bool __ineof; - if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) - __err |= ios_base::failbit; - if (__ineof) - __err |= ios_base::eofbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::failbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::failbit); } - } - else if (!__sbout) - __err |= ios_base::failbit; - if (__err) - this->setstate(__err); - return *this; - } - - template - typename basic_istream<_CharT, _Traits>::int_type - basic_istream<_CharT, _Traits>:: - get(void) - { - const int_type __eof = traits_type::eof(); - int_type __c = __eof; - _M_gcount = 0; - ios_base::iostate __err = ios_base::goodbit; - sentry __cerb(*this, true); - if (__cerb) - { - try - { - __c = this->rdbuf()->sbumpc(); - - if (!traits_type::eq_int_type(__c, __eof)) - _M_gcount = 1; - else - __err |= ios_base::eofbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - } - if (!_M_gcount) - __err |= ios_base::failbit; - if (__err) - this->setstate(__err); - return __c; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - get(char_type& __c) - { - _M_gcount = 0; - ios_base::iostate __err = ios_base::goodbit; - sentry __cerb(*this, true); - if (__cerb) - { - try - { - const int_type __cb = this->rdbuf()->sbumpc(); - - if (!traits_type::eq_int_type(__cb, traits_type::eof())) - { - _M_gcount = 1; - __c = traits_type::to_char_type(__cb); - } - else - __err |= ios_base::eofbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - } - if (!_M_gcount) - __err |= ios_base::failbit; - if (__err) - this->setstate(__err); - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - get(char_type* __s, streamsize __n, char_type __delim) - { - _M_gcount = 0; - ios_base::iostate __err = ios_base::goodbit; - sentry __cerb(*this, true); - if (__cerb) - { - try - { - const int_type __idelim = traits_type::to_int_type(__delim); - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sgetc(); - - while (_M_gcount + 1 < __n - && !traits_type::eq_int_type(__c, __eof) - && !traits_type::eq_int_type(__c, __idelim)) - { - *__s++ = traits_type::to_char_type(__c); - ++_M_gcount; - __c = __sb->snextc(); - } - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - } - - - if (__n > 0) - *__s = char_type(); - if (!_M_gcount) - __err |= ios_base::failbit; - if (__err) - this->setstate(__err); - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - get(__streambuf_type& __sb, char_type __delim) - { - _M_gcount = 0; - ios_base::iostate __err = ios_base::goodbit; - sentry __cerb(*this, true); - if (__cerb) - { - try - { - const int_type __idelim = traits_type::to_int_type(__delim); - const int_type __eof = traits_type::eof(); - __streambuf_type* __this_sb = this->rdbuf(); - int_type __c = __this_sb->sgetc(); - char_type __c2 = traits_type::to_char_type(__c); - unsigned long long __gcount = 0; - - while (!traits_type::eq_int_type(__c, __eof) - && !traits_type::eq_int_type(__c, __idelim) - && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) - { - ++__gcount; - __c = __this_sb->snextc(); - __c2 = traits_type::to_char_type(__c); - } - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - - - if (__gcount <= __gnu_cxx::__numeric_traits::__max) - _M_gcount = __gcount; - else - _M_gcount = __gnu_cxx::__numeric_traits::__max; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - } - if (!_M_gcount) - __err |= ios_base::failbit; - if (__err) - this->setstate(__err); - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - getline(char_type* __s, streamsize __n, char_type __delim) - { - _M_gcount = 0; - ios_base::iostate __err = ios_base::goodbit; - sentry __cerb(*this, true); - if (__cerb) - { - try - { - const int_type __idelim = traits_type::to_int_type(__delim); - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sgetc(); - - while (_M_gcount + 1 < __n - && !traits_type::eq_int_type(__c, __eof) - && !traits_type::eq_int_type(__c, __idelim)) - { - *__s++ = traits_type::to_char_type(__c); - __c = __sb->snextc(); - ++_M_gcount; - } - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - else - { - if (traits_type::eq_int_type(__c, __idelim)) - { - __sb->sbumpc(); - ++_M_gcount; - } - else - __err |= ios_base::failbit; - } - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - } - - - if (__n > 0) - *__s = char_type(); - if (!_M_gcount) - __err |= ios_base::failbit; - if (__err) - this->setstate(__err); - return *this; - } - - - - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - ignore(void) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - - if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) - __err |= ios_base::eofbit; - else - _M_gcount = 1; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - ignore(streamsize __n) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb && __n > 0) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sgetc(); -# 545 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/istream.tcc" 3 - bool __large_ignore = false; - while (true) - { - while (_M_gcount < __n - && !traits_type::eq_int_type(__c, __eof)) - { - ++_M_gcount; - __c = __sb->snextc(); - } - if (__n == __gnu_cxx::__numeric_traits::__max - && !traits_type::eq_int_type(__c, __eof)) - { - _M_gcount = - __gnu_cxx::__numeric_traits::__min; - __large_ignore = true; - } - else - break; - } - - if (__n == __gnu_cxx::__numeric_traits::__max) - { - if (__large_ignore) - _M_gcount = __gnu_cxx::__numeric_traits::__max; - - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - } - else if (_M_gcount < __n) - { - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - } - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - ignore(streamsize __n, int_type __delim) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb && __n > 0) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - int_type __c = __sb->sgetc(); - - - bool __large_ignore = false; - while (true) - { - while (_M_gcount < __n - && !traits_type::eq_int_type(__c, __eof) - && !traits_type::eq_int_type(__c, __delim)) - { - ++_M_gcount; - __c = __sb->snextc(); - } - if (__n == __gnu_cxx::__numeric_traits::__max - && !traits_type::eq_int_type(__c, __eof) - && !traits_type::eq_int_type(__c, __delim)) - { - _M_gcount = - __gnu_cxx::__numeric_traits::__min; - __large_ignore = true; - } - else - break; - } - - if (__n == __gnu_cxx::__numeric_traits::__max) - { - if (__large_ignore) - _M_gcount = __gnu_cxx::__numeric_traits::__max; - - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - else - { - if (_M_gcount != __n) - ++_M_gcount; - __sb->sbumpc(); - } - } - else if (_M_gcount < __n) - { - if (traits_type::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - else - { - ++_M_gcount; - __sb->sbumpc(); - } - } - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - typename basic_istream<_CharT, _Traits>::int_type - basic_istream<_CharT, _Traits>:: - peek(void) - { - int_type __c = traits_type::eof(); - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - __c = this->rdbuf()->sgetc(); - if (traits_type::eq_int_type(__c, traits_type::eof())) - __err |= ios_base::eofbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return __c; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - read(char_type* __s, streamsize __n) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - _M_gcount = this->rdbuf()->sgetn(__s, __n); - if (_M_gcount != __n) - __err |= (ios_base::eofbit | ios_base::failbit); - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - streamsize - basic_istream<_CharT, _Traits>:: - readsome(char_type* __s, streamsize __n) - { - _M_gcount = 0; - sentry __cerb(*this, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - - const streamsize __num = this->rdbuf()->in_avail(); - if (__num > 0) - _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); - else if (__num == -1) - __err |= ios_base::eofbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return _M_gcount; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - putback(char_type __c) - { - - - _M_gcount = 0; - - this->clear(this->rdstate() & ~ios_base::eofbit); - sentry __cerb(*this, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - if (!__sb - || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) - __err |= ios_base::badbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - unget(void) - { - - - _M_gcount = 0; - - this->clear(this->rdstate() & ~ios_base::eofbit); - sentry __cerb(*this, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - const int_type __eof = traits_type::eof(); - __streambuf_type* __sb = this->rdbuf(); - if (!__sb - || traits_type::eq_int_type(__sb->sungetc(), __eof)) - __err |= ios_base::badbit; - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - int - basic_istream<_CharT, _Traits>:: - sync(void) - { - - - int __ret = -1; - sentry __cerb(*this, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - __streambuf_type* __sb = this->rdbuf(); - if (__sb) - { - if (__sb->pubsync() == -1) - __err |= ios_base::badbit; - else - __ret = 0; - } - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return __ret; - } - - template - typename basic_istream<_CharT, _Traits>::pos_type - basic_istream<_CharT, _Traits>:: - tellg(void) - { - - - pos_type __ret = pos_type(-1); - sentry __cerb(*this, true); - if (__cerb) - { - try - { - if (!this->fail()) - __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, - ios_base::in); - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - } - return __ret; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - seekg(pos_type __pos) - { - - - - this->clear(this->rdstate() & ~ios_base::eofbit); - sentry __cerb(*this, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - if (!this->fail()) - { - - const pos_type __p = this->rdbuf()->pubseekpos(__pos, - ios_base::in); - - - if (__p == pos_type(off_type(-1))) - __err |= ios_base::failbit; - } - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - template - basic_istream<_CharT, _Traits>& - basic_istream<_CharT, _Traits>:: - seekg(off_type __off, ios_base::seekdir __dir) - { - - - - this->clear(this->rdstate() & ~ios_base::eofbit); - sentry __cerb(*this, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - if (!this->fail()) - { - - const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, - ios_base::in); - - - if (__p == pos_type(off_type(-1))) - __err |= ios_base::failbit; - } - } - catch(__cxxabiv1::__forced_unwind&) - { - this->_M_setstate(ios_base::badbit); - throw; - } - catch(...) - { this->_M_setstate(ios_base::badbit); } - if (__err) - this->setstate(__err); - } - return *this; - } - - - template - basic_istream<_CharT, _Traits>& - operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef typename __istream_type::int_type __int_type; - - typename __istream_type::sentry __cerb(__in, false); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - const __int_type __cb = __in.rdbuf()->sbumpc(); - if (!_Traits::eq_int_type(__cb, _Traits::eof())) - __c = _Traits::to_char_type(__cb); - else - __err |= (ios_base::eofbit | ios_base::failbit); - } - catch(__cxxabiv1::__forced_unwind&) - { - __in._M_setstate(ios_base::badbit); - throw; - } - catch(...) - { __in._M_setstate(ios_base::badbit); } - if (__err) - __in.setstate(__err); - } - return __in; - } - - template - void - __istream_extract(basic_istream<_CharT, _Traits>& __in, _CharT* __s, - streamsize __num) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef basic_streambuf<_CharT, _Traits> __streambuf_type; - typedef typename _Traits::int_type int_type; - typedef _CharT char_type; - typedef ctype<_CharT> __ctype_type; - - streamsize __extracted = 0; - ios_base::iostate __err = ios_base::goodbit; - typename __istream_type::sentry __cerb(__in, false); - if (__cerb) - { - try - { - - streamsize __width = __in.width(); - if (0 < __width && __width < __num) - __num = __width; - - const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); - - const int_type __eof = _Traits::eof(); - __streambuf_type* __sb = __in.rdbuf(); - int_type __c = __sb->sgetc(); - - while (__extracted < __num - 1 - && !_Traits::eq_int_type(__c, __eof) - && !__ct.is(ctype_base::space, - _Traits::to_char_type(__c))) - { - *__s++ = _Traits::to_char_type(__c); - ++__extracted; - __c = __sb->snextc(); - } - - if (__extracted < __num - 1 - && _Traits::eq_int_type(__c, __eof)) - __err |= ios_base::eofbit; - - - - *__s = char_type(); - __in.width(0); - } - catch(__cxxabiv1::__forced_unwind&) - { - __in._M_setstate(ios_base::badbit); - throw; - } - catch(...) - { __in._M_setstate(ios_base::badbit); } - } - if (!__extracted) - __err |= ios_base::failbit; - if (__err) - __in.setstate(__err); - } - - - template - basic_istream<_CharT, _Traits>& - ws(basic_istream<_CharT, _Traits>& __in) - { - typedef basic_istream<_CharT, _Traits> __istream_type; - typedef basic_streambuf<_CharT, _Traits> __streambuf_type; - typedef typename __istream_type::int_type __int_type; - typedef ctype<_CharT> __ctype_type; - - - - typename __istream_type::sentry __cerb(__in, true); - if (__cerb) - { - ios_base::iostate __err = ios_base::goodbit; - try - { - const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); - const __int_type __eof = _Traits::eof(); - __streambuf_type* __sb = __in.rdbuf(); - __int_type __c = __sb->sgetc(); - - while (true) - { - if (_Traits::eq_int_type(__c, __eof)) - { - __err = ios_base::eofbit; - break; - } - if (!__ct.is(ctype_base::space, _Traits::to_char_type(__c))) - break; - __c = __sb->snextc(); - } - } - catch(const __cxxabiv1::__forced_unwind&) - { - __in._M_setstate(ios_base::badbit); - throw; - } - catch(...) - { - __in._M_setstate(ios_base::badbit); - } - if (__err) - __in.setstate(__err); - } - return __in; - } - - - - - extern template class basic_istream; - extern template istream& ws(istream&); - extern template istream& operator>>(istream&, char&); - extern template istream& operator>>(istream&, unsigned char&); - extern template istream& operator>>(istream&, signed char&); - - extern template istream& istream::_M_extract(unsigned short&); - extern template istream& istream::_M_extract(unsigned int&); - extern template istream& istream::_M_extract(long&); - extern template istream& istream::_M_extract(unsigned long&); - extern template istream& istream::_M_extract(bool&); - - extern template istream& istream::_M_extract(long long&); - extern template istream& istream::_M_extract(unsigned long long&); - - extern template istream& istream::_M_extract(float&); - extern template istream& istream::_M_extract(double&); - extern template istream& istream::_M_extract(long double&); - extern template istream& istream::_M_extract(void*&); - - extern template class basic_iostream; - - - extern template class basic_istream; - extern template wistream& ws(wistream&); - extern template wistream& operator>>(wistream&, wchar_t&); - extern template void __istream_extract(wistream&, wchar_t*, streamsize); - - extern template wistream& wistream::_M_extract(unsigned short&); - extern template wistream& wistream::_M_extract(unsigned int&); - extern template wistream& wistream::_M_extract(long&); - extern template wistream& wistream::_M_extract(unsigned long&); - extern template wistream& wistream::_M_extract(bool&); - - extern template wistream& wistream::_M_extract(long long&); - extern template wistream& wistream::_M_extract(unsigned long long&); - - extern template wistream& wistream::_M_extract(float&); - extern template wistream& wistream::_M_extract(double&); - extern template wistream& wistream::_M_extract(long double&); - extern template wistream& wistream::_M_extract(void*&); - - extern template class basic_iostream; - - - - -} -# 1107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/istream" 2 3 -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - class codecvt_base - { - public: - enum result - { - ok, - partial, - error, - noconv - }; - }; -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 - template - class __codecvt_abstract_base - : public locale::facet, public codecvt_base - { - public: - - typedef codecvt_base::result result; - typedef _InternT intern_type; - typedef _ExternT extern_type; - typedef _StateT state_type; -# 118 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 - result - out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const - { - return this->do_out(__state, __from, __from_end, __from_next, - __to, __to_end, __to_next); - } -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 - result - unshift(state_type& __state, extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const - { return this->do_unshift(__state, __to,__to_end,__to_next); } -# 198 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 - result - in(state_type& __state, const extern_type* __from, - const extern_type* __from_end, const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const - { - return this->do_in(__state, __from, __from_end, __from_next, - __to, __to_end, __to_next); - } - - int - encoding() const throw() - { return this->do_encoding(); } - - bool - always_noconv() const throw() - { return this->do_always_noconv(); } - - int - length(state_type& __state, const extern_type* __from, - const extern_type* __end, size_t __max) const - { return this->do_length(__state, __from, __end, __max); } - - int - max_length() const throw() - { return this->do_max_length(); } - - protected: - explicit - __codecvt_abstract_base(size_t __refs = 0) : locale::facet(__refs) { } - - virtual - ~__codecvt_abstract_base() { } -# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const = 0; - - virtual result - do_unshift(state_type& __state, extern_type* __to, - extern_type* __to_end, extern_type*& __to_next) const = 0; - - virtual result - do_in(state_type& __state, const extern_type* __from, - const extern_type* __from_end, const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const = 0; - - virtual int - do_encoding() const throw() = 0; - - virtual bool - do_always_noconv() const throw() = 0; - - virtual int - do_length(state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const = 0; - - virtual int - do_max_length() const throw() = 0; - }; -# 276 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 - template - class codecvt - : public __codecvt_abstract_base<_InternT, _ExternT, _StateT> - { - public: - - typedef codecvt_base::result result; - typedef _InternT intern_type; - typedef _ExternT extern_type; - typedef _StateT state_type; - - protected: - __c_locale _M_c_locale_codecvt; - - public: - static locale::id id; - - explicit - codecvt(size_t __refs = 0) - : __codecvt_abstract_base<_InternT, _ExternT, _StateT> (__refs), - _M_c_locale_codecvt(0) - { } - - explicit - codecvt(__c_locale __cloc, size_t __refs = 0); - - protected: - virtual - ~codecvt() { } - - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_unshift(state_type& __state, extern_type* __to, - extern_type* __to_end, extern_type*& __to_next) const; - - virtual result - do_in(state_type& __state, const extern_type* __from, - const extern_type* __from_end, const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const; - - virtual int - do_encoding() const throw(); - - virtual bool - do_always_noconv() const throw(); - - virtual int - do_length(state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const; - - virtual int - do_max_length() const throw(); - }; - - template - locale::id codecvt<_InternT, _ExternT, _StateT>::id; - - - template<> - class codecvt - : public __codecvt_abstract_base - { - friend class messages; - - public: - - typedef char intern_type; - typedef char extern_type; - typedef mbstate_t state_type; - - protected: - __c_locale _M_c_locale_codecvt; - - public: - static locale::id id; - - explicit - codecvt(size_t __refs = 0); - - explicit - codecvt(__c_locale __cloc, size_t __refs = 0); - - protected: - virtual - ~codecvt(); - - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_unshift(state_type& __state, extern_type* __to, - extern_type* __to_end, extern_type*& __to_next) const; - - virtual result - do_in(state_type& __state, const extern_type* __from, - const extern_type* __from_end, const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const; - - virtual int - do_encoding() const throw(); - - virtual bool - do_always_noconv() const throw(); - - virtual int - do_length(state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const; - - virtual int - do_max_length() const throw(); - }; - - - - - - - template<> - class codecvt - : public __codecvt_abstract_base - { - friend class messages; - - public: - - typedef wchar_t intern_type; - typedef char extern_type; - typedef mbstate_t state_type; - - protected: - __c_locale _M_c_locale_codecvt; - - public: - static locale::id id; - - explicit - codecvt(size_t __refs = 0); - - explicit - codecvt(__c_locale __cloc, size_t __refs = 0); - - protected: - virtual - ~codecvt(); - - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_unshift(state_type& __state, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_in(state_type& __state, - const extern_type* __from, const extern_type* __from_end, - const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const; - - virtual - int do_encoding() const throw(); - - virtual - bool do_always_noconv() const throw(); - - virtual - int do_length(state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const; - - virtual int - do_max_length() const throw(); - }; - - - - - - - - template<> - class codecvt - : public __codecvt_abstract_base - { - public: - - typedef char16_t intern_type; - typedef char extern_type; - typedef mbstate_t state_type; - - public: - static locale::id id; - - explicit - codecvt(size_t __refs = 0) - : __codecvt_abstract_base(__refs) { } - - protected: - virtual - ~codecvt(); - - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_unshift(state_type& __state, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_in(state_type& __state, - const extern_type* __from, const extern_type* __from_end, - const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const; - - virtual - int do_encoding() const throw(); - - virtual - bool do_always_noconv() const throw(); - - virtual - int do_length(state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const; - - virtual int - do_max_length() const throw(); - }; - - - - - - template<> - class codecvt - : public __codecvt_abstract_base - { - public: - - typedef char32_t intern_type; - typedef char extern_type; - typedef mbstate_t state_type; - - public: - static locale::id id; - - explicit - codecvt(size_t __refs = 0) - : __codecvt_abstract_base(__refs) { } - - protected: - virtual - ~codecvt(); - - virtual result - do_out(state_type& __state, const intern_type* __from, - const intern_type* __from_end, const intern_type*& __from_next, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_unshift(state_type& __state, - extern_type* __to, extern_type* __to_end, - extern_type*& __to_next) const; - - virtual result - do_in(state_type& __state, - const extern_type* __from, const extern_type* __from_end, - const extern_type*& __from_next, - intern_type* __to, intern_type* __to_end, - intern_type*& __to_next) const; - - virtual - int do_encoding() const throw(); - - virtual - bool do_always_noconv() const throw(); - - virtual - int do_length(state_type&, const extern_type* __from, - const extern_type* __end, size_t __max) const; - - virtual int - do_max_length() const throw(); - }; -# 698 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 - template - class codecvt_byname : public codecvt<_InternT, _ExternT, _StateT> - { - public: - explicit - codecvt_byname(const char* __s, size_t __refs = 0) - : codecvt<_InternT, _ExternT, _StateT>(__refs) - { - if (__builtin_strcmp(__s, "C") != 0 - && __builtin_strcmp(__s, "POSIX") != 0) - { - this->_S_destroy_c_locale(this->_M_c_locale_codecvt); - this->_S_create_c_locale(this->_M_c_locale_codecvt, __s); - } - } - - - explicit - codecvt_byname(const string& __s, size_t __refs = 0) - : codecvt_byname(__s.c_str(), __refs) { } - - - protected: - virtual - ~codecvt_byname() { } - }; - - - template<> - class codecvt_byname - : public codecvt - { - public: - explicit - codecvt_byname(const char*, size_t __refs = 0) - : codecvt(__refs) { } - - explicit - codecvt_byname(const string& __s, size_t __refs = 0) - : codecvt_byname(__s.c_str(), __refs) { } - - protected: - virtual - ~codecvt_byname() { } - }; - - template<> - class codecvt_byname - : public codecvt - { - public: - explicit - codecvt_byname(const char*, size_t __refs = 0) - : codecvt(__refs) { } - - explicit - codecvt_byname(const string& __s, size_t __refs = 0) - : codecvt_byname(__s.c_str(), __refs) { } - - protected: - virtual - ~codecvt_byname() { } - }; -# 805 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 - extern template class codecvt_byname; - - extern template - const codecvt& - use_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - - extern template class codecvt_byname; - - extern template - const codecvt& - use_facet >(const locale&); - - extern template - bool - has_facet >(const locale&); - - - - extern template class codecvt_byname; - extern template class codecvt_byname; -# 841 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/codecvt.h" 3 -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 -# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/basic_file.h" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/basic_file.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++io.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++io.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdio" 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++io.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++io.h" 3 - typedef __gthread_mutex_t __c_lock; - - - - typedef FILE __c_file; - - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/basic_file.h" 2 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - class __basic_file; - - - template<> - class __basic_file - { - - __c_file* _M_cfile; - - - bool _M_cfile_created; - - public: - __basic_file(__c_lock* __lock = 0) throw (); - - - __basic_file(__basic_file&& __rv, __c_lock* = 0) noexcept - : _M_cfile(__rv._M_cfile), _M_cfile_created(__rv._M_cfile_created) - { - __rv._M_cfile = nullptr; - __rv._M_cfile_created = false; - } - - __basic_file& operator=(const __basic_file&) = delete; - __basic_file& operator=(__basic_file&&) = delete; - - void - swap(__basic_file& __f) noexcept - { - std::swap(_M_cfile, __f._M_cfile); - std::swap(_M_cfile_created, __f._M_cfile_created); - } - - - __basic_file* - open(const char* __name, ios_base::openmode __mode, int __prot = 0664); - - - - - - - __basic_file* - sys_open(__c_file* __file, ios_base::openmode); - - __basic_file* - sys_open(int __fd, ios_base::openmode __mode) throw (); - - __basic_file* - close(); - - __attribute__ ((__pure__)) bool - is_open() const throw (); - - __attribute__ ((__pure__)) int - fd() throw (); - - __attribute__ ((__pure__)) __c_file* - file() throw (); - - ~__basic_file(); - - streamsize - xsputn(const char* __s, streamsize __n); - - streamsize - xsputn_2(const char* __s1, streamsize __n1, - const char* __s2, streamsize __n2); - - streamsize - xsgetn(char* __s, streamsize __n); - - streamoff - seekoff(streamoff __off, ios_base::seekdir __way) throw (); - - int - sync(); - - streamsize - showmanyc(); - }; - - -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 2 3 -# 54 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template().make_preferred().filename())> - using _If_fs_path = enable_if_t, _Result>; -# 86 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template - class basic_filebuf : public basic_streambuf<_CharT, _Traits> - { - - template - using __chk_state = __and_, - is_copy_constructible<_Tp>, - is_default_constructible<_Tp>>; - - static_assert(__chk_state::value, - "state_type must be CopyAssignable, CopyConstructible" - " and DefaultConstructible"); - - static_assert(is_same>::value, - "pos_type must be fpos"); - - public: - - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - typedef basic_streambuf __streambuf_type; - typedef basic_filebuf __filebuf_type; - typedef __basic_file __file_type; - typedef typename traits_type::state_type __state_type; - typedef codecvt __codecvt_type; - - friend class ios_base; - - protected: - - - __c_lock _M_lock; - - - __file_type _M_file; - - - ios_base::openmode _M_mode; - - - __state_type _M_state_beg; - - - - - __state_type _M_state_cur; - - - - __state_type _M_state_last; - - - char_type* _M_buf; - - - - - - - size_t _M_buf_size; - - - bool _M_buf_allocated; -# 162 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - bool _M_reading; - bool _M_writing; - - - - - - - - char_type _M_pback; - char_type* _M_pback_cur_save; - char_type* _M_pback_end_save; - bool _M_pback_init; - - - - const __codecvt_type* _M_codecvt; - - - - - - - char* _M_ext_buf; - - - - - streamsize _M_ext_buf_size; - - - - - - - const char* _M_ext_next; - char* _M_ext_end; - - - - - - - void - _M_create_pback() - { - if (!_M_pback_init) - { - _M_pback_cur_save = this->gptr(); - _M_pback_end_save = this->egptr(); - this->setg(&_M_pback, &_M_pback, &_M_pback + 1); - _M_pback_init = true; - } - } - - - - - - - void - _M_destroy_pback() throw() - { - if (_M_pback_init) - { - - _M_pback_cur_save += this->gptr() != this->eback(); - this->setg(_M_buf, _M_pback_cur_save, _M_pback_end_save); - _M_pback_init = false; - } - } - - public: - - - - - - - - basic_filebuf(); - - - basic_filebuf(const basic_filebuf&) = delete; - basic_filebuf(basic_filebuf&&); - - - - - - virtual - ~basic_filebuf() - { - try - { this->close(); } - catch(...) - { } - } - - - basic_filebuf& operator=(const basic_filebuf&) = delete; - basic_filebuf& operator=(basic_filebuf&&); - void swap(basic_filebuf&); - - - - - - - bool - is_open() const throw() - { return _M_file.is_open(); } -# 316 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - __filebuf_type* - open(const char* __s, ios_base::openmode __mode); -# 337 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - __filebuf_type* - open(const std::string& __s, ios_base::openmode __mode) - { return open(__s.c_str(), __mode); } -# 348 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template - _If_fs_path<_Path, __filebuf_type*> - open(const _Path& __s, ios_base::openmode __mode) - { return open(__s.c_str(), __mode); } -# 367 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - __filebuf_type* - close(); - - protected: - void - _M_allocate_internal_buffer(); - - void - _M_destroy_internal_buffer() throw(); - - - virtual streamsize - showmanyc(); - - - - - - - virtual int_type - underflow(); - - virtual int_type - pbackfail(int_type __c = _Traits::eof()); -# 399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - virtual int_type - overflow(int_type __c = _Traits::eof()); - - - - bool - _M_convert_to_external(char_type*, streamsize); -# 419 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - virtual __streambuf_type* - setbuf(char_type* __s, streamsize __n); - - virtual pos_type - seekoff(off_type __off, ios_base::seekdir __way, - ios_base::openmode __mode = ios_base::in | ios_base::out); - - virtual pos_type - seekpos(pos_type __pos, - ios_base::openmode __mode = ios_base::in | ios_base::out); - - - pos_type - _M_seek(off_type __off, ios_base::seekdir __way, __state_type __state); - - int - _M_get_ext_pos(__state_type &__state); - - virtual int - sync(); - - virtual void - imbue(const locale& __loc); - - virtual streamsize - xsgetn(char_type* __s, streamsize __n); - - virtual streamsize - xsputn(const char_type* __s, streamsize __n); - - - bool - _M_terminate_output(); -# 465 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - _M_set_buffer(streamsize __off) - { - const bool __testin = _M_mode & ios_base::in; - const bool __testout = (_M_mode & ios_base::out - || _M_mode & ios_base::app); - - if (__testin && __off > 0) - this->setg(_M_buf, _M_buf, _M_buf + __off); - else - this->setg(_M_buf, _M_buf, _M_buf); - - if (__testout && __off == 0 && _M_buf_size > 1 ) - this->setp(_M_buf, _M_buf + _M_buf_size - 1); - else - this->setp(0, 0); - } - }; -# 498 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template - class basic_ifstream : public basic_istream<_CharT, _Traits> - { - public: - - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - - typedef basic_filebuf __filebuf_type; - typedef basic_istream __istream_type; - - private: - __filebuf_type _M_filebuf; - - public: -# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - basic_ifstream() : __istream_type(), _M_filebuf() - { this->init(&_M_filebuf); } -# 535 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - explicit - basic_ifstream(const char* __s, ios_base::openmode __mode = ios_base::in) - : __istream_type(), _M_filebuf() - { - this->init(&_M_filebuf); - this->open(__s, __mode); - } -# 568 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - explicit - basic_ifstream(const std::string& __s, - ios_base::openmode __mode = ios_base::in) - : __istream_type(), _M_filebuf() - { - this->init(&_M_filebuf); - this->open(__s, __mode); - } -# 585 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template> - basic_ifstream(const _Path& __s, - ios_base::openmode __mode = ios_base::in) - : basic_ifstream(__s.c_str(), __mode) - { } - - - basic_ifstream(const basic_ifstream&) = delete; - - basic_ifstream(basic_ifstream&& __rhs) - : __istream_type(std::move(__rhs)), - _M_filebuf(std::move(__rhs._M_filebuf)) - { __istream_type::set_rdbuf(&_M_filebuf); } -# 606 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - ~basic_ifstream() - { } - - - - - basic_ifstream& - operator=(const basic_ifstream&) = delete; - - basic_ifstream& - operator=(basic_ifstream&& __rhs) - { - __istream_type::operator=(std::move(__rhs)); - _M_filebuf = std::move(__rhs._M_filebuf); - return *this; - } - - void - swap(basic_ifstream& __rhs) - { - __istream_type::swap(__rhs); - _M_filebuf.swap(__rhs._M_filebuf); - } -# 638 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - __filebuf_type* - rdbuf() const - { return const_cast<__filebuf_type*>(&_M_filebuf); } - - - - - - bool - is_open() - { return _M_filebuf.is_open(); } - - - - bool - is_open() const - { return _M_filebuf.is_open(); } -# 664 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - open(const char* __s, ios_base::openmode __mode = ios_base::in) - { - if (!_M_filebuf.open(__s, __mode | ios_base::in)) - this->setstate(ios_base::failbit); - else - - - this->clear(); - } -# 703 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - open(const std::string& __s, ios_base::openmode __mode = ios_base::in) - { - if (!_M_filebuf.open(__s, __mode | ios_base::in)) - this->setstate(ios_base::failbit); - else - - - this->clear(); - } -# 723 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template - _If_fs_path<_Path, void> - open(const _Path& __s, ios_base::openmode __mode = ios_base::in) - { open(__s.c_str(), __mode); } -# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - close() - { - if (!_M_filebuf.close()) - this->setstate(ios_base::failbit); - } - }; -# 759 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template - class basic_ofstream : public basic_ostream<_CharT,_Traits> - { - public: - - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - - typedef basic_filebuf __filebuf_type; - typedef basic_ostream __ostream_type; - - private: - __filebuf_type _M_filebuf; - - public: -# 786 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - basic_ofstream(): __ostream_type(), _M_filebuf() - { this->init(&_M_filebuf); } -# 796 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - explicit - basic_ofstream(const char* __s, - ios_base::openmode __mode = ios_base::out) - : __ostream_type(), _M_filebuf() - { - this->init(&_M_filebuf); - this->open(__s, __mode); - } -# 831 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - explicit - basic_ofstream(const std::string& __s, - ios_base::openmode __mode = ios_base::out) - : __ostream_type(), _M_filebuf() - { - this->init(&_M_filebuf); - this->open(__s, __mode); - } -# 848 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template> - basic_ofstream(const _Path& __s, - ios_base::openmode __mode = ios_base::out) - : basic_ofstream(__s.c_str(), __mode) - { } - - - basic_ofstream(const basic_ofstream&) = delete; - - basic_ofstream(basic_ofstream&& __rhs) - : __ostream_type(std::move(__rhs)), - _M_filebuf(std::move(__rhs._M_filebuf)) - { __ostream_type::set_rdbuf(&_M_filebuf); } -# 869 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - ~basic_ofstream() - { } - - - - - basic_ofstream& - operator=(const basic_ofstream&) = delete; - - basic_ofstream& - operator=(basic_ofstream&& __rhs) - { - __ostream_type::operator=(std::move(__rhs)); - _M_filebuf = std::move(__rhs._M_filebuf); - return *this; - } - - void - swap(basic_ofstream& __rhs) - { - __ostream_type::swap(__rhs); - _M_filebuf.swap(__rhs._M_filebuf); - } -# 901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - __filebuf_type* - rdbuf() const - { return const_cast<__filebuf_type*>(&_M_filebuf); } - - - - - - bool - is_open() - { return _M_filebuf.is_open(); } - - - - bool - is_open() const - { return _M_filebuf.is_open(); } -# 927 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - open(const char* __s, ios_base::openmode __mode = ios_base::out) - { - if (!_M_filebuf.open(__s, __mode | ios_base::out)) - this->setstate(ios_base::failbit); - else - - - this->clear(); - } -# 966 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - open(const std::string& __s, ios_base::openmode __mode = ios_base::out) - { - if (!_M_filebuf.open(__s, __mode | ios_base::out)) - this->setstate(ios_base::failbit); - else - - - this->clear(); - } -# 986 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template - _If_fs_path<_Path, void> - open(const _Path& __s, ios_base::openmode __mode = ios_base::out) - { open(__s.c_str(), __mode); } -# 999 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - close() - { - if (!_M_filebuf.close()) - this->setstate(ios_base::failbit); - } - }; -# 1022 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template - class basic_fstream : public basic_iostream<_CharT, _Traits> - { - public: - - typedef _CharT char_type; - typedef _Traits traits_type; - typedef typename traits_type::int_type int_type; - typedef typename traits_type::pos_type pos_type; - typedef typename traits_type::off_type off_type; - - - typedef basic_filebuf __filebuf_type; - typedef basic_ios __ios_type; - typedef basic_iostream __iostream_type; - - private: - __filebuf_type _M_filebuf; - - public: -# 1050 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - basic_fstream() - : __iostream_type(), _M_filebuf() - { this->init(&_M_filebuf); } - - - - - - - explicit - basic_fstream(const char* __s, - ios_base::openmode __mode = ios_base::in | ios_base::out) - : __iostream_type(0), _M_filebuf() - { - this->init(&_M_filebuf); - this->open(__s, __mode); - } -# 1089 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - explicit - basic_fstream(const std::string& __s, - ios_base::openmode __mode = ios_base::in | ios_base::out) - : __iostream_type(0), _M_filebuf() - { - this->init(&_M_filebuf); - this->open(__s, __mode); - } - - - - - - - - template> - basic_fstream(const _Path& __s, - ios_base::openmode __mode = ios_base::in | ios_base::out) - : basic_fstream(__s.c_str(), __mode) - { } - - - basic_fstream(const basic_fstream&) = delete; - - basic_fstream(basic_fstream&& __rhs) - : __iostream_type(std::move(__rhs)), - _M_filebuf(std::move(__rhs._M_filebuf)) - { __iostream_type::set_rdbuf(&_M_filebuf); } -# 1125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - ~basic_fstream() - { } - - - - - basic_fstream& - operator=(const basic_fstream&) = delete; - - basic_fstream& - operator=(basic_fstream&& __rhs) - { - __iostream_type::operator=(std::move(__rhs)); - _M_filebuf = std::move(__rhs._M_filebuf); - return *this; - } - - void - swap(basic_fstream& __rhs) - { - __iostream_type::swap(__rhs); - _M_filebuf.swap(__rhs._M_filebuf); - } -# 1157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - __filebuf_type* - rdbuf() const - { return const_cast<__filebuf_type*>(&_M_filebuf); } - - - - - - bool - is_open() - { return _M_filebuf.is_open(); } - - - - bool - is_open() const - { return _M_filebuf.is_open(); } -# 1183 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - open(const char* __s, - ios_base::openmode __mode = ios_base::in | ios_base::out) - { - if (!_M_filebuf.open(__s, __mode)) - this->setstate(ios_base::failbit); - else - - - this->clear(); - } -# 1224 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - open(const std::string& __s, - ios_base::openmode __mode = ios_base::in | ios_base::out) - { - if (!_M_filebuf.open(__s, __mode)) - this->setstate(ios_base::failbit); - else - - - this->clear(); - } -# 1245 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - template - _If_fs_path<_Path, void> - open(const _Path& __s, - ios_base::openmode __mode = ios_base::in | ios_base::out) - { open(__s.c_str(), __mode); } -# 1259 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/fstream" 3 - void - close() - { - if (!_M_filebuf.close()) - this->setstate(ios_base::failbit); - } - }; - - - - template - inline void - swap(basic_filebuf<_CharT, _Traits>& __x, - basic_filebuf<_CharT, _Traits>& __y) - { __x.swap(__y); } - - - template - inline void - swap(basic_ifstream<_CharT, _Traits>& __x, - basic_ifstream<_CharT, _Traits>& __y) - { __x.swap(__y); } - - - template - inline void - swap(basic_ofstream<_CharT, _Traits>& __x, - basic_ofstream<_CharT, _Traits>& __y) - { __x.swap(__y); } - - - template - inline void - swap(basic_fstream<_CharT, _Traits>& __x, - basic_fstream<_CharT, _Traits>& __y) - { __x.swap(__y); } - - - -} - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/fstream.tcc" 1 3 -# 38 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/fstream.tcc" 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cerrno" 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/fstream.tcc" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - void - basic_filebuf<_CharT, _Traits>:: - _M_allocate_internal_buffer() - { - - - if (!_M_buf_allocated && !_M_buf) - { - _M_buf = new char_type[_M_buf_size]; - _M_buf_allocated = true; - } - } - - template - void - basic_filebuf<_CharT, _Traits>:: - _M_destroy_internal_buffer() throw() - { - if (_M_buf_allocated) - { - delete [] _M_buf; - _M_buf = 0; - _M_buf_allocated = false; - } - delete [] _M_ext_buf; - _M_ext_buf = 0; - _M_ext_buf_size = 0; - _M_ext_next = 0; - _M_ext_end = 0; - } - - template - basic_filebuf<_CharT, _Traits>:: - basic_filebuf() : __streambuf_type(), _M_lock(), _M_file(&_M_lock), - _M_mode(ios_base::openmode(0)), _M_state_beg(), _M_state_cur(), - _M_state_last(), _M_buf(0), _M_buf_size(8192), - _M_buf_allocated(false), _M_reading(false), _M_writing(false), _M_pback(), - _M_pback_cur_save(0), _M_pback_end_save(0), _M_pback_init(false), - _M_codecvt(0), _M_ext_buf(0), _M_ext_buf_size(0), _M_ext_next(0), - _M_ext_end(0) - { - _M_codecvt = std::__try_use_facet<__codecvt_type>(this->_M_buf_locale); - } - - - template - basic_filebuf<_CharT, _Traits>:: - basic_filebuf(basic_filebuf&& __rhs) - : __streambuf_type(__rhs), - _M_lock(), _M_file(std::move(__rhs._M_file), &_M_lock), - _M_mode(std::__exchange(__rhs._M_mode, ios_base::openmode(0))), - _M_state_beg(std::move(__rhs._M_state_beg)), - _M_state_cur(std::move(__rhs._M_state_cur)), - _M_state_last(std::move(__rhs._M_state_last)), - _M_buf(std::__exchange(__rhs._M_buf, nullptr)), - _M_buf_size(std::__exchange(__rhs._M_buf_size, 1)), - _M_buf_allocated(std::__exchange(__rhs._M_buf_allocated, false)), - _M_reading(std::__exchange(__rhs._M_reading, false)), - _M_writing(std::__exchange(__rhs._M_writing, false)), - _M_pback(__rhs._M_pback), - _M_pback_cur_save(std::__exchange(__rhs._M_pback_cur_save, nullptr)), - _M_pback_end_save(std::__exchange(__rhs._M_pback_end_save, nullptr)), - _M_pback_init(std::__exchange(__rhs._M_pback_init, false)), - _M_codecvt(__rhs._M_codecvt), - _M_ext_buf(std::__exchange(__rhs._M_ext_buf, nullptr)), - _M_ext_buf_size(std::__exchange(__rhs._M_ext_buf_size, 0)), - _M_ext_next(std::__exchange(__rhs._M_ext_next, nullptr)), - _M_ext_end(std::__exchange(__rhs._M_ext_end, nullptr)) - { - __rhs._M_set_buffer(-1); - __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg; - } - - template - basic_filebuf<_CharT, _Traits>& - basic_filebuf<_CharT, _Traits>:: - operator=(basic_filebuf&& __rhs) - { - this->close(); - __streambuf_type::operator=(__rhs); - _M_file.swap(__rhs._M_file); - _M_mode = std::__exchange(__rhs._M_mode, ios_base::openmode(0)); - _M_state_beg = std::move(__rhs._M_state_beg); - _M_state_cur = std::move(__rhs._M_state_cur); - _M_state_last = std::move(__rhs._M_state_last); - _M_buf = std::__exchange(__rhs._M_buf, nullptr); - _M_buf_size = std::__exchange(__rhs._M_buf_size, 1); - _M_buf_allocated = std::__exchange(__rhs._M_buf_allocated, false); - _M_ext_buf = std::__exchange(__rhs._M_ext_buf, nullptr); - _M_ext_buf_size = std::__exchange(__rhs._M_ext_buf_size, 0); - _M_ext_next = std::__exchange(__rhs._M_ext_next, nullptr); - _M_ext_end = std::__exchange(__rhs._M_ext_end, nullptr); - _M_reading = std::__exchange(__rhs._M_reading, false); - _M_writing = std::__exchange(__rhs._M_writing, false); - _M_pback_cur_save = std::__exchange(__rhs._M_pback_cur_save, nullptr); - _M_pback_end_save = std::__exchange(__rhs._M_pback_end_save, nullptr); - _M_pback_init = std::__exchange(__rhs._M_pback_init, false); - __rhs._M_set_buffer(-1); - __rhs._M_state_last = __rhs._M_state_cur = __rhs._M_state_beg; - return *this; - } - - template - void - basic_filebuf<_CharT, _Traits>:: - swap(basic_filebuf& __rhs) - { - __streambuf_type::swap(__rhs); - _M_file.swap(__rhs._M_file); - std::swap(_M_mode, __rhs._M_mode); - std::swap(_M_state_beg, __rhs._M_state_beg); - std::swap(_M_state_cur, __rhs._M_state_cur); - std::swap(_M_state_last, __rhs._M_state_last); - std::swap(_M_buf, __rhs._M_buf); - std::swap(_M_buf_size, __rhs._M_buf_size); - std::swap(_M_buf_allocated, __rhs._M_buf_allocated); - std::swap(_M_ext_buf, __rhs._M_ext_buf); - std::swap(_M_ext_buf_size, __rhs._M_ext_buf_size); - std::swap(_M_ext_next, __rhs._M_ext_next); - std::swap(_M_ext_end, __rhs._M_ext_end); - std::swap(_M_reading, __rhs._M_reading); - std::swap(_M_writing, __rhs._M_writing); - std::swap(_M_pback_cur_save, __rhs._M_pback_cur_save); - std::swap(_M_pback_end_save, __rhs._M_pback_end_save); - std::swap(_M_pback_init, __rhs._M_pback_init); - } - - - template - typename basic_filebuf<_CharT, _Traits>::__filebuf_type* - basic_filebuf<_CharT, _Traits>:: - open(const char* __s, ios_base::openmode __mode) - { - __filebuf_type *__ret = 0; - if (!this->is_open()) - { - _M_file.open(__s, __mode); - if (this->is_open()) - { - _M_allocate_internal_buffer(); - _M_mode = __mode; - - - _M_reading = false; - _M_writing = false; - _M_set_buffer(-1); - - - _M_state_last = _M_state_cur = _M_state_beg; - - - if ((__mode & ios_base::ate) - && this->seekoff(0, ios_base::end, __mode) - == pos_type(off_type(-1))) - this->close(); - else - __ret = this; - } - } - return __ret; - } -# 246 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/fstream.tcc" 3 - template - typename basic_filebuf<_CharT, _Traits>::__filebuf_type* - basic_filebuf<_CharT, _Traits>:: - close() - { - if (!this->is_open()) - return 0; - - bool __testfail = false; - { - - struct __close_sentry - { - basic_filebuf *__fb; - __close_sentry (basic_filebuf *__fbi): __fb(__fbi) { } - ~__close_sentry () - { - __fb->_M_mode = ios_base::openmode(0); - __fb->_M_pback_init = false; - __fb->_M_destroy_internal_buffer(); - __fb->_M_reading = false; - __fb->_M_writing = false; - __fb->_M_set_buffer(-1); - __fb->_M_state_last = __fb->_M_state_cur = __fb->_M_state_beg; - } - } __cs (this); - - try - { - if (!_M_terminate_output()) - __testfail = true; - } - catch(...) - { - _M_file.close(); - throw; - } - } - - if (!_M_file.close()) - __testfail = true; - - if (__testfail) - return 0; - else - return this; - } - - template - streamsize - basic_filebuf<_CharT, _Traits>:: - showmanyc() - { - streamsize __ret = -1; - const bool __testin = _M_mode & ios_base::in; - if (__testin && this->is_open()) - { - - - __ret = this->egptr() - this->gptr(); - - - - - - - - if (__check_facet(_M_codecvt).encoding() >= 0) - - __ret += _M_file.showmanyc() / _M_codecvt->max_length(); - } - return __ret; - } - - template - typename basic_filebuf<_CharT, _Traits>::int_type - basic_filebuf<_CharT, _Traits>:: - underflow() - { - int_type __ret = traits_type::eof(); - const bool __testin = _M_mode & ios_base::in; - if (__testin) - { - if (_M_writing) - { - if (overflow() == traits_type::eof()) - return __ret; - _M_set_buffer(-1); - _M_writing = false; - } - - - - _M_destroy_pback(); - - if (this->gptr() < this->egptr()) - return traits_type::to_int_type(*this->gptr()); - - - const size_t __buflen = _M_buf_size > 1 ? _M_buf_size - 1 : 1; - - - bool __got_eof = false; - - streamsize __ilen = 0; - codecvt_base::result __r = codecvt_base::ok; - if (__check_facet(_M_codecvt).always_noconv()) - { - __ilen = _M_file.xsg \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/descriptors/__cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/descriptors/__cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp deleted file mode 100644 index dc239d3..0000000 --- a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/descriptors/__cpp_vk_descriptor_set.cpp-e50198dc.cpp.tmp +++ /dev/null @@ -1,34132 +0,0 @@ -# 1 "src/renderer/descriptors/vk_descriptor_set.cpp" -# 1 "" 1 -# 1 "" 3 -# 433 "" 3 -# 1 "" 1 -# 1 "" 2 -# 1 "src/renderer/descriptors/vk_descriptor_set.cpp" 2 -# 13 "src/renderer/descriptors/vk_descriptor_set.cpp" -# 1 "src/renderer/descriptors/vk_descriptor_set.h" 1 -# 16 "src/renderer/descriptors/vk_descriptor_set.h" -# 1 "third_party/volk.h" 1 -# 50 "third_party/volk.h" -# 1 "/usr/include/vulkan/vulkan.h" 1 3 4 -# 10 "/usr/include/vulkan/vulkan.h" 3 4 -# 1 "/usr/include/vulkan/vk_platform.h" 1 3 4 -# 15 "/usr/include/vulkan/vk_platform.h" 3 4 -extern "C" -{ -# 62 "/usr/include/vulkan/vk_platform.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 35 "/usr/lib/clang/16/include/stddef.h" 3 4 -typedef long int ptrdiff_t; -# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 -typedef long unsigned int size_t; -# 109 "/usr/lib/clang/16/include/stddef.h" 3 4 -# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 4 -# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 4 -typedef struct { - long long __clang_max_align_nonce1 - __attribute__((__aligned__(__alignof__(long long)))); - long double __clang_max_align_nonce2 - __attribute__((__aligned__(__alignof__(long double)))); -} max_align_t; -# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 4 -# 63 "/usr/include/vulkan/vk_platform.h" 2 3 4 -# 76 "/usr/include/vulkan/vk_platform.h" 3 4 -# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 4 -# 52 "/usr/lib/clang/16/include/stdint.h" 3 4 -# 1 "/usr/include/stdint.h" 1 3 4 -# 26 "/usr/include/stdint.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 33 "/usr/include/bits/libc-header-start.h" 3 4 -# 1 "/usr/include/features.h" 1 3 4 -# 394 "/usr/include/features.h" 3 4 -# 1 "/usr/include/features-time64.h" 1 3 4 -# 20 "/usr/include/features-time64.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 21 "/usr/include/features-time64.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 22 "/usr/include/features-time64.h" 2 3 4 -# 395 "/usr/include/features.h" 2 3 4 -# 481 "/usr/include/features.h" 3 4 -# 1 "/usr/include/stdc-predef.h" 1 3 4 -# 482 "/usr/include/features.h" 2 3 4 -# 503 "/usr/include/features.h" 3 4 -# 1 "/usr/include/sys/cdefs.h" 1 3 4 -# 576 "/usr/include/sys/cdefs.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 577 "/usr/include/sys/cdefs.h" 2 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 578 "/usr/include/sys/cdefs.h" 2 3 4 -# 504 "/usr/include/features.h" 2 3 4 -# 527 "/usr/include/features.h" 3 4 -# 1 "/usr/include/gnu/stubs.h" 1 3 4 -# 10 "/usr/include/gnu/stubs.h" 3 4 -# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 -# 11 "/usr/include/gnu/stubs.h" 2 3 4 -# 528 "/usr/include/features.h" 2 3 4 -# 34 "/usr/include/bits/libc-header-start.h" 2 3 4 -# 27 "/usr/include/stdint.h" 2 3 4 -# 1 "/usr/include/bits/types.h" 1 3 4 -# 27 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 28 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 29 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned char __u_char; -typedef unsigned short int __u_short; -typedef unsigned int __u_int; -typedef unsigned long int __u_long; - - -typedef signed char __int8_t; -typedef unsigned char __uint8_t; -typedef signed short int __int16_t; -typedef unsigned short int __uint16_t; -typedef signed int __int32_t; -typedef unsigned int __uint32_t; - -typedef signed long int __int64_t; -typedef unsigned long int __uint64_t; - - - - - - -typedef __int8_t __int_least8_t; -typedef __uint8_t __uint_least8_t; -typedef __int16_t __int_least16_t; -typedef __uint16_t __uint_least16_t; -typedef __int32_t __int_least32_t; -typedef __uint32_t __uint_least32_t; -typedef __int64_t __int_least64_t; -typedef __uint64_t __uint_least64_t; - - - -typedef long int __quad_t; -typedef unsigned long int __u_quad_t; - - - - - - - -typedef long int __intmax_t; -typedef unsigned long int __uintmax_t; -# 141 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/typesizes.h" 1 3 4 -# 142 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/time64.h" 1 3 4 -# 143 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned long int __dev_t; -typedef unsigned int __uid_t; -typedef unsigned int __gid_t; -typedef unsigned long int __ino_t; -typedef unsigned long int __ino64_t; -typedef unsigned int __mode_t; -typedef unsigned long int __nlink_t; -typedef long int __off_t; -typedef long int __off64_t; -typedef int __pid_t; -typedef struct { int __val[2]; } __fsid_t; -typedef long int __clock_t; -typedef unsigned long int __rlim_t; -typedef unsigned long int __rlim64_t; -typedef unsigned int __id_t; -typedef long int __time_t; -typedef unsigned int __useconds_t; -typedef long int __suseconds_t; -typedef long int __suseconds64_t; - -typedef int __daddr_t; -typedef int __key_t; - - -typedef int __clockid_t; - - -typedef void * __timer_t; - - -typedef long int __blksize_t; - - - - -typedef long int __blkcnt_t; -typedef long int __blkcnt64_t; - - -typedef unsigned long int __fsblkcnt_t; -typedef unsigned long int __fsblkcnt64_t; - - -typedef unsigned long int __fsfilcnt_t; -typedef unsigned long int __fsfilcnt64_t; - - -typedef long int __fsword_t; - -typedef long int __ssize_t; - - -typedef long int __syscall_slong_t; - -typedef unsigned long int __syscall_ulong_t; - - - -typedef __off64_t __loff_t; -typedef char *__caddr_t; - - -typedef long int __intptr_t; - - -typedef unsigned int __socklen_t; - - - - -typedef int __sig_atomic_t; -# 28 "/usr/include/stdint.h" 2 3 4 -# 1 "/usr/include/bits/wchar.h" 1 3 4 -# 29 "/usr/include/stdint.h" 2 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 30 "/usr/include/stdint.h" 2 3 4 - - - - -# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-intn.h" 3 4 -typedef __int8_t int8_t; -typedef __int16_t int16_t; -typedef __int32_t int32_t; -typedef __int64_t int64_t; -# 35 "/usr/include/stdint.h" 2 3 4 - - -# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-uintn.h" 3 4 -typedef __uint8_t uint8_t; -typedef __uint16_t uint16_t; -typedef __uint32_t uint32_t; -typedef __uint64_t uint64_t; -# 38 "/usr/include/stdint.h" 2 3 4 - - - - - -typedef __int_least8_t int_least8_t; -typedef __int_least16_t int_least16_t; -typedef __int_least32_t int_least32_t; -typedef __int_least64_t int_least64_t; - - -typedef __uint_least8_t uint_least8_t; -typedef __uint_least16_t uint_least16_t; -typedef __uint_least32_t uint_least32_t; -typedef __uint_least64_t uint_least64_t; - - - - - -typedef signed char int_fast8_t; - -typedef long int int_fast16_t; -typedef long int int_fast32_t; -typedef long int int_fast64_t; -# 71 "/usr/include/stdint.h" 3 4 -typedef unsigned char uint_fast8_t; - -typedef unsigned long int uint_fast16_t; -typedef unsigned long int uint_fast32_t; -typedef unsigned long int uint_fast64_t; -# 87 "/usr/include/stdint.h" 3 4 -typedef long int intptr_t; - - -typedef unsigned long int uintptr_t; -# 101 "/usr/include/stdint.h" 3 4 -typedef __intmax_t intmax_t; -typedef __uintmax_t uintmax_t; -# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 4 -# 77 "/usr/include/vulkan/vk_platform.h" 2 3 4 - - - - -} -# 11 "/usr/include/vulkan/vulkan.h" 2 3 4 -# 1 "/usr/include/vulkan/vulkan_core.h" 1 3 4 -# 17 "/usr/include/vulkan/vulkan_core.h" 3 4 -extern "C" { -# 94 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef uint32_t VkBool32; -typedef uint64_t VkDeviceAddress; -typedef uint64_t VkDeviceSize; -typedef uint32_t VkFlags; -typedef uint32_t VkSampleMask; -typedef struct VkBuffer_T *VkBuffer; -typedef struct VkImage_T *VkImage; -typedef struct VkInstance_T* VkInstance; -typedef struct VkPhysicalDevice_T* VkPhysicalDevice; -typedef struct VkDevice_T* VkDevice; -typedef struct VkQueue_T* VkQueue; -typedef struct VkSemaphore_T *VkSemaphore; -typedef struct VkCommandBuffer_T* VkCommandBuffer; -typedef struct VkFence_T *VkFence; -typedef struct VkDeviceMemory_T *VkDeviceMemory; -typedef struct VkEvent_T *VkEvent; -typedef struct VkQueryPool_T *VkQueryPool; -typedef struct VkBufferView_T *VkBufferView; -typedef struct VkImageView_T *VkImageView; -typedef struct VkShaderModule_T *VkShaderModule; -typedef struct VkPipelineCache_T *VkPipelineCache; -typedef struct VkPipelineLayout_T *VkPipelineLayout; -typedef struct VkPipeline_T *VkPipeline; -typedef struct VkRenderPass_T *VkRenderPass; -typedef struct VkDescriptorSetLayout_T *VkDescriptorSetLayout; -typedef struct VkSampler_T *VkSampler; -typedef struct VkDescriptorSet_T *VkDescriptorSet; -typedef struct VkDescriptorPool_T *VkDescriptorPool; -typedef struct VkFramebuffer_T *VkFramebuffer; -typedef struct VkCommandPool_T *VkCommandPool; -# 140 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkResult { - VK_SUCCESS = 0, - VK_NOT_READY = 1, - VK_TIMEOUT = 2, - VK_EVENT_SET = 3, - VK_EVENT_RESET = 4, - VK_INCOMPLETE = 5, - VK_ERROR_OUT_OF_HOST_MEMORY = -1, - VK_ERROR_OUT_OF_DEVICE_MEMORY = -2, - VK_ERROR_INITIALIZATION_FAILED = -3, - VK_ERROR_DEVICE_LOST = -4, - VK_ERROR_MEMORY_MAP_FAILED = -5, - VK_ERROR_LAYER_NOT_PRESENT = -6, - VK_ERROR_EXTENSION_NOT_PRESENT = -7, - VK_ERROR_FEATURE_NOT_PRESENT = -8, - VK_ERROR_INCOMPATIBLE_DRIVER = -9, - VK_ERROR_TOO_MANY_OBJECTS = -10, - VK_ERROR_FORMAT_NOT_SUPPORTED = -11, - VK_ERROR_FRAGMENTED_POOL = -12, - VK_ERROR_UNKNOWN = -13, - VK_ERROR_OUT_OF_POOL_MEMORY = -1000069000, - VK_ERROR_INVALID_EXTERNAL_HANDLE = -1000072003, - VK_ERROR_FRAGMENTATION = -1000161000, - VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS = -1000257000, - VK_PIPELINE_COMPILE_REQUIRED = 1000297000, - VK_ERROR_SURFACE_LOST_KHR = -1000000000, - VK_ERROR_NATIVE_WINDOW_IN_USE_KHR = -1000000001, - VK_SUBOPTIMAL_KHR = 1000001003, - VK_ERROR_OUT_OF_DATE_KHR = -1000001004, - VK_ERROR_INCOMPATIBLE_DISPLAY_KHR = -1000003001, - VK_ERROR_VALIDATION_FAILED_EXT = -1000011001, - VK_ERROR_INVALID_SHADER_NV = -1000012000, - VK_ERROR_IMAGE_USAGE_NOT_SUPPORTED_KHR = -1000023000, - VK_ERROR_VIDEO_PICTURE_LAYOUT_NOT_SUPPORTED_KHR = -1000023001, - VK_ERROR_VIDEO_PROFILE_OPERATION_NOT_SUPPORTED_KHR = -1000023002, - VK_ERROR_VIDEO_PROFILE_FORMAT_NOT_SUPPORTED_KHR = -1000023003, - VK_ERROR_VIDEO_PROFILE_CODEC_NOT_SUPPORTED_KHR = -1000023004, - VK_ERROR_VIDEO_STD_VERSION_NOT_SUPPORTED_KHR = -1000023005, - VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT = -1000158000, - VK_ERROR_NOT_PERMITTED_KHR = -1000174001, - VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT = -1000255000, - VK_THREAD_IDLE_KHR = 1000268000, - VK_THREAD_DONE_KHR = 1000268001, - VK_OPERATION_DEFERRED_KHR = 1000268002, - VK_OPERATION_NOT_DEFERRED_KHR = 1000268003, - - - - VK_ERROR_COMPRESSION_EXHAUSTED_EXT = -1000338000, - VK_ERROR_INCOMPATIBLE_SHADER_BINARY_EXT = 1000482000, - VK_ERROR_OUT_OF_POOL_MEMORY_KHR = VK_ERROR_OUT_OF_POOL_MEMORY, - VK_ERROR_INVALID_EXTERNAL_HANDLE_KHR = VK_ERROR_INVALID_EXTERNAL_HANDLE, - VK_ERROR_FRAGMENTATION_EXT = VK_ERROR_FRAGMENTATION, - VK_ERROR_NOT_PERMITTED_EXT = VK_ERROR_NOT_PERMITTED_KHR, - VK_ERROR_INVALID_DEVICE_ADDRESS_EXT = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, - VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS_KHR = VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS, - VK_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, - VK_ERROR_PIPELINE_COMPILE_REQUIRED_EXT = VK_PIPELINE_COMPILE_REQUIRED, - VK_RESULT_MAX_ENUM = 0x7FFFFFFF -} VkResult; - -typedef enum VkStructureType { - VK_STRUCTURE_TYPE_APPLICATION_INFO = 0, - VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO = 1, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO = 2, - VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO = 3, - VK_STRUCTURE_TYPE_SUBMIT_INFO = 4, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO = 5, - VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE = 6, - VK_STRUCTURE_TYPE_BIND_SPARSE_INFO = 7, - VK_STRUCTURE_TYPE_FENCE_CREATE_INFO = 8, - VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO = 9, - VK_STRUCTURE_TYPE_EVENT_CREATE_INFO = 10, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO = 11, - VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO = 12, - VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO = 13, - VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO = 14, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO = 15, - VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO = 16, - VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO = 17, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO = 18, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO = 19, - VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO = 20, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO = 21, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO = 22, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO = 23, - VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO = 24, - VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO = 25, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO = 26, - VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO = 27, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO = 28, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO = 29, - VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO = 30, - VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO = 31, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO = 32, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO = 33, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO = 34, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET = 35, - VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET = 36, - VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO = 37, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO = 38, - VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO = 39, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO = 40, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO = 41, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO = 42, - VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO = 43, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER = 44, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER = 45, - VK_STRUCTURE_TYPE_MEMORY_BARRIER = 46, - VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO = 47, - VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO = 48, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES = 1000094000, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO = 1000157000, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO = 1000157001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES = 1000083000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS = 1000127000, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO = 1000127001, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO = 1000060000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO = 1000060003, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO = 1000060004, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO = 1000060005, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO = 1000060006, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO = 1000060013, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO = 1000060014, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES = 1000070000, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO = 1000070001, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2 = 1000146000, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2 = 1000146001, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2 = 1000146002, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2 = 1000146003, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2 = 1000146004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2 = 1000059000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 = 1000059001, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2 = 1000059002, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2 = 1000059003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2 = 1000059004, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2 = 1000059005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2 = 1000059006, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2 = 1000059007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2 = 1000059008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES = 1000117000, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO = 1000117001, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO = 1000117002, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO = 1000117003, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO = 1000053000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES = 1000053001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES = 1000053002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES = 1000120000, - VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO = 1000145000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES = 1000145001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES = 1000145002, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2 = 1000145003, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO = 1000156000, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO = 1000156001, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO = 1000156002, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO = 1000156003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES = 1000156004, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES = 1000156005, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO = 1000085000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO = 1000071000, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES = 1000071001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO = 1000071002, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES = 1000071003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES = 1000071004, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO = 1000072000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO = 1000072001, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO = 1000072002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO = 1000112000, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES = 1000112001, - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO = 1000113000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO = 1000077000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO = 1000076000, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES = 1000076001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES = 1000168000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT = 1000168001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES = 1000063000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES = 49, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES = 50, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES = 51, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES = 52, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO = 1000147000, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2 = 1000109000, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2 = 1000109001, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2 = 1000109002, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2 = 1000109003, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2 = 1000109004, - VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO = 1000109005, - VK_STRUCTURE_TYPE_SUBPASS_END_INFO = 1000109006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES = 1000177000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES = 1000196000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES = 1000180000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES = 1000082000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES = 1000197000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO = 1000161000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES = 1000161001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES = 1000161002, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO = 1000161003, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT = 1000161004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES = 1000199000, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE = 1000199001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES = 1000221000, - VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO = 1000246000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES = 1000130000, - VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO = 1000130001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES = 1000211000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES = 1000108000, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO = 1000108001, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO = 1000108002, - VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO = 1000108003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES = 1000253000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES = 1000175000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES = 1000241000, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT = 1000241001, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT = 1000241002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES = 1000261000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES = 1000207000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES = 1000207001, - VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO = 1000207002, - VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO = 1000207003, - VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO = 1000207004, - VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO = 1000207005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES = 1000257000, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO = 1000244001, - VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO = 1000257002, - VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO = 1000257003, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO = 1000257004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES = 53, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES = 54, - VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO = 1000192000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES = 1000215000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES = 1000245000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES = 1000276000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES = 1000295000, - VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO = 1000295001, - VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO = 1000295002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES = 1000297000, - VK_STRUCTURE_TYPE_MEMORY_BARRIER_2 = 1000314000, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2 = 1000314001, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2 = 1000314002, - VK_STRUCTURE_TYPE_DEPENDENCY_INFO = 1000314003, - VK_STRUCTURE_TYPE_SUBMIT_INFO_2 = 1000314004, - VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO = 1000314005, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO = 1000314006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES = 1000314007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES = 1000325000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES = 1000335000, - VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2 = 1000337000, - VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2 = 1000337001, - VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2 = 1000337002, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2 = 1000337003, - VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2 = 1000337004, - VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2 = 1000337005, - VK_STRUCTURE_TYPE_BUFFER_COPY_2 = 1000337006, - VK_STRUCTURE_TYPE_IMAGE_COPY_2 = 1000337007, - VK_STRUCTURE_TYPE_IMAGE_BLIT_2 = 1000337008, - VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2 = 1000337009, - VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2 = 1000337010, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES = 1000225000, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO = 1000225001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES = 1000225002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES = 1000138000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES = 1000138001, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK = 1000138002, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO = 1000138003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES = 1000066000, - VK_STRUCTURE_TYPE_RENDERING_INFO = 1000044000, - VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO = 1000044001, - VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO = 1000044002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES = 1000044003, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO = 1000044004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES = 1000280000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES = 1000280001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES = 1000281001, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3 = 1000360000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES = 1000413000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES = 1000413001, - VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS = 1000413002, - VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS = 1000413003, - VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR = 1000001000, - VK_STRUCTURE_TYPE_PRESENT_INFO_KHR = 1000001001, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR = 1000060007, - VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR = 1000060008, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR = 1000060009, - VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR = 1000060010, - VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR = 1000060011, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR = 1000060012, - VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR = 1000002000, - VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR = 1000002001, - VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR = 1000003000, - VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR = 1000004000, - VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR = 1000005000, - VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR = 1000006000, - VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR = 1000008000, - VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR = 1000009000, - VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT = 1000011000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD = 1000018000, - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT = 1000022000, - VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT = 1000022001, - VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT = 1000022002, - VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR = 1000023000, - VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR = 1000023001, - VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR = 1000023002, - VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR = 1000023003, - VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR = 1000023004, - VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR = 1000023005, - VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000023006, - VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR = 1000023007, - VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR = 1000023008, - VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR = 1000023009, - VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR = 1000023010, - VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR = 1000023011, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR = 1000023012, - VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR = 1000023013, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR = 1000023014, - VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR = 1000023015, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR = 1000023016, - VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR = 1000024000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR = 1000024001, - VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR = 1000024002, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV = 1000026000, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV = 1000026001, - VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV = 1000026002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT = 1000028000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT = 1000028001, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT = 1000028002, - VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX = 1000029000, - VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX = 1000029001, - VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX = 1000029002, - VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX = 1000030000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX = 1000030001, -# 554 "/usr/include/vulkan/vulkan_core.h" 3 4 - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_KHR = 1000040000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_KHR = 1000040001, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_KHR = 1000040003, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000040004, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_KHR = 1000040005, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_KHR = 1000040006, - VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD = 1000041000, - VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000044006, - VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT = 1000044007, - VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD = 1000044008, - VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX = 1000044009, - VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP = 1000049000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV = 1000050000, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV = 1000056000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV = 1000056001, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV = 1000057001, - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV = 1000058000, - VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT = 1000061000, - VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN = 1000062000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT = 1000067000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT = 1000067001, - VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT = 1000068000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT = 1000068001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT = 1000068002, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073000, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR = 1000073001, - VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR = 1000073002, - VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR = 1000073003, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR = 1000074000, - VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR = 1000074001, - VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR = 1000074002, - VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR = 1000075000, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078000, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR = 1000078001, - VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR = 1000078002, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR = 1000078003, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR = 1000079000, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR = 1000079001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR = 1000080000, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT = 1000081000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT = 1000081001, - VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT = 1000081002, - VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR = 1000084000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV = 1000087000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT = 1000090000, - VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT = 1000091000, - VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT = 1000091001, - VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT = 1000091002, - VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT = 1000091003, - VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE = 1000092000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX = 1000097000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV = 1000098000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT = 1000099000, - VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT = 1000099001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT = 1000101000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT = 1000101001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT = 1000102000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT = 1000102001, - VK_STRUCTURE_TYPE_HDR_METADATA_EXT = 1000105000, - VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR = 1000111000, - VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114000, - VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR = 1000114001, - VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR = 1000114002, - VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR = 1000115000, - VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR = 1000115001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR = 1000116000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR = 1000116001, - VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR = 1000116002, - VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR = 1000116003, - VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR = 1000116004, - VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR = 1000116005, - VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR = 1000116006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR = 1000119000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR = 1000119001, - VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR = 1000119002, - VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR = 1000121000, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR = 1000121001, - VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR = 1000121002, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR = 1000121003, - VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR = 1000121004, - VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK = 1000122000, - VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK = 1000123000, - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT = 1000128000, - VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT = 1000128001, - VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT = 1000128002, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT = 1000128003, - VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT = 1000128004, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID = 1000129000, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID = 1000129001, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID = 1000129002, - VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129003, - VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID = 1000129004, - VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID = 1000129005, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_2_ANDROID = 1000129006, -# 664 "/usr/include/vulkan/vulkan_core.h" 3 4 - VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT = 1000143000, - VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT = 1000143001, - VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT = 1000143002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT = 1000143003, - VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT = 1000143004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT = 1000148000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT = 1000148001, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT = 1000148002, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV = 1000149000, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR = 1000150007, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR = 1000150000, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR = 1000150002, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR = 1000150003, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR = 1000150004, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR = 1000150005, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR = 1000150006, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR = 1000150009, - VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR = 1000150010, - VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR = 1000150011, - VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR = 1000150012, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR = 1000150013, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR = 1000150014, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR = 1000150017, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR = 1000150020, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR = 1000347000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR = 1000347001, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR = 1000150015, - VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR = 1000150016, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR = 1000150018, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR = 1000348013, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV = 1000152000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV = 1000154000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV = 1000154001, - VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT = 1000158000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT = 1000158002, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT = 1000158003, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT = 1000158004, - VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT = 1000158005, - VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT = 1000158006, - VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160000, - VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT = 1000160001, - - - - - - - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV = 1000164000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV = 1000164001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV = 1000164002, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV = 1000164005, - VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV = 1000165000, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV = 1000165001, - VK_STRUCTURE_TYPE_GEOMETRY_NV = 1000165003, - VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV = 1000165004, - VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV = 1000165005, - VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV = 1000165006, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV = 1000165007, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV = 1000165008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV = 1000165009, - VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV = 1000165011, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV = 1000165012, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV = 1000166000, - VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV = 1000166001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT = 1000170000, - VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT = 1000170001, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT = 1000178000, - VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT = 1000178001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT = 1000178002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR = 1000181000, - VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD = 1000183000, - VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT = 1000184000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD = 1000185000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_KHR = 1000187000, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_KHR = 1000187001, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_KHR = 1000187002, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_KHR = 1000187003, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_KHR = 1000187004, - VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_KHR = 1000187005, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR = 1000174000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR = 1000388000, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR = 1000388001, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD = 1000189000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT = 1000190000, - VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT = 1000190001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT = 1000190002, - VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP = 1000191000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV = 1000201000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV = 1000202000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV = 1000202001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV = 1000204000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV = 1000205000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV = 1000205002, - VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV = 1000206000, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV = 1000206001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL = 1000209000, - VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL = 1000210000, - VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL = 1000210001, - VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL = 1000210002, - VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL = 1000210003, - VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL = 1000210004, - VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL = 1000210005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT = 1000212000, - VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD = 1000213000, - VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD = 1000213001, - VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA = 1000214000, - VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT = 1000217000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT = 1000218000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT = 1000218001, - VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT = 1000218002, - VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR = 1000226000, - VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR = 1000226001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR = 1000226002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR = 1000226003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR = 1000226004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD = 1000227000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD = 1000229000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT = 1000234000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT = 1000237000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT = 1000238000, - VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT = 1000238001, - VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR = 1000239000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV = 1000240000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT = 1000244000, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT = 1000244002, - VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT = 1000247000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR = 1000248000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV = 1000249000, - VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV = 1000249002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV = 1000250000, - VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV = 1000250001, - VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV = 1000250002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT = 1000251000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT = 1000252000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT = 1000254000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT = 1000254001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT = 1000254002, - VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT = 1000255000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT = 1000255002, - VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_WIN32_INFO_EXT = 1000255001, - VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT = 1000256000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT = 1000259000, - VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT = 1000259001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT = 1000259002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT = 1000260000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT = 1000265000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT = 1000267000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR = 1000269000, - VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR = 1000269001, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR = 1000269002, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR = 1000269003, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR = 1000269004, - VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR = 1000269005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_FEATURES_EXT = 1000270000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_IMAGE_COPY_PROPERTIES_EXT = 1000270001, - VK_STRUCTURE_TYPE_MEMORY_TO_IMAGE_COPY_EXT = 1000270002, - VK_STRUCTURE_TYPE_IMAGE_TO_MEMORY_COPY_EXT = 1000270003, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_MEMORY_INFO_EXT = 1000270004, - VK_STRUCTURE_TYPE_COPY_MEMORY_TO_IMAGE_INFO_EXT = 1000270005, - VK_STRUCTURE_TYPE_HOST_IMAGE_LAYOUT_TRANSITION_INFO_EXT = 1000270006, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_IMAGE_INFO_EXT = 1000270007, - VK_STRUCTURE_TYPE_SUBRESOURCE_HOST_MEMCPY_SIZE_EXT = 1000270008, - VK_STRUCTURE_TYPE_HOST_IMAGE_COPY_DEVICE_PERFORMANCE_QUERY_EXT = 1000270009, - VK_STRUCTURE_TYPE_MEMORY_MAP_INFO_KHR = 1000271000, - VK_STRUCTURE_TYPE_MEMORY_UNMAP_INFO_KHR = 1000271001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT = 1000273000, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_EXT = 1000274000, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_SCALING_CAPABILITIES_EXT = 1000274001, - VK_STRUCTURE_TYPE_SURFACE_PRESENT_MODE_COMPATIBILITY_EXT = 1000274002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SWAPCHAIN_MAINTENANCE_1_FEATURES_EXT = 1000275000, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_FENCE_INFO_EXT = 1000275001, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODES_CREATE_INFO_EXT = 1000275002, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_MODE_INFO_EXT = 1000275003, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_SCALING_CREATE_INFO_EXT = 1000275004, - VK_STRUCTURE_TYPE_RELEASE_SWAPCHAIN_IMAGES_INFO_EXT = 1000275005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV = 1000277000, - VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV = 1000277001, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV = 1000277002, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV = 1000277003, - VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV = 1000277004, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV = 1000277005, - VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV = 1000277006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV = 1000277007, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV = 1000278000, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV = 1000278001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT = 1000281000, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM = 1000282000, - VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM = 1000282001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_BIAS_CONTROL_FEATURES_EXT = 1000283000, - VK_STRUCTURE_TYPE_DEPTH_BIAS_INFO_EXT = 1000283001, - VK_STRUCTURE_TYPE_DEPTH_BIAS_REPRESENTATION_INFO_EXT = 1000283002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT = 1000284000, - VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT = 1000284001, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT = 1000284002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT = 1000286000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT = 1000286001, - VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT = 1000287000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT = 1000287001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT = 1000287002, - VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR = 1000290000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_BARRIER_FEATURES_NV = 1000292000, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_PRESENT_BARRIER_NV = 1000292001, - VK_STRUCTURE_TYPE_SWAPCHAIN_PRESENT_BARRIER_CREATE_INFO_NV = 1000292002, - VK_STRUCTURE_TYPE_PRESENT_ID_KHR = 1000294000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR = 1000294001, -# 903 "/usr/include/vulkan/vulkan_core.h" 3 4 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV = 1000300000, - VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV = 1000300001, - VK_STRUCTURE_TYPE_CUDA_MODULE_CREATE_INFO_NV = 1000307000, - VK_STRUCTURE_TYPE_CUDA_FUNCTION_CREATE_INFO_NV = 1000307001, - VK_STRUCTURE_TYPE_CUDA_LAUNCH_INFO_NV = 1000307002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_FEATURES_NV = 1000307003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUDA_KERNEL_LAUNCH_PROPERTIES_NV = 1000307004, - VK_STRUCTURE_TYPE_QUERY_LOW_LATENCY_SUPPORT_NV = 1000310000, - VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT = 1000311000, - VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT = 1000311001, - VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT = 1000311002, - VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT = 1000311003, - VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT = 1000311004, - VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT = 1000311005, - VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT = 1000311006, - VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT = 1000311007, - VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT = 1000311008, - VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT = 1000311009, - VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311010, - VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT = 1000311011, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV = 1000314008, - VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV = 1000314009, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_PROPERTIES_EXT = 1000316000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_DENSITY_MAP_PROPERTIES_EXT = 1000316001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_BUFFER_FEATURES_EXT = 1000316002, - VK_STRUCTURE_TYPE_DESCRIPTOR_ADDRESS_INFO_EXT = 1000316003, - VK_STRUCTURE_TYPE_DESCRIPTOR_GET_INFO_EXT = 1000316004, - VK_STRUCTURE_TYPE_BUFFER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316005, - VK_STRUCTURE_TYPE_IMAGE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316006, - VK_STRUCTURE_TYPE_IMAGE_VIEW_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316007, - VK_STRUCTURE_TYPE_SAMPLER_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316008, - VK_STRUCTURE_TYPE_OPAQUE_CAPTURE_DESCRIPTOR_DATA_CREATE_INFO_EXT = 1000316010, - VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_INFO_EXT = 1000316011, - VK_STRUCTURE_TYPE_DESCRIPTOR_BUFFER_BINDING_PUSH_DESCRIPTOR_BUFFER_HANDLE_EXT = 1000316012, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CAPTURE_DESCRIPTOR_DATA_INFO_EXT = 1000316009, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT = 1000320000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT = 1000320001, - VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT = 1000320002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD = 1000321000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR = 1000203000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR = 1000322000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR = 1000323000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV = 1000326000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV = 1000326001, - VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV = 1000326002, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV = 1000327000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV = 1000327001, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV = 1000327002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_EXT = 1000328000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_EXT = 1000328001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT = 1000330000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT = 1000332000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT = 1000332001, - VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM = 1000333000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR = 1000336000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT = 1000338000, - VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT = 1000338001, - VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT = 1000338004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_FEATURES_EXT = 1000339000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT = 1000340000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FAULT_FEATURES_EXT = 1000341000, - VK_STRUCTURE_TYPE_DEVICE_FAULT_COUNTS_EXT = 1000341001, - VK_STRUCTURE_TYPE_DEVICE_FAULT_INFO_EXT = 1000341002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT = 1000344000, - VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT = 1000346000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT = 1000352000, - VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT = 1000352001, - VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT = 1000352002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT = 1000353000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ADDRESS_BINDING_REPORT_FEATURES_EXT = 1000354000, - VK_STRUCTURE_TYPE_DEVICE_ADDRESS_BINDING_CALLBACK_DATA_EXT = 1000354001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT = 1000355000, - VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT = 1000355001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT = 1000356000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364000, - VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA = 1000364001, - VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000364002, - VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365000, - VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA = 1000365001, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA = 1000366000, - VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA = 1000366001, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA = 1000366002, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA = 1000366003, - VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA = 1000366004, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA = 1000366005, - VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA = 1000366006, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA = 1000366007, - VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA = 1000366008, - VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA = 1000366009, - VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI = 1000369000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI = 1000369001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI = 1000369002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI = 1000370000, - VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV = 1000371000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV = 1000371001, - VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT = 1000372000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT = 1000372001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAME_BOUNDARY_FEATURES_EXT = 1000375000, - VK_STRUCTURE_TYPE_FRAME_BOUNDARY_EXT = 1000375001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT = 1000376000, - VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT = 1000376001, - VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT = 1000376002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT = 1000377000, - VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX = 1000378000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT = 1000381000, - VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT = 1000381001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT = 1000382000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR = 1000386000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT = 1000391000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT = 1000391001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT = 1000392000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT = 1000392001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT = 1000393000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_FEATURES_EXT = 1000395000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TILE_IMAGE_PROPERTIES_EXT = 1000395001, - VK_STRUCTURE_TYPE_MICROMAP_BUILD_INFO_EXT = 1000396000, - VK_STRUCTURE_TYPE_MICROMAP_VERSION_INFO_EXT = 1000396001, - VK_STRUCTURE_TYPE_COPY_MICROMAP_INFO_EXT = 1000396002, - VK_STRUCTURE_TYPE_COPY_MICROMAP_TO_MEMORY_INFO_EXT = 1000396003, - VK_STRUCTURE_TYPE_COPY_MEMORY_TO_MICROMAP_INFO_EXT = 1000396004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_FEATURES_EXT = 1000396005, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPACITY_MICROMAP_PROPERTIES_EXT = 1000396006, - VK_STRUCTURE_TYPE_MICROMAP_CREATE_INFO_EXT = 1000396007, - VK_STRUCTURE_TYPE_MICROMAP_BUILD_SIZES_INFO_EXT = 1000396008, - VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_TRIANGLES_OPACITY_MICROMAP_EXT = 1000396009, -# 1037 "/usr/include/vulkan/vulkan_core.h" 3 4 - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_FEATURES_HUAWEI = 1000404000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CLUSTER_CULLING_SHADER_PROPERTIES_HUAWEI = 1000404001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT = 1000411000, - VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT = 1000411001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT = 1000412000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_ARM = 1000415000, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_SHADER_CORE_CONTROL_CREATE_INFO_ARM = 1000417000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FEATURES_ARM = 1000417001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_PROPERTIES_ARM = 1000417002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_SLICED_VIEW_OF_3D_FEATURES_EXT = 1000418000, - VK_STRUCTURE_TYPE_IMAGE_VIEW_SLICED_CREATE_INFO_EXT = 1000418001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE = 1000420000, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE = 1000420001, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE = 1000420002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLAMP_ZERO_ONE_FEATURES_EXT = 1000421000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT = 1000422000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM = 1000425000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM = 1000425001, - VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM = 1000425002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_FEATURES_NV = 1000426000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COPY_MEMORY_INDIRECT_PROPERTIES_NV = 1000426001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_FEATURES_NV = 1000427000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_DECOMPRESSION_PROPERTIES_NV = 1000427001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_COMPUTE_FEATURES_NV = 1000428000, - VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_INDIRECT_BUFFER_INFO_NV = 1000428001, - VK_STRUCTURE_TYPE_PIPELINE_INDIRECT_DEVICE_ADDRESS_INFO_NV = 1000428002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV = 1000430000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT = 1000437000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_FEATURES_QCOM = 1000440000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_PROPERTIES_QCOM = 1000440001, - VK_STRUCTURE_TYPE_IMAGE_VIEW_SAMPLE_WEIGHT_CREATE_INFO_QCOM = 1000440002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_FEATURES_EXT = 1000451000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NESTED_COMMAND_BUFFER_PROPERTIES_EXT = 1000451001, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_ACQUIRE_UNMODIFIED_EXT = 1000453000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT = 1000455000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_PROPERTIES_EXT = 1000455001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT = 1000458000, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT = 1000458001, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT = 1000458002, - VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT = 1000458003, - VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_INFO_LUNARG = 1000459000, - VK_STRUCTURE_TYPE_DIRECT_DRIVER_LOADING_LIST_LUNARG = 1000459001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT = 1000462000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT = 1000462001, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT = 1000462002, - VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT = 1000462003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT = 1000342000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_FEATURES_NV = 1000464000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_OPTICAL_FLOW_PROPERTIES_NV = 1000464001, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_INFO_NV = 1000464002, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_IMAGE_FORMAT_PROPERTIES_NV = 1000464003, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_INFO_NV = 1000464004, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_EXECUTE_INFO_NV = 1000464005, - VK_STRUCTURE_TYPE_OPTICAL_FLOW_SESSION_CREATE_PRIVATE_DATA_INFO_NV = 1000464010, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LEGACY_DITHERING_FEATURES_EXT = 1000465000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROTECTED_ACCESS_FEATURES_EXT = 1000466000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_FEATURES_ANDROID = 1000468000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468001, - VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_RESOLVE_PROPERTIES_ANDROID = 1000468002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_FEATURES_KHR = 1000470000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR = 1000470001, - VK_STRUCTURE_TYPE_RENDERING_AREA_INFO_KHR = 1000470003, - VK_STRUCTURE_TYPE_DEVICE_IMAGE_SUBRESOURCE_INFO_KHR = 1000470004, - VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR = 1000338002, - VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR = 1000338003, - VK_STRUCTURE_TYPE_PIPELINE_CREATE_FLAGS_2_CREATE_INFO_KHR = 1000470005, - VK_STRUCTURE_TYPE_BUFFER_USAGE_FLAGS_2_CREATE_INFO_KHR = 1000470006, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_POSITION_FETCH_FEATURES_KHR = 1000481000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_FEATURES_EXT = 1000482000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_OBJECT_PROPERTIES_EXT = 1000482001, - VK_STRUCTURE_TYPE_SHADER_CREATE_INFO_EXT = 1000482002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TILE_PROPERTIES_FEATURES_QCOM = 1000484000, - VK_STRUCTURE_TYPE_TILE_PROPERTIES_QCOM = 1000484001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_AMIGO_PROFILING_FEATURES_SEC = 1000485000, - VK_STRUCTURE_TYPE_AMIGO_PROFILING_SUBMIT_INFO_SEC = 1000485001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_VIEWPORTS_FEATURES_QCOM = 1000488000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_FEATURES_NV = 1000490000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_INVOCATION_REORDER_PROPERTIES_NV = 1000490001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_FEATURES_NV = 1000492000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_SPARSE_ADDRESS_SPACE_PROPERTIES_NV = 1000492001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT = 1000351000, - VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT = 1000351002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_FEATURES_ARM = 1000497000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_BUILTINS_PROPERTIES_ARM = 1000497001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_LIBRARY_GROUP_HANDLES_FEATURES_EXT = 1000498000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_UNUSED_ATTACHMENTS_FEATURES_EXT = 1000499000, - VK_STRUCTURE_TYPE_LATENCY_SLEEP_MODE_INFO_NV = 1000505000, - VK_STRUCTURE_TYPE_LATENCY_SLEEP_INFO_NV = 1000505001, - VK_STRUCTURE_TYPE_SET_LATENCY_MARKER_INFO_NV = 1000505002, - VK_STRUCTURE_TYPE_GET_LATENCY_MARKER_INFO_NV = 1000505003, - VK_STRUCTURE_TYPE_LATENCY_TIMINGS_FRAME_REPORT_NV = 1000505004, - VK_STRUCTURE_TYPE_LATENCY_SUBMISSION_PRESENT_ID_NV = 1000505005, - VK_STRUCTURE_TYPE_OUT_OF_BAND_QUEUE_TYPE_INFO_NV = 1000505006, - VK_STRUCTURE_TYPE_SWAPCHAIN_LATENCY_CREATE_INFO_NV = 1000505007, - VK_STRUCTURE_TYPE_LATENCY_SURFACE_CAPABILITIES_NV = 1000505008, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_KHR = 1000506000, - VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_KHR = 1000506002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_RENDER_AREAS_FEATURES_QCOM = 1000510000, - VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_RENDER_AREAS_RENDER_PASS_BEGIN_INFO_QCOM = 1000510001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_FEATURES_QCOM = 1000518000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_PROCESSING_2_PROPERTIES_QCOM = 1000518001, - VK_STRUCTURE_TYPE_SAMPLER_BLOCK_MATCH_WINDOW_CREATE_INFO_QCOM = 1000518002, - VK_STRUCTURE_TYPE_SAMPLER_CUBIC_WEIGHTS_CREATE_INFO_QCOM = 1000519000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_WEIGHTS_FEATURES_QCOM = 1000519001, - VK_STRUCTURE_TYPE_BLIT_IMAGE_CUBIC_WEIGHTS_INFO_QCOM = 1000519002, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_DEGAMMA_FEATURES_QCOM = 1000520000, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_YCBCR_DEGAMMA_CREATE_INFO_QCOM = 1000520001, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUBIC_CLAMP_FEATURES_QCOM = 1000521000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_FEATURES_EXT = 1000524000, - VK_STRUCTURE_TYPE_SCREEN_BUFFER_PROPERTIES_QNX = 1000529000, - VK_STRUCTURE_TYPE_SCREEN_BUFFER_FORMAT_PROPERTIES_QNX = 1000529001, - VK_STRUCTURE_TYPE_IMPORT_SCREEN_BUFFER_INFO_QNX = 1000529002, - VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_QNX = 1000529003, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_SCREEN_BUFFER_FEATURES_QNX = 1000529004, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LAYERED_DRIVER_PROPERTIES_MSFT = 1000530000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_POOL_OVERALLOCATION_FEATURES_NV = 1000546000, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETER_FEATURES = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, - VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT, - VK_STRUCTURE_TYPE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_INFO, - VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO, - VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO, - VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_NV = VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD, - VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2, - VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO, - VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES, - VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES, - VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT16_INT8_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, - VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO, - VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES2_EXT = VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO, - VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO_KHR = VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO, - VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2, - VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2_KHR = VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, - VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2, - VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO, - VK_STRUCTURE_TYPE_SUBPASS_END_INFO_KHR = VK_STRUCTURE_TYPE_SUBPASS_END_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO, - VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES, - VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, - VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO, - VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES_KHR, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, - VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES, - VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES, - VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK, - VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2_KHR = VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2, - VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, - VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2_KHR = VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2, - VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO, - VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR = VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, - VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES, - VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO, - VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR = VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT_EXT = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES, - VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT_KHR = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT, - VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, - VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES, - VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE_KHR = VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES, - VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO, - VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, - VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO, - VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, - VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO_INTEL = VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES, - VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, - VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT, - VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT_KHR = VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_ADDRESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES, - VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, - VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO, - VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO_KHR = VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO, - VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO_KHR = VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO, - VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO_KHR = VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES, - VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO, - VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES, - VK_STRUCTURE_TYPE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_MEMORY_BARRIER_2, - VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2, - VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2_KHR = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2, - VK_STRUCTURE_TYPE_DEPENDENCY_INFO_KHR = VK_STRUCTURE_TYPE_DEPENDENCY_INFO, - VK_STRUCTURE_TYPE_SUBMIT_INFO_2_KHR = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, - VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, - VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO_KHR = VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES, - VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2, - VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2, - VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2, - VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2_KHR = VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2, - VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2, - VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2_KHR = VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2, - VK_STRUCTURE_TYPE_BUFFER_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_COPY_2, - VK_STRUCTURE_TYPE_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_IMAGE_COPY_2, - VK_STRUCTURE_TYPE_IMAGE_BLIT_2_KHR = VK_STRUCTURE_TYPE_IMAGE_BLIT_2, - VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2_KHR = VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2, - VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2_KHR = VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2, - VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT = VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_KHR, - VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT = VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_ARM = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_FEATURES_EXT, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_EXT, - VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE = VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_EXT, - VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3_KHR = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3, - VK_STRUCTURE_TYPE_PIPELINE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_EXT = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR, - VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_EXT = VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES, - VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES_KHR = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES, - VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS, - VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS_KHR = VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS, - VK_STRUCTURE_TYPE_SHADER_REQUIRED_SUBGROUP_SIZE_CREATE_INFO_EXT = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO, - VK_STRUCTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkStructureType; - -typedef enum VkPipelineCacheHeaderVersion { - VK_PIPELINE_CACHE_HEADER_VERSION_ONE = 1, - VK_PIPELINE_CACHE_HEADER_VERSION_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCacheHeaderVersion; - -typedef enum VkImageLayout { - VK_IMAGE_LAYOUT_UNDEFINED = 0, - VK_IMAGE_LAYOUT_GENERAL = 1, - VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL = 2, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL = 3, - VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL = 4, - VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL = 5, - VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL = 6, - VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL = 7, - VK_IMAGE_LAYOUT_PREINITIALIZED = 8, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL = 1000117000, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL = 1000117001, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL = 1000241000, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL = 1000241001, - VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL = 1000241002, - VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL = 1000241003, - VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL = 1000314000, - VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL = 1000314001, - VK_IMAGE_LAYOUT_PRESENT_SRC_KHR = 1000001002, - VK_IMAGE_LAYOUT_VIDEO_DECODE_DST_KHR = 1000024000, - VK_IMAGE_LAYOUT_VIDEO_DECODE_SRC_KHR = 1000024001, - VK_IMAGE_LAYOUT_VIDEO_DECODE_DPB_KHR = 1000024002, - VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR = 1000111000, - VK_IMAGE_LAYOUT_FRAGMENT_DENSITY_MAP_OPTIMAL_EXT = 1000218000, - VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR = 1000164003, -# 1372 "/usr/include/vulkan/vulkan_core.h" 3 4 - VK_IMAGE_LAYOUT_ATTACHMENT_FEEDBACK_LOOP_OPTIMAL_EXT = 1000339000, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_SHADING_RATE_OPTIMAL_NV = VK_IMAGE_LAYOUT_FRAGMENT_SHADING_RATE_ATTACHMENT_OPTIMAL_KHR, - VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_STENCIL_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL_KHR = VK_IMAGE_LAYOUT_READ_ONLY_OPTIMAL, - VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL, - VK_IMAGE_LAYOUT_MAX_ENUM = 0x7FFFFFFF -} VkImageLayout; - -typedef enum VkObjectType { - VK_OBJECT_TYPE_UNKNOWN = 0, - VK_OBJECT_TYPE_INSTANCE = 1, - VK_OBJECT_TYPE_PHYSICAL_DEVICE = 2, - VK_OBJECT_TYPE_DEVICE = 3, - VK_OBJECT_TYPE_QUEUE = 4, - VK_OBJECT_TYPE_SEMAPHORE = 5, - VK_OBJECT_TYPE_COMMAND_BUFFER = 6, - VK_OBJECT_TYPE_FENCE = 7, - VK_OBJECT_TYPE_DEVICE_MEMORY = 8, - VK_OBJECT_TYPE_BUFFER = 9, - VK_OBJECT_TYPE_IMAGE = 10, - VK_OBJECT_TYPE_EVENT = 11, - VK_OBJECT_TYPE_QUERY_POOL = 12, - VK_OBJECT_TYPE_BUFFER_VIEW = 13, - VK_OBJECT_TYPE_IMAGE_VIEW = 14, - VK_OBJECT_TYPE_SHADER_MODULE = 15, - VK_OBJECT_TYPE_PIPELINE_CACHE = 16, - VK_OBJECT_TYPE_PIPELINE_LAYOUT = 17, - VK_OBJECT_TYPE_RENDER_PASS = 18, - VK_OBJECT_TYPE_PIPELINE = 19, - VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT = 20, - VK_OBJECT_TYPE_SAMPLER = 21, - VK_OBJECT_TYPE_DESCRIPTOR_POOL = 22, - VK_OBJECT_TYPE_DESCRIPTOR_SET = 23, - VK_OBJECT_TYPE_FRAMEBUFFER = 24, - VK_OBJECT_TYPE_COMMAND_POOL = 25, - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION = 1000156000, - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE = 1000085000, - VK_OBJECT_TYPE_PRIVATE_DATA_SLOT = 1000295000, - VK_OBJECT_TYPE_SURFACE_KHR = 1000000000, - VK_OBJECT_TYPE_SWAPCHAIN_KHR = 1000001000, - VK_OBJECT_TYPE_DISPLAY_KHR = 1000002000, - VK_OBJECT_TYPE_DISPLAY_MODE_KHR = 1000002001, - VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT = 1000011000, - VK_OBJECT_TYPE_VIDEO_SESSION_KHR = 1000023000, - VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR = 1000023001, - VK_OBJECT_TYPE_CU_MODULE_NVX = 1000029000, - VK_OBJECT_TYPE_CU_FUNCTION_NVX = 1000029001, - VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT = 1000128000, - VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, - VK_OBJECT_TYPE_VALIDATION_CACHE_EXT = 1000160000, - VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, - VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL = 1000210000, - VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR = 1000268000, - VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV = 1000277000, - VK_OBJECT_TYPE_CUDA_MODULE_NV = 1000307000, - VK_OBJECT_TYPE_CUDA_FUNCTION_NV = 1000307001, - VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA = 1000366000, - VK_OBJECT_TYPE_MICROMAP_EXT = 1000396000, - VK_OBJECT_TYPE_OPTICAL_FLOW_SESSION_NV = 1000464000, - VK_OBJECT_TYPE_SHADER_EXT = 1000482000, - VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE, - VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION, - VK_OBJECT_TYPE_PRIVATE_DATA_SLOT_EXT = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT, - VK_OBJECT_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkObjectType; - -typedef enum VkVendorId { - VK_VENDOR_ID_VIV = 0x10001, - VK_VENDOR_ID_VSI = 0x10002, - VK_VENDOR_ID_KAZAN = 0x10003, - VK_VENDOR_ID_CODEPLAY = 0x10004, - VK_VENDOR_ID_MESA = 0x10005, - VK_VENDOR_ID_POCL = 0x10006, - VK_VENDOR_ID_MOBILEYE = 0x10007, - VK_VENDOR_ID_MAX_ENUM = 0x7FFFFFFF -} VkVendorId; - -typedef enum VkSystemAllocationScope { - VK_SYSTEM_ALLOCATION_SCOPE_COMMAND = 0, - VK_SYSTEM_ALLOCATION_SCOPE_OBJECT = 1, - VK_SYSTEM_ALLOCATION_SCOPE_CACHE = 2, - VK_SYSTEM_ALLOCATION_SCOPE_DEVICE = 3, - VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE = 4, - VK_SYSTEM_ALLOCATION_SCOPE_MAX_ENUM = 0x7FFFFFFF -} VkSystemAllocationScope; - -typedef enum VkInternalAllocationType { - VK_INTERNAL_ALLOCATION_TYPE_EXECUTABLE = 0, - VK_INTERNAL_ALLOCATION_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkInternalAllocationType; - -typedef enum VkFormat { - VK_FORMAT_UNDEFINED = 0, - VK_FORMAT_R4G4_UNORM_PACK8 = 1, - VK_FORMAT_R4G4B4A4_UNORM_PACK16 = 2, - VK_FORMAT_B4G4R4A4_UNORM_PACK16 = 3, - VK_FORMAT_R5G6B5_UNORM_PACK16 = 4, - VK_FORMAT_B5G6R5_UNORM_PACK16 = 5, - VK_FORMAT_R5G5B5A1_UNORM_PACK16 = 6, - VK_FORMAT_B5G5R5A1_UNORM_PACK16 = 7, - VK_FORMAT_A1R5G5B5_UNORM_PACK16 = 8, - VK_FORMAT_R8_UNORM = 9, - VK_FORMAT_R8_SNORM = 10, - VK_FORMAT_R8_USCALED = 11, - VK_FORMAT_R8_SSCALED = 12, - VK_FORMAT_R8_UINT = 13, - VK_FORMAT_R8_SINT = 14, - VK_FORMAT_R8_SRGB = 15, - VK_FORMAT_R8G8_UNORM = 16, - VK_FORMAT_R8G8_SNORM = 17, - VK_FORMAT_R8G8_USCALED = 18, - VK_FORMAT_R8G8_SSCALED = 19, - VK_FORMAT_R8G8_UINT = 20, - VK_FORMAT_R8G8_SINT = 21, - VK_FORMAT_R8G8_SRGB = 22, - VK_FORMAT_R8G8B8_UNORM = 23, - VK_FORMAT_R8G8B8_SNORM = 24, - VK_FORMAT_R8G8B8_USCALED = 25, - VK_FORMAT_R8G8B8_SSCALED = 26, - VK_FORMAT_R8G8B8_UINT = 27, - VK_FORMAT_R8G8B8_SINT = 28, - VK_FORMAT_R8G8B8_SRGB = 29, - VK_FORMAT_B8G8R8_UNORM = 30, - VK_FORMAT_B8G8R8_SNORM = 31, - VK_FORMAT_B8G8R8_USCALED = 32, - VK_FORMAT_B8G8R8_SSCALED = 33, - VK_FORMAT_B8G8R8_UINT = 34, - VK_FORMAT_B8G8R8_SINT = 35, - VK_FORMAT_B8G8R8_SRGB = 36, - VK_FORMAT_R8G8B8A8_UNORM = 37, - VK_FORMAT_R8G8B8A8_SNORM = 38, - VK_FORMAT_R8G8B8A8_USCALED = 39, - VK_FORMAT_R8G8B8A8_SSCALED = 40, - VK_FORMAT_R8G8B8A8_UINT = 41, - VK_FORMAT_R8G8B8A8_SINT = 42, - VK_FORMAT_R8G8B8A8_SRGB = 43, - VK_FORMAT_B8G8R8A8_UNORM = 44, - VK_FORMAT_B8G8R8A8_SNORM = 45, - VK_FORMAT_B8G8R8A8_USCALED = 46, - VK_FORMAT_B8G8R8A8_SSCALED = 47, - VK_FORMAT_B8G8R8A8_UINT = 48, - VK_FORMAT_B8G8R8A8_SINT = 49, - VK_FORMAT_B8G8R8A8_SRGB = 50, - VK_FORMAT_A8B8G8R8_UNORM_PACK32 = 51, - VK_FORMAT_A8B8G8R8_SNORM_PACK32 = 52, - VK_FORMAT_A8B8G8R8_USCALED_PACK32 = 53, - VK_FORMAT_A8B8G8R8_SSCALED_PACK32 = 54, - VK_FORMAT_A8B8G8R8_UINT_PACK32 = 55, - VK_FORMAT_A8B8G8R8_SINT_PACK32 = 56, - VK_FORMAT_A8B8G8R8_SRGB_PACK32 = 57, - VK_FORMAT_A2R10G10B10_UNORM_PACK32 = 58, - VK_FORMAT_A2R10G10B10_SNORM_PACK32 = 59, - VK_FORMAT_A2R10G10B10_USCALED_PACK32 = 60, - VK_FORMAT_A2R10G10B10_SSCALED_PACK32 = 61, - VK_FORMAT_A2R10G10B10_UINT_PACK32 = 62, - VK_FORMAT_A2R10G10B10_SINT_PACK32 = 63, - VK_FORMAT_A2B10G10R10_UNORM_PACK32 = 64, - VK_FORMAT_A2B10G10R10_SNORM_PACK32 = 65, - VK_FORMAT_A2B10G10R10_USCALED_PACK32 = 66, - VK_FORMAT_A2B10G10R10_SSCALED_PACK32 = 67, - VK_FORMAT_A2B10G10R10_UINT_PACK32 = 68, - VK_FORMAT_A2B10G10R10_SINT_PACK32 = 69, - VK_FORMAT_R16_UNORM = 70, - VK_FORMAT_R16_SNORM = 71, - VK_FORMAT_R16_USCALED = 72, - VK_FORMAT_R16_SSCALED = 73, - VK_FORMAT_R16_UINT = 74, - VK_FORMAT_R16_SINT = 75, - VK_FORMAT_R16_SFLOAT = 76, - VK_FORMAT_R16G16_UNORM = 77, - VK_FORMAT_R16G16_SNORM = 78, - VK_FORMAT_R16G16_USCALED = 79, - VK_FORMAT_R16G16_SSCALED = 80, - VK_FORMAT_R16G16_UINT = 81, - VK_FORMAT_R16G16_SINT = 82, - VK_FORMAT_R16G16_SFLOAT = 83, - VK_FORMAT_R16G16B16_UNORM = 84, - VK_FORMAT_R16G16B16_SNORM = 85, - VK_FORMAT_R16G16B16_USCALED = 86, - VK_FORMAT_R16G16B16_SSCALED = 87, - VK_FORMAT_R16G16B16_UINT = 88, - VK_FORMAT_R16G16B16_SINT = 89, - VK_FORMAT_R16G16B16_SFLOAT = 90, - VK_FORMAT_R16G16B16A16_UNORM = 91, - VK_FORMAT_R16G16B16A16_SNORM = 92, - VK_FORMAT_R16G16B16A16_USCALED = 93, - VK_FORMAT_R16G16B16A16_SSCALED = 94, - VK_FORMAT_R16G16B16A16_UINT = 95, - VK_FORMAT_R16G16B16A16_SINT = 96, - VK_FORMAT_R16G16B16A16_SFLOAT = 97, - VK_FORMAT_R32_UINT = 98, - VK_FORMAT_R32_SINT = 99, - VK_FORMAT_R32_SFLOAT = 100, - VK_FORMAT_R32G32_UINT = 101, - VK_FORMAT_R32G32_SINT = 102, - VK_FORMAT_R32G32_SFLOAT = 103, - VK_FORMAT_R32G32B32_UINT = 104, - VK_FORMAT_R32G32B32_SINT = 105, - VK_FORMAT_R32G32B32_SFLOAT = 106, - VK_FORMAT_R32G32B32A32_UINT = 107, - VK_FORMAT_R32G32B32A32_SINT = 108, - VK_FORMAT_R32G32B32A32_SFLOAT = 109, - VK_FORMAT_R64_UINT = 110, - VK_FORMAT_R64_SINT = 111, - VK_FORMAT_R64_SFLOAT = 112, - VK_FORMAT_R64G64_UINT = 113, - VK_FORMAT_R64G64_SINT = 114, - VK_FORMAT_R64G64_SFLOAT = 115, - VK_FORMAT_R64G64B64_UINT = 116, - VK_FORMAT_R64G64B64_SINT = 117, - VK_FORMAT_R64G64B64_SFLOAT = 118, - VK_FORMAT_R64G64B64A64_UINT = 119, - VK_FORMAT_R64G64B64A64_SINT = 120, - VK_FORMAT_R64G64B64A64_SFLOAT = 121, - VK_FORMAT_B10G11R11_UFLOAT_PACK32 = 122, - VK_FORMAT_E5B9G9R9_UFLOAT_PACK32 = 123, - VK_FORMAT_D16_UNORM = 124, - VK_FORMAT_X8_D24_UNORM_PACK32 = 125, - VK_FORMAT_D32_SFLOAT = 126, - VK_FORMAT_S8_UINT = 127, - VK_FORMAT_D16_UNORM_S8_UINT = 128, - VK_FORMAT_D24_UNORM_S8_UINT = 129, - VK_FORMAT_D32_SFLOAT_S8_UINT = 130, - VK_FORMAT_BC1_RGB_UNORM_BLOCK = 131, - VK_FORMAT_BC1_RGB_SRGB_BLOCK = 132, - VK_FORMAT_BC1_RGBA_UNORM_BLOCK = 133, - VK_FORMAT_BC1_RGBA_SRGB_BLOCK = 134, - VK_FORMAT_BC2_UNORM_BLOCK = 135, - VK_FORMAT_BC2_SRGB_BLOCK = 136, - VK_FORMAT_BC3_UNORM_BLOCK = 137, - VK_FORMAT_BC3_SRGB_BLOCK = 138, - VK_FORMAT_BC4_UNORM_BLOCK = 139, - VK_FORMAT_BC4_SNORM_BLOCK = 140, - VK_FORMAT_BC5_UNORM_BLOCK = 141, - VK_FORMAT_BC5_SNORM_BLOCK = 142, - VK_FORMAT_BC6H_UFLOAT_BLOCK = 143, - VK_FORMAT_BC6H_SFLOAT_BLOCK = 144, - VK_FORMAT_BC7_UNORM_BLOCK = 145, - VK_FORMAT_BC7_SRGB_BLOCK = 146, - VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK = 147, - VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK = 148, - VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK = 149, - VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK = 150, - VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK = 151, - VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK = 152, - VK_FORMAT_EAC_R11_UNORM_BLOCK = 153, - VK_FORMAT_EAC_R11_SNORM_BLOCK = 154, - VK_FORMAT_EAC_R11G11_UNORM_BLOCK = 155, - VK_FORMAT_EAC_R11G11_SNORM_BLOCK = 156, - VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157, - VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158, - VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159, - VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160, - VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161, - VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162, - VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163, - VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164, - VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165, - VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166, - VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167, - VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168, - VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169, - VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170, - VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171, - VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172, - VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173, - VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174, - VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175, - VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176, - VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177, - VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178, - VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179, - VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180, - VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181, - VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182, - VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183, - VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184, - VK_FORMAT_G8B8G8R8_422_UNORM = 1000156000, - VK_FORMAT_B8G8R8G8_422_UNORM = 1000156001, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM = 1000156002, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM = 1000156003, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM = 1000156004, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM = 1000156005, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM = 1000156006, - VK_FORMAT_R10X6_UNORM_PACK16 = 1000156007, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16 = 1000156008, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16 = 1000156009, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16 = 1000156010, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16 = 1000156011, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16 = 1000156012, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16 = 1000156013, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16 = 1000156014, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16 = 1000156015, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16 = 1000156016, - VK_FORMAT_R12X4_UNORM_PACK16 = 1000156017, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16 = 1000156018, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16 = 1000156019, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16 = 1000156020, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16 = 1000156021, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16 = 1000156022, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16 = 1000156023, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16 = 1000156024, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16 = 1000156025, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16 = 1000156026, - VK_FORMAT_G16B16G16R16_422_UNORM = 1000156027, - VK_FORMAT_B16G16R16G16_422_UNORM = 1000156028, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM = 1000156029, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM = 1000156030, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM = 1000156031, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM = 1000156032, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM = 1000156033, - VK_FORMAT_G8_B8R8_2PLANE_444_UNORM = 1000330000, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16 = 1000330001, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16 = 1000330002, - VK_FORMAT_G16_B16R16_2PLANE_444_UNORM = 1000330003, - VK_FORMAT_A4R4G4B4_UNORM_PACK16 = 1000340000, - VK_FORMAT_A4B4G4R4_UNORM_PACK16 = 1000340001, - VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK = 1000066000, - VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK = 1000066001, - VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK = 1000066002, - VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK = 1000066003, - VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK = 1000066004, - VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK = 1000066005, - VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK = 1000066006, - VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK = 1000066007, - VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK = 1000066008, - VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK = 1000066009, - VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK = 1000066010, - VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK = 1000066011, - VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK = 1000066012, - VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK = 1000066013, - VK_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG = 1000054000, - VK_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG = 1000054001, - VK_FORMAT_PVRTC2_2BPP_UNORM_BLOCK_IMG = 1000054002, - VK_FORMAT_PVRTC2_4BPP_UNORM_BLOCK_IMG = 1000054003, - VK_FORMAT_PVRTC1_2BPP_SRGB_BLOCK_IMG = 1000054004, - VK_FORMAT_PVRTC1_4BPP_SRGB_BLOCK_IMG = 1000054005, - VK_FORMAT_PVRTC2_2BPP_SRGB_BLOCK_IMG = 1000054006, - VK_FORMAT_PVRTC2_4BPP_SRGB_BLOCK_IMG = 1000054007, - VK_FORMAT_R16G16_S10_5_NV = 1000464000, - VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR = 1000470000, - VK_FORMAT_A8_UNORM_KHR = 1000470001, - VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK, - VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x4_SFLOAT_BLOCK, - VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_5x5_SFLOAT_BLOCK, - VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x5_SFLOAT_BLOCK, - VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_6x6_SFLOAT_BLOCK, - VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x5_SFLOAT_BLOCK, - VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x6_SFLOAT_BLOCK, - VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_8x8_SFLOAT_BLOCK, - VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x5_SFLOAT_BLOCK, - VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x6_SFLOAT_BLOCK, - VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x8_SFLOAT_BLOCK, - VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK, - VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK, - VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT = VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK, - VK_FORMAT_G8B8G8R8_422_UNORM_KHR = VK_FORMAT_G8B8G8R8_422_UNORM, - VK_FORMAT_B8G8R8G8_422_UNORM_KHR = VK_FORMAT_B8G8R8G8_422_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR = VK_FORMAT_G8_B8R8_2PLANE_422_UNORM, - VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR = VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM, - VK_FORMAT_R10X6_UNORM_PACK16_KHR = VK_FORMAT_R10X6_UNORM_PACK16, - VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR = VK_FORMAT_R10X6G10X6_UNORM_2PACK16, - VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16, - VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16, - VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR = VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16, - VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16, - VK_FORMAT_R12X4_UNORM_PACK16_KHR = VK_FORMAT_R12X4_UNORM_PACK16, - VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR = VK_FORMAT_R12X4G12X4_UNORM_2PACK16, - VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16, - VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16, - VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR = VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR = VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16, - VK_FORMAT_G16B16G16R16_422_UNORM_KHR = VK_FORMAT_G16B16G16R16_422_UNORM, - VK_FORMAT_B16G16R16G16_422_UNORM_KHR = VK_FORMAT_B16G16R16G16_422_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM, - VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_420_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM, - VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR = VK_FORMAT_G16_B16R16_2PLANE_422_UNORM, - VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR = VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM, - VK_FORMAT_G8_B8R8_2PLANE_444_UNORM_EXT = VK_FORMAT_G8_B8R8_2PLANE_444_UNORM, - VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G10X6_B10X6R10X6_2PLANE_444_UNORM_3PACK16, - VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16_EXT = VK_FORMAT_G12X4_B12X4R12X4_2PLANE_444_UNORM_3PACK16, - VK_FORMAT_G16_B16R16_2PLANE_444_UNORM_EXT = VK_FORMAT_G16_B16R16_2PLANE_444_UNORM, - VK_FORMAT_A4R4G4B4_UNORM_PACK16_EXT = VK_FORMAT_A4R4G4B4_UNORM_PACK16, - VK_FORMAT_A4B4G4R4_UNORM_PACK16_EXT = VK_FORMAT_A4B4G4R4_UNORM_PACK16, - VK_FORMAT_MAX_ENUM = 0x7FFFFFFF -} VkFormat; - -typedef enum VkImageTiling { - VK_IMAGE_TILING_OPTIMAL = 0, - VK_IMAGE_TILING_LINEAR = 1, - VK_IMAGE_TILING_DRM_FORMAT_MODIFIER_EXT = 1000158000, - VK_IMAGE_TILING_MAX_ENUM = 0x7FFFFFFF -} VkImageTiling; - -typedef enum VkImageType { - VK_IMAGE_TYPE_1D = 0, - VK_IMAGE_TYPE_2D = 1, - VK_IMAGE_TYPE_3D = 2, - VK_IMAGE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageType; - -typedef enum VkPhysicalDeviceType { - VK_PHYSICAL_DEVICE_TYPE_OTHER = 0, - VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU = 1, - VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU = 2, - VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU = 3, - VK_PHYSICAL_DEVICE_TYPE_CPU = 4, - VK_PHYSICAL_DEVICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkPhysicalDeviceType; - -typedef enum VkQueryType { - VK_QUERY_TYPE_OCCLUSION = 0, - VK_QUERY_TYPE_PIPELINE_STATISTICS = 1, - VK_QUERY_TYPE_TIMESTAMP = 2, - VK_QUERY_TYPE_RESULT_STATUS_ONLY_KHR = 1000023000, - VK_QUERY_TYPE_TRANSFORM_FEEDBACK_STREAM_EXT = 1000028004, - VK_QUERY_TYPE_PERFORMANCE_QUERY_KHR = 1000116000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_KHR = 1000150000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_SIZE_KHR = 1000150001, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_COMPACTED_SIZE_NV = 1000165000, - VK_QUERY_TYPE_PERFORMANCE_QUERY_INTEL = 1000210000, - - - - VK_QUERY_TYPE_MESH_PRIMITIVES_GENERATED_EXT = 1000328000, - VK_QUERY_TYPE_PRIMITIVES_GENERATED_EXT = 1000382000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SERIALIZATION_BOTTOM_LEVEL_POINTERS_KHR = 1000386000, - VK_QUERY_TYPE_ACCELERATION_STRUCTURE_SIZE_KHR = 1000386001, - VK_QUERY_TYPE_MICROMAP_SERIALIZATION_SIZE_EXT = 1000396000, - VK_QUERY_TYPE_MICROMAP_COMPACTED_SIZE_EXT = 1000396001, - VK_QUERY_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkQueryType; - -typedef enum VkSharingMode { - VK_SHARING_MODE_EXCLUSIVE = 0, - VK_SHARING_MODE_CONCURRENT = 1, - VK_SHARING_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSharingMode; - -typedef enum VkComponentSwizzle { - VK_COMPONENT_SWIZZLE_IDENTITY = 0, - VK_COMPONENT_SWIZZLE_ZERO = 1, - VK_COMPONENT_SWIZZLE_ONE = 2, - VK_COMPONENT_SWIZZLE_R = 3, - VK_COMPONENT_SWIZZLE_G = 4, - VK_COMPONENT_SWIZZLE_B = 5, - VK_COMPONENT_SWIZZLE_A = 6, - VK_COMPONENT_SWIZZLE_MAX_ENUM = 0x7FFFFFFF -} VkComponentSwizzle; - -typedef enum VkImageViewType { - VK_IMAGE_VIEW_TYPE_1D = 0, - VK_IMAGE_VIEW_TYPE_2D = 1, - VK_IMAGE_VIEW_TYPE_3D = 2, - VK_IMAGE_VIEW_TYPE_CUBE = 3, - VK_IMAGE_VIEW_TYPE_1D_ARRAY = 4, - VK_IMAGE_VIEW_TYPE_2D_ARRAY = 5, - VK_IMAGE_VIEW_TYPE_CUBE_ARRAY = 6, - VK_IMAGE_VIEW_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkImageViewType; - -typedef enum VkBlendFactor { - VK_BLEND_FACTOR_ZERO = 0, - VK_BLEND_FACTOR_ONE = 1, - VK_BLEND_FACTOR_SRC_COLOR = 2, - VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR = 3, - VK_BLEND_FACTOR_DST_COLOR = 4, - VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR = 5, - VK_BLEND_FACTOR_SRC_ALPHA = 6, - VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA = 7, - VK_BLEND_FACTOR_DST_ALPHA = 8, - VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA = 9, - VK_BLEND_FACTOR_CONSTANT_COLOR = 10, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR = 11, - VK_BLEND_FACTOR_CONSTANT_ALPHA = 12, - VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_ALPHA = 13, - VK_BLEND_FACTOR_SRC_ALPHA_SATURATE = 14, - VK_BLEND_FACTOR_SRC1_COLOR = 15, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR = 16, - VK_BLEND_FACTOR_SRC1_ALPHA = 17, - VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA = 18, - VK_BLEND_FACTOR_MAX_ENUM = 0x7FFFFFFF -} VkBlendFactor; - -typedef enum VkBlendOp { - VK_BLEND_OP_ADD = 0, - VK_BLEND_OP_SUBTRACT = 1, - VK_BLEND_OP_REVERSE_SUBTRACT = 2, - VK_BLEND_OP_MIN = 3, - VK_BLEND_OP_MAX = 4, - VK_BLEND_OP_ZERO_EXT = 1000148000, - VK_BLEND_OP_SRC_EXT = 1000148001, - VK_BLEND_OP_DST_EXT = 1000148002, - VK_BLEND_OP_SRC_OVER_EXT = 1000148003, - VK_BLEND_OP_DST_OVER_EXT = 1000148004, - VK_BLEND_OP_SRC_IN_EXT = 1000148005, - VK_BLEND_OP_DST_IN_EXT = 1000148006, - VK_BLEND_OP_SRC_OUT_EXT = 1000148007, - VK_BLEND_OP_DST_OUT_EXT = 1000148008, - VK_BLEND_OP_SRC_ATOP_EXT = 1000148009, - VK_BLEND_OP_DST_ATOP_EXT = 1000148010, - VK_BLEND_OP_XOR_EXT = 1000148011, - VK_BLEND_OP_MULTIPLY_EXT = 1000148012, - VK_BLEND_OP_SCREEN_EXT = 1000148013, - VK_BLEND_OP_OVERLAY_EXT = 1000148014, - VK_BLEND_OP_DARKEN_EXT = 1000148015, - VK_BLEND_OP_LIGHTEN_EXT = 1000148016, - VK_BLEND_OP_COLORDODGE_EXT = 1000148017, - VK_BLEND_OP_COLORBURN_EXT = 1000148018, - VK_BLEND_OP_HARDLIGHT_EXT = 1000148019, - VK_BLEND_OP_SOFTLIGHT_EXT = 1000148020, - VK_BLEND_OP_DIFFERENCE_EXT = 1000148021, - VK_BLEND_OP_EXCLUSION_EXT = 1000148022, - VK_BLEND_OP_INVERT_EXT = 1000148023, - VK_BLEND_OP_INVERT_RGB_EXT = 1000148024, - VK_BLEND_OP_LINEARDODGE_EXT = 1000148025, - VK_BLEND_OP_LINEARBURN_EXT = 1000148026, - VK_BLEND_OP_VIVIDLIGHT_EXT = 1000148027, - VK_BLEND_OP_LINEARLIGHT_EXT = 1000148028, - VK_BLEND_OP_PINLIGHT_EXT = 1000148029, - VK_BLEND_OP_HARDMIX_EXT = 1000148030, - VK_BLEND_OP_HSL_HUE_EXT = 1000148031, - VK_BLEND_OP_HSL_SATURATION_EXT = 1000148032, - VK_BLEND_OP_HSL_COLOR_EXT = 1000148033, - VK_BLEND_OP_HSL_LUMINOSITY_EXT = 1000148034, - VK_BLEND_OP_PLUS_EXT = 1000148035, - VK_BLEND_OP_PLUS_CLAMPED_EXT = 1000148036, - VK_BLEND_OP_PLUS_CLAMPED_ALPHA_EXT = 1000148037, - VK_BLEND_OP_PLUS_DARKER_EXT = 1000148038, - VK_BLEND_OP_MINUS_EXT = 1000148039, - VK_BLEND_OP_MINUS_CLAMPED_EXT = 1000148040, - VK_BLEND_OP_CONTRAST_EXT = 1000148041, - VK_BLEND_OP_INVERT_OVG_EXT = 1000148042, - VK_BLEND_OP_RED_EXT = 1000148043, - VK_BLEND_OP_GREEN_EXT = 1000148044, - VK_BLEND_OP_BLUE_EXT = 1000148045, - VK_BLEND_OP_MAX_ENUM = 0x7FFFFFFF -} VkBlendOp; - -typedef enum VkCompareOp { - VK_COMPARE_OP_NEVER = 0, - VK_COMPARE_OP_LESS = 1, - VK_COMPARE_OP_EQUAL = 2, - VK_COMPARE_OP_LESS_OR_EQUAL = 3, - VK_COMPARE_OP_GREATER = 4, - VK_COMPARE_OP_NOT_EQUAL = 5, - VK_COMPARE_OP_GREATER_OR_EQUAL = 6, - VK_COMPARE_OP_ALWAYS = 7, - VK_COMPARE_OP_MAX_ENUM = 0x7FFFFFFF -} VkCompareOp; - -typedef enum VkDynamicState { - VK_DYNAMIC_STATE_VIEWPORT = 0, - VK_DYNAMIC_STATE_SCISSOR = 1, - VK_DYNAMIC_STATE_LINE_WIDTH = 2, - VK_DYNAMIC_STATE_DEPTH_BIAS = 3, - VK_DYNAMIC_STATE_BLEND_CONSTANTS = 4, - VK_DYNAMIC_STATE_DEPTH_BOUNDS = 5, - VK_DYNAMIC_STATE_STENCIL_COMPARE_MASK = 6, - VK_DYNAMIC_STATE_STENCIL_WRITE_MASK = 7, - VK_DYNAMIC_STATE_STENCIL_REFERENCE = 8, - VK_DYNAMIC_STATE_CULL_MODE = 1000267000, - VK_DYNAMIC_STATE_FRONT_FACE = 1000267001, - VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY = 1000267002, - VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT = 1000267003, - VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT = 1000267004, - VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE = 1000267005, - VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE = 1000267006, - VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE = 1000267007, - VK_DYNAMIC_STATE_DEPTH_COMPARE_OP = 1000267008, - VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE = 1000267009, - VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE = 1000267010, - VK_DYNAMIC_STATE_STENCIL_OP = 1000267011, - VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE = 1000377001, - VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE = 1000377002, - VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE = 1000377004, - VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_NV = 1000087000, - VK_DYNAMIC_STATE_DISCARD_RECTANGLE_EXT = 1000099000, - VK_DYNAMIC_STATE_DISCARD_RECTANGLE_ENABLE_EXT = 1000099001, - VK_DYNAMIC_STATE_DISCARD_RECTANGLE_MODE_EXT = 1000099002, - VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_EXT = 1000143000, - VK_DYNAMIC_STATE_RAY_TRACING_PIPELINE_STACK_SIZE_KHR = 1000347000, - VK_DYNAMIC_STATE_VIEWPORT_SHADING_RATE_PALETTE_NV = 1000164004, - VK_DYNAMIC_STATE_VIEWPORT_COARSE_SAMPLE_ORDER_NV = 1000164006, - VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_ENABLE_NV = 1000205000, - VK_DYNAMIC_STATE_EXCLUSIVE_SCISSOR_NV = 1000205001, - VK_DYNAMIC_STATE_FRAGMENT_SHADING_RATE_KHR = 1000226000, - VK_DYNAMIC_STATE_LINE_STIPPLE_EXT = 1000259000, - VK_DYNAMIC_STATE_VERTEX_INPUT_EXT = 1000352000, - VK_DYNAMIC_STATE_PATCH_CONTROL_POINTS_EXT = 1000377000, - VK_DYNAMIC_STATE_LOGIC_OP_EXT = 1000377003, - VK_DYNAMIC_STATE_COLOR_WRITE_ENABLE_EXT = 1000381000, - VK_DYNAMIC_STATE_TESSELLATION_DOMAIN_ORIGIN_EXT = 1000455002, - VK_DYNAMIC_STATE_DEPTH_CLAMP_ENABLE_EXT = 1000455003, - VK_DYNAMIC_STATE_POLYGON_MODE_EXT = 1000455004, - VK_DYNAMIC_STATE_RASTERIZATION_SAMPLES_EXT = 1000455005, - VK_DYNAMIC_STATE_SAMPLE_MASK_EXT = 1000455006, - VK_DYNAMIC_STATE_ALPHA_TO_COVERAGE_ENABLE_EXT = 1000455007, - VK_DYNAMIC_STATE_ALPHA_TO_ONE_ENABLE_EXT = 1000455008, - VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT = 1000455009, - VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT = 1000455010, - VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT = 1000455011, - VK_DYNAMIC_STATE_COLOR_WRITE_MASK_EXT = 1000455012, - VK_DYNAMIC_STATE_RASTERIZATION_STREAM_EXT = 1000455013, - VK_DYNAMIC_STATE_CONSERVATIVE_RASTERIZATION_MODE_EXT = 1000455014, - VK_DYNAMIC_STATE_EXTRA_PRIMITIVE_OVERESTIMATION_SIZE_EXT = 1000455015, - VK_DYNAMIC_STATE_DEPTH_CLIP_ENABLE_EXT = 1000455016, - VK_DYNAMIC_STATE_SAMPLE_LOCATIONS_ENABLE_EXT = 1000455017, - VK_DYNAMIC_STATE_COLOR_BLEND_ADVANCED_EXT = 1000455018, - VK_DYNAMIC_STATE_PROVOKING_VERTEX_MODE_EXT = 1000455019, - VK_DYNAMIC_STATE_LINE_RASTERIZATION_MODE_EXT = 1000455020, - VK_DYNAMIC_STATE_LINE_STIPPLE_ENABLE_EXT = 1000455021, - VK_DYNAMIC_STATE_DEPTH_CLIP_NEGATIVE_ONE_TO_ONE_EXT = 1000455022, - VK_DYNAMIC_STATE_VIEWPORT_W_SCALING_ENABLE_NV = 1000455023, - VK_DYNAMIC_STATE_VIEWPORT_SWIZZLE_NV = 1000455024, - VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_ENABLE_NV = 1000455025, - VK_DYNAMIC_STATE_COVERAGE_TO_COLOR_LOCATION_NV = 1000455026, - VK_DYNAMIC_STATE_COVERAGE_MODULATION_MODE_NV = 1000455027, - VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_ENABLE_NV = 1000455028, - VK_DYNAMIC_STATE_COVERAGE_MODULATION_TABLE_NV = 1000455029, - VK_DYNAMIC_STATE_SHADING_RATE_IMAGE_ENABLE_NV = 1000455030, - VK_DYNAMIC_STATE_REPRESENTATIVE_FRAGMENT_TEST_ENABLE_NV = 1000455031, - VK_DYNAMIC_STATE_COVERAGE_REDUCTION_MODE_NV = 1000455032, - VK_DYNAMIC_STATE_ATTACHMENT_FEEDBACK_LOOP_ENABLE_EXT = 1000524000, - VK_DYNAMIC_STATE_CULL_MODE_EXT = VK_DYNAMIC_STATE_CULL_MODE, - VK_DYNAMIC_STATE_FRONT_FACE_EXT = VK_DYNAMIC_STATE_FRONT_FACE, - VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY_EXT = VK_DYNAMIC_STATE_PRIMITIVE_TOPOLOGY, - VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT_EXT = VK_DYNAMIC_STATE_VIEWPORT_WITH_COUNT, - VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT_EXT = VK_DYNAMIC_STATE_SCISSOR_WITH_COUNT, - VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE_EXT = VK_DYNAMIC_STATE_VERTEX_INPUT_BINDING_STRIDE, - VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_TEST_ENABLE, - VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_WRITE_ENABLE, - VK_DYNAMIC_STATE_DEPTH_COMPARE_OP_EXT = VK_DYNAMIC_STATE_DEPTH_COMPARE_OP, - VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BOUNDS_TEST_ENABLE, - VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE, - VK_DYNAMIC_STATE_STENCIL_OP_EXT = VK_DYNAMIC_STATE_STENCIL_OP, - VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE_EXT = VK_DYNAMIC_STATE_RASTERIZER_DISCARD_ENABLE, - VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE_EXT = VK_DYNAMIC_STATE_DEPTH_BIAS_ENABLE, - VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE_EXT = VK_DYNAMIC_STATE_PRIMITIVE_RESTART_ENABLE, - VK_DYNAMIC_STATE_MAX_ENUM = 0x7FFFFFFF -} VkDynamicState; - -typedef enum VkFrontFace { - VK_FRONT_FACE_COUNTER_CLOCKWISE = 0, - VK_FRONT_FACE_CLOCKWISE = 1, - VK_FRONT_FACE_MAX_ENUM = 0x7FFFFFFF -} VkFrontFace; - -typedef enum VkVertexInputRate { - VK_VERTEX_INPUT_RATE_VERTEX = 0, - VK_VERTEX_INPUT_RATE_INSTANCE = 1, - VK_VERTEX_INPUT_RATE_MAX_ENUM = 0x7FFFFFFF -} VkVertexInputRate; - -typedef enum VkPrimitiveTopology { - VK_PRIMITIVE_TOPOLOGY_POINT_LIST = 0, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST = 1, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP = 2, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST = 3, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP = 4, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_FAN = 5, - VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY = 6, - VK_PRIMITIVE_TOPOLOGY_LINE_STRIP_WITH_ADJACENCY = 7, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY = 8, - VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP_WITH_ADJACENCY = 9, - VK_PRIMITIVE_TOPOLOGY_PATCH_LIST = 10, - VK_PRIMITIVE_TOPOLOGY_MAX_ENUM = 0x7FFFFFFF -} VkPrimitiveTopology; - -typedef enum VkPolygonMode { - VK_POLYGON_MODE_FILL = 0, - VK_POLYGON_MODE_LINE = 1, - VK_POLYGON_MODE_POINT = 2, - VK_POLYGON_MODE_FILL_RECTANGLE_NV = 1000153000, - VK_POLYGON_MODE_MAX_ENUM = 0x7FFFFFFF -} VkPolygonMode; - -typedef enum VkStencilOp { - VK_STENCIL_OP_KEEP = 0, - VK_STENCIL_OP_ZERO = 1, - VK_STENCIL_OP_REPLACE = 2, - VK_STENCIL_OP_INCREMENT_AND_CLAMP = 3, - VK_STENCIL_OP_DECREMENT_AND_CLAMP = 4, - VK_STENCIL_OP_INVERT = 5, - VK_STENCIL_OP_INCREMENT_AND_WRAP = 6, - VK_STENCIL_OP_DECREMENT_AND_WRAP = 7, - VK_STENCIL_OP_MAX_ENUM = 0x7FFFFFFF -} VkStencilOp; - -typedef enum VkLogicOp { - VK_LOGIC_OP_CLEAR = 0, - VK_LOGIC_OP_AND = 1, - VK_LOGIC_OP_AND_REVERSE = 2, - VK_LOGIC_OP_COPY = 3, - VK_LOGIC_OP_AND_INVERTED = 4, - VK_LOGIC_OP_NO_OP = 5, - VK_LOGIC_OP_XOR = 6, - VK_LOGIC_OP_OR = 7, - VK_LOGIC_OP_NOR = 8, - VK_LOGIC_OP_EQUIVALENT = 9, - VK_LOGIC_OP_INVERT = 10, - VK_LOGIC_OP_OR_REVERSE = 11, - VK_LOGIC_OP_COPY_INVERTED = 12, - VK_LOGIC_OP_OR_INVERTED = 13, - VK_LOGIC_OP_NAND = 14, - VK_LOGIC_OP_SET = 15, - VK_LOGIC_OP_MAX_ENUM = 0x7FFFFFFF -} VkLogicOp; - -typedef enum VkBorderColor { - VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK = 0, - VK_BORDER_COLOR_INT_TRANSPARENT_BLACK = 1, - VK_BORDER_COLOR_FLOAT_OPAQUE_BLACK = 2, - VK_BORDER_COLOR_INT_OPAQUE_BLACK = 3, - VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE = 4, - VK_BORDER_COLOR_INT_OPAQUE_WHITE = 5, - VK_BORDER_COLOR_FLOAT_CUSTOM_EXT = 1000287003, - VK_BORDER_COLOR_INT_CUSTOM_EXT = 1000287004, - VK_BORDER_COLOR_MAX_ENUM = 0x7FFFFFFF -} VkBorderColor; - -typedef enum VkFilter { - VK_FILTER_NEAREST = 0, - VK_FILTER_LINEAR = 1, - VK_FILTER_CUBIC_EXT = 1000015000, - VK_FILTER_CUBIC_IMG = VK_FILTER_CUBIC_EXT, - VK_FILTER_MAX_ENUM = 0x7FFFFFFF -} VkFilter; - -typedef enum VkSamplerAddressMode { - VK_SAMPLER_ADDRESS_MODE_REPEAT = 0, - VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT = 1, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE = 2, - VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER = 3, - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE = 4, - VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE_KHR = VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE, - VK_SAMPLER_ADDRESS_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerAddressMode; - -typedef enum VkSamplerMipmapMode { - VK_SAMPLER_MIPMAP_MODE_NEAREST = 0, - VK_SAMPLER_MIPMAP_MODE_LINEAR = 1, - VK_SAMPLER_MIPMAP_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerMipmapMode; - -typedef enum VkDescriptorType { - VK_DESCRIPTOR_TYPE_SAMPLER = 0, - VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER = 1, - VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE = 2, - VK_DESCRIPTOR_TYPE_STORAGE_IMAGE = 3, - VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER = 4, - VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER = 5, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER = 6, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER = 7, - VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC = 8, - VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC = 9, - VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT = 10, - VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK = 1000138000, - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR = 1000150000, - VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_NV = 1000165000, - VK_DESCRIPTOR_TYPE_SAMPLE_WEIGHT_IMAGE_QCOM = 1000440000, - VK_DESCRIPTOR_TYPE_BLOCK_MATCH_IMAGE_QCOM = 1000440001, - VK_DESCRIPTOR_TYPE_MUTABLE_EXT = 1000351000, - VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT = VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK, - VK_DESCRIPTOR_TYPE_MUTABLE_VALVE = VK_DESCRIPTOR_TYPE_MUTABLE_EXT, - VK_DESCRIPTOR_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorType; - -typedef enum VkAttachmentLoadOp { - VK_ATTACHMENT_LOAD_OP_LOAD = 0, - VK_ATTACHMENT_LOAD_OP_CLEAR = 1, - VK_ATTACHMENT_LOAD_OP_DONT_CARE = 2, - VK_ATTACHMENT_LOAD_OP_NONE_EXT = 1000400000, - VK_ATTACHMENT_LOAD_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentLoadOp; - -typedef enum VkAttachmentStoreOp { - VK_ATTACHMENT_STORE_OP_STORE = 0, - VK_ATTACHMENT_STORE_OP_DONT_CARE = 1, - VK_ATTACHMENT_STORE_OP_NONE = 1000301000, - VK_ATTACHMENT_STORE_OP_NONE_KHR = VK_ATTACHMENT_STORE_OP_NONE, - VK_ATTACHMENT_STORE_OP_NONE_QCOM = VK_ATTACHMENT_STORE_OP_NONE, - VK_ATTACHMENT_STORE_OP_NONE_EXT = VK_ATTACHMENT_STORE_OP_NONE, - VK_ATTACHMENT_STORE_OP_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentStoreOp; - -typedef enum VkPipelineBindPoint { - VK_PIPELINE_BIND_POINT_GRAPHICS = 0, - VK_PIPELINE_BIND_POINT_COMPUTE = 1, - - - - VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR = 1000165000, - VK_PIPELINE_BIND_POINT_SUBPASS_SHADING_HUAWEI = 1000369003, - VK_PIPELINE_BIND_POINT_RAY_TRACING_NV = VK_PIPELINE_BIND_POINT_RAY_TRACING_KHR, - VK_PIPELINE_BIND_POINT_MAX_ENUM = 0x7FFFFFFF -} VkPipelineBindPoint; - -typedef enum VkCommandBufferLevel { - VK_COMMAND_BUFFER_LEVEL_PRIMARY = 0, - VK_COMMAND_BUFFER_LEVEL_SECONDARY = 1, - VK_COMMAND_BUFFER_LEVEL_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferLevel; - -typedef enum VkIndexType { - VK_INDEX_TYPE_UINT16 = 0, - VK_INDEX_TYPE_UINT32 = 1, - VK_INDEX_TYPE_NONE_KHR = 1000165000, - VK_INDEX_TYPE_UINT8_EXT = 1000265000, - VK_INDEX_TYPE_NONE_NV = VK_INDEX_TYPE_NONE_KHR, - VK_INDEX_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkIndexType; - -typedef enum VkSubpassContents { - VK_SUBPASS_CONTENTS_INLINE = 0, - VK_SUBPASS_CONTENTS_SECONDARY_COMMAND_BUFFERS = 1, - VK_SUBPASS_CONTENTS_INLINE_AND_SECONDARY_COMMAND_BUFFERS_EXT = 1000451000, - VK_SUBPASS_CONTENTS_MAX_ENUM = 0x7FFFFFFF -} VkSubpassContents; - -typedef enum VkAccessFlagBits { - VK_ACCESS_INDIRECT_COMMAND_READ_BIT = 0x00000001, - VK_ACCESS_INDEX_READ_BIT = 0x00000002, - VK_ACCESS_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004, - VK_ACCESS_UNIFORM_READ_BIT = 0x00000008, - VK_ACCESS_INPUT_ATTACHMENT_READ_BIT = 0x00000010, - VK_ACCESS_SHADER_READ_BIT = 0x00000020, - VK_ACCESS_SHADER_WRITE_BIT = 0x00000040, - VK_ACCESS_COLOR_ATTACHMENT_READ_BIT = 0x00000080, - VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200, - VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400, - VK_ACCESS_TRANSFER_READ_BIT = 0x00000800, - VK_ACCESS_TRANSFER_WRITE_BIT = 0x00001000, - VK_ACCESS_HOST_READ_BIT = 0x00002000, - VK_ACCESS_HOST_WRITE_BIT = 0x00004000, - VK_ACCESS_MEMORY_READ_BIT = 0x00008000, - VK_ACCESS_MEMORY_WRITE_BIT = 0x00010000, - VK_ACCESS_NONE = 0, - VK_ACCESS_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000, - VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000, - VK_ACCESS_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000, - VK_ACCESS_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000, - VK_ACCESS_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000, - VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000, - VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000, - VK_ACCESS_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000, - VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000, - VK_ACCESS_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000, - VK_ACCESS_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000, - VK_ACCESS_SHADING_RATE_IMAGE_READ_BIT_NV = VK_ACCESS_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR, - VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR, - VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_NV = VK_ACCESS_ACCELERATION_STRUCTURE_WRITE_BIT_KHR, - VK_ACCESS_NONE_KHR = VK_ACCESS_NONE, - VK_ACCESS_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkAccessFlagBits; -typedef VkFlags VkAccessFlags; - -typedef enum VkImageAspectFlagBits { - VK_IMAGE_ASPECT_COLOR_BIT = 0x00000001, - VK_IMAGE_ASPECT_DEPTH_BIT = 0x00000002, - VK_IMAGE_ASPECT_STENCIL_BIT = 0x00000004, - VK_IMAGE_ASPECT_METADATA_BIT = 0x00000008, - VK_IMAGE_ASPECT_PLANE_0_BIT = 0x00000010, - VK_IMAGE_ASPECT_PLANE_1_BIT = 0x00000020, - VK_IMAGE_ASPECT_PLANE_2_BIT = 0x00000040, - VK_IMAGE_ASPECT_NONE = 0, - VK_IMAGE_ASPECT_MEMORY_PLANE_0_BIT_EXT = 0x00000080, - VK_IMAGE_ASPECT_MEMORY_PLANE_1_BIT_EXT = 0x00000100, - VK_IMAGE_ASPECT_MEMORY_PLANE_2_BIT_EXT = 0x00000200, - VK_IMAGE_ASPECT_MEMORY_PLANE_3_BIT_EXT = 0x00000400, - VK_IMAGE_ASPECT_PLANE_0_BIT_KHR = VK_IMAGE_ASPECT_PLANE_0_BIT, - VK_IMAGE_ASPECT_PLANE_1_BIT_KHR = VK_IMAGE_ASPECT_PLANE_1_BIT, - VK_IMAGE_ASPECT_PLANE_2_BIT_KHR = VK_IMAGE_ASPECT_PLANE_2_BIT, - VK_IMAGE_ASPECT_NONE_KHR = VK_IMAGE_ASPECT_NONE, - VK_IMAGE_ASPECT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageAspectFlagBits; -typedef VkFlags VkImageAspectFlags; - -typedef enum VkFormatFeatureFlagBits { - VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT = 0x00000001, - VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT = 0x00000002, - VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004, - VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT = 0x00000010, - VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020, - VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT = 0x00000040, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT = 0x00000080, - VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100, - VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200, - VK_FORMAT_FEATURE_BLIT_SRC_BIT = 0x00000400, - VK_FORMAT_FEATURE_BLIT_DST_BIT = 0x00000800, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000, - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT = 0x00004000, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT = 0x00008000, - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000, - VK_FORMAT_FEATURE_DISJOINT_BIT = 0x00400000, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT = 0x00800000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000, - VK_FORMAT_FEATURE_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000, - VK_FORMAT_FEATURE_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000, - VK_FORMAT_FEATURE_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000, - VK_FORMAT_FEATURE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000, - VK_FORMAT_FEATURE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000, - - - - - - - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_IMG = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT, - VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT, - VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR = VK_FORMAT_FEATURE_TRANSFER_DST_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_EXT = VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT, - VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT, - VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT, - VK_FORMAT_FEATURE_DISJOINT_BIT_KHR = VK_FORMAT_FEATURE_DISJOINT_BIT, - VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR = VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT, - VK_FORMAT_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFormatFeatureFlagBits; -typedef VkFlags VkFormatFeatureFlags; - -typedef enum VkImageCreateFlagBits { - VK_IMAGE_CREATE_SPARSE_BINDING_BIT = 0x00000001, - VK_IMAGE_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_IMAGE_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT = 0x00000008, - VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT = 0x00000010, - VK_IMAGE_CREATE_ALIAS_BIT = 0x00000400, - VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT = 0x00000040, - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT = 0x00000020, - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT = 0x00000080, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT = 0x00000100, - VK_IMAGE_CREATE_PROTECTED_BIT = 0x00000800, - VK_IMAGE_CREATE_DISJOINT_BIT = 0x00000200, - VK_IMAGE_CREATE_CORNER_SAMPLED_BIT_NV = 0x00002000, - VK_IMAGE_CREATE_SAMPLE_LOCATIONS_COMPATIBLE_DEPTH_BIT_EXT = 0x00001000, - VK_IMAGE_CREATE_SUBSAMPLED_BIT_EXT = 0x00004000, - VK_IMAGE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00010000, - VK_IMAGE_CREATE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_BIT_EXT = 0x00040000, - VK_IMAGE_CREATE_2D_VIEW_COMPATIBLE_BIT_EXT = 0x00020000, - VK_IMAGE_CREATE_FRAGMENT_DENSITY_MAP_OFFSET_BIT_QCOM = 0x00008000, - VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = VK_IMAGE_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT, - VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT, - VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT_KHR = VK_IMAGE_CREATE_BLOCK_TEXEL_VIEW_COMPATIBLE_BIT, - VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR = VK_IMAGE_CREATE_EXTENDED_USAGE_BIT, - VK_IMAGE_CREATE_DISJOINT_BIT_KHR = VK_IMAGE_CREATE_DISJOINT_BIT, - VK_IMAGE_CREATE_ALIAS_BIT_KHR = VK_IMAGE_CREATE_ALIAS_BIT, - VK_IMAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageCreateFlagBits; -typedef VkFlags VkImageCreateFlags; - -typedef enum VkSampleCountFlagBits { - VK_SAMPLE_COUNT_1_BIT = 0x00000001, - VK_SAMPLE_COUNT_2_BIT = 0x00000002, - VK_SAMPLE_COUNT_4_BIT = 0x00000004, - VK_SAMPLE_COUNT_8_BIT = 0x00000008, - VK_SAMPLE_COUNT_16_BIT = 0x00000010, - VK_SAMPLE_COUNT_32_BIT = 0x00000020, - VK_SAMPLE_COUNT_64_BIT = 0x00000040, - VK_SAMPLE_COUNT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSampleCountFlagBits; -typedef VkFlags VkSampleCountFlags; - -typedef enum VkImageUsageFlagBits { - VK_IMAGE_USAGE_TRANSFER_SRC_BIT = 0x00000001, - VK_IMAGE_USAGE_TRANSFER_DST_BIT = 0x00000002, - VK_IMAGE_USAGE_SAMPLED_BIT = 0x00000004, - VK_IMAGE_USAGE_STORAGE_BIT = 0x00000008, - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT = 0x00000010, - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000020, - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT = 0x00000040, - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT = 0x00000080, - VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00000400, - VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00000800, - VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR = 0x00001000, - VK_IMAGE_USAGE_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x00000200, - VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00000100, - VK_IMAGE_USAGE_HOST_TRANSFER_BIT_EXT = 0x00400000, -# 2385 "/usr/include/vulkan/vulkan_core.h" 3 4 - VK_IMAGE_USAGE_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x00080000, - VK_IMAGE_USAGE_INVOCATION_MASK_BIT_HUAWEI = 0x00040000, - VK_IMAGE_USAGE_SAMPLE_WEIGHT_BIT_QCOM = 0x00100000, - VK_IMAGE_USAGE_SAMPLE_BLOCK_MATCH_BIT_QCOM = 0x00200000, - VK_IMAGE_USAGE_SHADING_RATE_IMAGE_BIT_NV = VK_IMAGE_USAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - VK_IMAGE_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageUsageFlagBits; -typedef VkFlags VkImageUsageFlags; - -typedef enum VkInstanceCreateFlagBits { - VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR = 0x00000001, - VK_INSTANCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkInstanceCreateFlagBits; -typedef VkFlags VkInstanceCreateFlags; - -typedef enum VkMemoryHeapFlagBits { - VK_MEMORY_HEAP_DEVICE_LOCAL_BIT = 0x00000001, - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT = 0x00000002, - VK_MEMORY_HEAP_MULTI_INSTANCE_BIT_KHR = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT, - VK_MEMORY_HEAP_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryHeapFlagBits; -typedef VkFlags VkMemoryHeapFlags; - -typedef enum VkMemoryPropertyFlagBits { - VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT = 0x00000001, - VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT = 0x00000002, - VK_MEMORY_PROPERTY_HOST_COHERENT_BIT = 0x00000004, - VK_MEMORY_PROPERTY_HOST_CACHED_BIT = 0x00000008, - VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT = 0x00000010, - VK_MEMORY_PROPERTY_PROTECTED_BIT = 0x00000020, - VK_MEMORY_PROPERTY_DEVICE_COHERENT_BIT_AMD = 0x00000040, - VK_MEMORY_PROPERTY_DEVICE_UNCACHED_BIT_AMD = 0x00000080, - VK_MEMORY_PROPERTY_RDMA_CAPABLE_BIT_NV = 0x00000100, - VK_MEMORY_PROPERTY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryPropertyFlagBits; -typedef VkFlags VkMemoryPropertyFlags; - -typedef enum VkQueueFlagBits { - VK_QUEUE_GRAPHICS_BIT = 0x00000001, - VK_QUEUE_COMPUTE_BIT = 0x00000002, - VK_QUEUE_TRANSFER_BIT = 0x00000004, - VK_QUEUE_SPARSE_BINDING_BIT = 0x00000008, - VK_QUEUE_PROTECTED_BIT = 0x00000010, - VK_QUEUE_VIDEO_DECODE_BIT_KHR = 0x00000020, - - - - VK_QUEUE_OPTICAL_FLOW_BIT_NV = 0x00000100, - VK_QUEUE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueueFlagBits; -typedef VkFlags VkQueueFlags; -typedef VkFlags VkDeviceCreateFlags; - -typedef enum VkDeviceQueueCreateFlagBits { - VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT = 0x00000001, - VK_DEVICE_QUEUE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDeviceQueueCreateFlagBits; -typedef VkFlags VkDeviceQueueCreateFlags; - -typedef enum VkPipelineStageFlagBits { - VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT = 0x00000001, - VK_PIPELINE_STAGE_DRAW_INDIRECT_BIT = 0x00000002, - VK_PIPELINE_STAGE_VERTEX_INPUT_BIT = 0x00000004, - VK_PIPELINE_STAGE_VERTEX_SHADER_BIT = 0x00000008, - VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010, - VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020, - VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT = 0x00000040, - VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT = 0x00000080, - VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT = 0x00000100, - VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT = 0x00000200, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400, - VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT = 0x00000800, - VK_PIPELINE_STAGE_TRANSFER_BIT = 0x00001000, - VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT = 0x00002000, - VK_PIPELINE_STAGE_HOST_BIT = 0x00004000, - VK_PIPELINE_STAGE_ALL_GRAPHICS_BIT = 0x00008000, - VK_PIPELINE_STAGE_ALL_COMMANDS_BIT = 0x00010000, - VK_PIPELINE_STAGE_NONE = 0, - VK_PIPELINE_STAGE_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000, - VK_PIPELINE_STAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000, - VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000, - VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR = 0x00200000, - VK_PIPELINE_STAGE_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000, - VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000, - VK_PIPELINE_STAGE_COMMAND_PREPROCESS_BIT_NV = 0x00020000, - VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT = 0x00080000, - VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT = 0x00100000, - VK_PIPELINE_STAGE_SHADING_RATE_IMAGE_BIT_NV = VK_PIPELINE_STAGE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_NV = VK_PIPELINE_STAGE_RAY_TRACING_SHADER_BIT_KHR, - VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_NV = VK_PIPELINE_STAGE_ACCELERATION_STRUCTURE_BUILD_BIT_KHR, - VK_PIPELINE_STAGE_TASK_SHADER_BIT_NV = VK_PIPELINE_STAGE_TASK_SHADER_BIT_EXT, - VK_PIPELINE_STAGE_MESH_SHADER_BIT_NV = VK_PIPELINE_STAGE_MESH_SHADER_BIT_EXT, - VK_PIPELINE_STAGE_NONE_KHR = VK_PIPELINE_STAGE_NONE, - VK_PIPELINE_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineStageFlagBits; -typedef VkFlags VkPipelineStageFlags; -typedef VkFlags VkMemoryMapFlags; - -typedef enum VkSparseMemoryBindFlagBits { - VK_SPARSE_MEMORY_BIND_METADATA_BIT = 0x00000001, - VK_SPARSE_MEMORY_BIND_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSparseMemoryBindFlagBits; -typedef VkFlags VkSparseMemoryBindFlags; - -typedef enum VkSparseImageFormatFlagBits { - VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT = 0x00000001, - VK_SPARSE_IMAGE_FORMAT_ALIGNED_MIP_SIZE_BIT = 0x00000002, - VK_SPARSE_IMAGE_FORMAT_NONSTANDARD_BLOCK_SIZE_BIT = 0x00000004, - VK_SPARSE_IMAGE_FORMAT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSparseImageFormatFlagBits; -typedef VkFlags VkSparseImageFormatFlags; - -typedef enum VkFenceCreateFlagBits { - VK_FENCE_CREATE_SIGNALED_BIT = 0x00000001, - VK_FENCE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFenceCreateFlagBits; -typedef VkFlags VkFenceCreateFlags; -typedef VkFlags VkSemaphoreCreateFlags; - -typedef enum VkEventCreateFlagBits { - VK_EVENT_CREATE_DEVICE_ONLY_BIT = 0x00000001, - VK_EVENT_CREATE_DEVICE_ONLY_BIT_KHR = VK_EVENT_CREATE_DEVICE_ONLY_BIT, - VK_EVENT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkEventCreateFlagBits; -typedef VkFlags VkEventCreateFlags; - -typedef enum VkQueryPipelineStatisticFlagBits { - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_VERTICES_BIT = 0x00000001, - VK_QUERY_PIPELINE_STATISTIC_INPUT_ASSEMBLY_PRIMITIVES_BIT = 0x00000002, - VK_QUERY_PIPELINE_STATISTIC_VERTEX_SHADER_INVOCATIONS_BIT = 0x00000004, - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_INVOCATIONS_BIT = 0x00000008, - VK_QUERY_PIPELINE_STATISTIC_GEOMETRY_SHADER_PRIMITIVES_BIT = 0x00000010, - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_INVOCATIONS_BIT = 0x00000020, - VK_QUERY_PIPELINE_STATISTIC_CLIPPING_PRIMITIVES_BIT = 0x00000040, - VK_QUERY_PIPELINE_STATISTIC_FRAGMENT_SHADER_INVOCATIONS_BIT = 0x00000080, - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_CONTROL_SHADER_PATCHES_BIT = 0x00000100, - VK_QUERY_PIPELINE_STATISTIC_TESSELLATION_EVALUATION_SHADER_INVOCATIONS_BIT = 0x00000200, - VK_QUERY_PIPELINE_STATISTIC_COMPUTE_SHADER_INVOCATIONS_BIT = 0x00000400, - VK_QUERY_PIPELINE_STATISTIC_TASK_SHADER_INVOCATIONS_BIT_EXT = 0x00000800, - VK_QUERY_PIPELINE_STATISTIC_MESH_SHADER_INVOCATIONS_BIT_EXT = 0x00001000, - VK_QUERY_PIPELINE_STATISTIC_CLUSTER_CULLING_SHADER_INVOCATIONS_BIT_HUAWEI = 0x00002000, - VK_QUERY_PIPELINE_STATISTIC_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryPipelineStatisticFlagBits; -typedef VkFlags VkQueryPipelineStatisticFlags; -typedef VkFlags VkQueryPoolCreateFlags; - -typedef enum VkQueryResultFlagBits { - VK_QUERY_RESULT_64_BIT = 0x00000001, - VK_QUERY_RESULT_WAIT_BIT = 0x00000002, - VK_QUERY_RESULT_WITH_AVAILABILITY_BIT = 0x00000004, - VK_QUERY_RESULT_PARTIAL_BIT = 0x00000008, - VK_QUERY_RESULT_WITH_STATUS_BIT_KHR = 0x00000010, - VK_QUERY_RESULT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryResultFlagBits; -typedef VkFlags VkQueryResultFlags; - -typedef enum VkBufferCreateFlagBits { - VK_BUFFER_CREATE_SPARSE_BINDING_BIT = 0x00000001, - VK_BUFFER_CREATE_SPARSE_RESIDENCY_BIT = 0x00000002, - VK_BUFFER_CREATE_SPARSE_ALIASED_BIT = 0x00000004, - VK_BUFFER_CREATE_PROTECTED_BIT = 0x00000008, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000010, - VK_BUFFER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000020, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_BUFFER_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - VK_BUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkBufferCreateFlagBits; -typedef VkFlags VkBufferCreateFlags; - -typedef enum VkBufferUsageFlagBits { - VK_BUFFER_USAGE_TRANSFER_SRC_BIT = 0x00000001, - VK_BUFFER_USAGE_TRANSFER_DST_BIT = 0x00000002, - VK_BUFFER_USAGE_UNIFORM_TEXEL_BUFFER_BIT = 0x00000004, - VK_BUFFER_USAGE_STORAGE_TEXEL_BUFFER_BIT = 0x00000008, - VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT = 0x00000010, - VK_BUFFER_USAGE_STORAGE_BUFFER_BIT = 0x00000020, - VK_BUFFER_USAGE_INDEX_BUFFER_BIT = 0x00000040, - VK_BUFFER_USAGE_VERTEX_BUFFER_BIT = 0x00000080, - VK_BUFFER_USAGE_INDIRECT_BUFFER_BIT = 0x00000100, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT = 0x00020000, - VK_BUFFER_USAGE_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000, - VK_BUFFER_USAGE_VIDEO_DECODE_DST_BIT_KHR = 0x00004000, - VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800, - VK_BUFFER_USAGE_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000, - VK_BUFFER_USAGE_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200, - - - - VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000, - VK_BUFFER_USAGE_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000, - VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400, - - - - - - - VK_BUFFER_USAGE_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000, - VK_BUFFER_USAGE_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000, - VK_BUFFER_USAGE_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000, - VK_BUFFER_USAGE_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000, - VK_BUFFER_USAGE_MICROMAP_STORAGE_BIT_EXT = 0x01000000, - VK_BUFFER_USAGE_RAY_TRACING_BIT_NV = VK_BUFFER_USAGE_SHADER_BINDING_TABLE_BIT_KHR, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_EXT = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, - VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT_KHR = VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT, - VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkBufferUsageFlagBits; -typedef VkFlags VkBufferUsageFlags; -typedef VkFlags VkBufferViewCreateFlags; - -typedef enum VkImageViewCreateFlagBits { - VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DYNAMIC_BIT_EXT = 0x00000001, - VK_IMAGE_VIEW_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000004, - VK_IMAGE_VIEW_CREATE_FRAGMENT_DENSITY_MAP_DEFERRED_BIT_EXT = 0x00000002, - VK_IMAGE_VIEW_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkImageViewCreateFlagBits; -typedef VkFlags VkImageViewCreateFlags; -typedef VkFlags VkShaderModuleCreateFlags; - -typedef enum VkPipelineCacheCreateFlagBits { - VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT = 0x00000001, - VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT_EXT = VK_PIPELINE_CACHE_CREATE_EXTERNALLY_SYNCHRONIZED_BIT, - VK_PIPELINE_CACHE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCacheCreateFlagBits; -typedef VkFlags VkPipelineCacheCreateFlags; - -typedef enum VkColorComponentFlagBits { - VK_COLOR_COMPONENT_R_BIT = 0x00000001, - VK_COLOR_COMPONENT_G_BIT = 0x00000002, - VK_COLOR_COMPONENT_B_BIT = 0x00000004, - VK_COLOR_COMPONENT_A_BIT = 0x00000008, - VK_COLOR_COMPONENT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkColorComponentFlagBits; -typedef VkFlags VkColorComponentFlags; - -typedef enum VkPipelineCreateFlagBits { - VK_PIPELINE_CREATE_DISABLE_OPTIMIZATION_BIT = 0x00000001, - VK_PIPELINE_CREATE_ALLOW_DERIVATIVES_BIT = 0x00000002, - VK_PIPELINE_CREATE_DERIVATIVE_BIT = 0x00000004, - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT = 0x00000008, - VK_PIPELINE_CREATE_DISPATCH_BASE_BIT = 0x00000010, - VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT = 0x00000100, - VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT = 0x00000200, - VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000, - VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000, - VK_PIPELINE_CREATE_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000, - VK_PIPELINE_CREATE_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000, - VK_PIPELINE_CREATE_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000, - VK_PIPELINE_CREATE_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000, - VK_PIPELINE_CREATE_DEFER_COMPILE_BIT_NV = 0x00000020, - VK_PIPELINE_CREATE_CAPTURE_STATISTICS_BIT_KHR = 0x00000040, - VK_PIPELINE_CREATE_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080, - VK_PIPELINE_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00040000, - VK_PIPELINE_CREATE_LIBRARY_BIT_KHR = 0x00000800, - VK_PIPELINE_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000, - VK_PIPELINE_CREATE_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000, - VK_PIPELINE_CREATE_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400, - VK_PIPELINE_CREATE_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000, - VK_PIPELINE_CREATE_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000, - VK_PIPELINE_CREATE_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000, - VK_PIPELINE_CREATE_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000, - - - - VK_PIPELINE_CREATE_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000, - VK_PIPELINE_CREATE_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000, - VK_PIPELINE_CREATE_DISPATCH_BASE = VK_PIPELINE_CREATE_DISPATCH_BASE_BIT, - VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR, - VK_PIPELINE_RASTERIZATION_STATE_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = VK_PIPELINE_CREATE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT, - VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT, - VK_PIPELINE_CREATE_DISPATCH_BASE_KHR = VK_PIPELINE_CREATE_DISPATCH_BASE, - VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_EXT = VK_PIPELINE_CREATE_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT, - VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT_EXT = VK_PIPELINE_CREATE_EARLY_RETURN_ON_FAILURE_BIT, - VK_PIPELINE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCreateFlagBits; -typedef VkFlags VkPipelineCreateFlags; - -typedef enum VkPipelineShaderStageCreateFlagBits { - VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT = 0x00000001, - VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT = 0x00000002, - VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT, - VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = VK_PIPELINE_SHADER_STAGE_CREATE_REQUIRE_FULL_SUBGROUPS_BIT, - VK_PIPELINE_SHADER_STAGE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineShaderStageCreateFlagBits; -typedef VkFlags VkPipelineShaderStageCreateFlags; - -typedef enum VkShaderStageFlagBits { - VK_SHADER_STAGE_VERTEX_BIT = 0x00000001, - VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT = 0x00000002, - VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT = 0x00000004, - VK_SHADER_STAGE_GEOMETRY_BIT = 0x00000008, - VK_SHADER_STAGE_FRAGMENT_BIT = 0x00000010, - VK_SHADER_STAGE_COMPUTE_BIT = 0x00000020, - VK_SHADER_STAGE_ALL_GRAPHICS = 0x0000001F, - VK_SHADER_STAGE_ALL = 0x7FFFFFFF, - VK_SHADER_STAGE_RAYGEN_BIT_KHR = 0x00000100, - VK_SHADER_STAGE_ANY_HIT_BIT_KHR = 0x00000200, - VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR = 0x00000400, - VK_SHADER_STAGE_MISS_BIT_KHR = 0x00000800, - VK_SHADER_STAGE_INTERSECTION_BIT_KHR = 0x00001000, - VK_SHADER_STAGE_CALLABLE_BIT_KHR = 0x00002000, - VK_SHADER_STAGE_TASK_BIT_EXT = 0x00000040, - VK_SHADER_STAGE_MESH_BIT_EXT = 0x00000080, - VK_SHADER_STAGE_SUBPASS_SHADING_BIT_HUAWEI = 0x00004000, - VK_SHADER_STAGE_CLUSTER_CULLING_BIT_HUAWEI = 0x00080000, - VK_SHADER_STAGE_RAYGEN_BIT_NV = VK_SHADER_STAGE_RAYGEN_BIT_KHR, - VK_SHADER_STAGE_ANY_HIT_BIT_NV = VK_SHADER_STAGE_ANY_HIT_BIT_KHR, - VK_SHADER_STAGE_CLOSEST_HIT_BIT_NV = VK_SHADER_STAGE_CLOSEST_HIT_BIT_KHR, - VK_SHADER_STAGE_MISS_BIT_NV = VK_SHADER_STAGE_MISS_BIT_KHR, - VK_SHADER_STAGE_INTERSECTION_BIT_NV = VK_SHADER_STAGE_INTERSECTION_BIT_KHR, - VK_SHADER_STAGE_CALLABLE_BIT_NV = VK_SHADER_STAGE_CALLABLE_BIT_KHR, - VK_SHADER_STAGE_TASK_BIT_NV = VK_SHADER_STAGE_TASK_BIT_EXT, - VK_SHADER_STAGE_MESH_BIT_NV = VK_SHADER_STAGE_MESH_BIT_EXT, - VK_SHADER_STAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkShaderStageFlagBits; - -typedef enum VkCullModeFlagBits { - VK_CULL_MODE_NONE = 0, - VK_CULL_MODE_FRONT_BIT = 0x00000001, - VK_CULL_MODE_BACK_BIT = 0x00000002, - VK_CULL_MODE_FRONT_AND_BACK = 0x00000003, - VK_CULL_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCullModeFlagBits; -typedef VkFlags VkCullModeFlags; -typedef VkFlags VkPipelineVertexInputStateCreateFlags; -typedef VkFlags VkPipelineInputAssemblyStateCreateFlags; -typedef VkFlags VkPipelineTessellationStateCreateFlags; -typedef VkFlags VkPipelineViewportStateCreateFlags; -typedef VkFlags VkPipelineRasterizationStateCreateFlags; -typedef VkFlags VkPipelineMultisampleStateCreateFlags; - -typedef enum VkPipelineDepthStencilStateCreateFlagBits { - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000001, - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000002, - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, - VK_PIPELINE_DEPTH_STENCIL_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineDepthStencilStateCreateFlagBits; -typedef VkFlags VkPipelineDepthStencilStateCreateFlags; - -typedef enum VkPipelineColorBlendStateCreateFlagBits { - VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT = 0x00000001, - VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_ARM = VK_PIPELINE_COLOR_BLEND_STATE_CREATE_RASTERIZATION_ORDER_ATTACHMENT_ACCESS_BIT_EXT, - VK_PIPELINE_COLOR_BLEND_STATE_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineColorBlendStateCreateFlagBits; -typedef VkFlags VkPipelineColorBlendStateCreateFlags; -typedef VkFlags VkPipelineDynamicStateCreateFlags; - -typedef enum VkPipelineLayoutCreateFlagBits { - VK_PIPELINE_LAYOUT_CREATE_INDEPENDENT_SETS_BIT_EXT = 0x00000002, - VK_PIPELINE_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineLayoutCreateFlagBits; -typedef VkFlags VkPipelineLayoutCreateFlags; -typedef VkFlags VkShaderStageFlags; - -typedef enum VkSamplerCreateFlagBits { - VK_SAMPLER_CREATE_SUBSAMPLED_BIT_EXT = 0x00000001, - VK_SAMPLER_CREATE_SUBSAMPLED_COARSE_RECONSTRUCTION_BIT_EXT = 0x00000002, - VK_SAMPLER_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, - VK_SAMPLER_CREATE_NON_SEAMLESS_CUBE_MAP_BIT_EXT = 0x00000004, - VK_SAMPLER_CREATE_IMAGE_PROCESSING_BIT_QCOM = 0x00000010, - VK_SAMPLER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSamplerCreateFlagBits; -typedef VkFlags VkSamplerCreateFlags; - -typedef enum VkDescriptorPoolCreateFlagBits { - VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT = 0x00000001, - VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT = 0x00000002, - VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT = 0x00000004, - VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_SETS_BIT_NV = 0x00000008, - VK_DESCRIPTOR_POOL_CREATE_ALLOW_OVERALLOCATION_POOLS_BIT_NV = 0x00000010, - VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT, - VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_VALVE = VK_DESCRIPTOR_POOL_CREATE_HOST_ONLY_BIT_EXT, - VK_DESCRIPTOR_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorPoolCreateFlagBits; -typedef VkFlags VkDescriptorPoolCreateFlags; -typedef VkFlags VkDescriptorPoolResetFlags; - -typedef enum VkDescriptorSetLayoutCreateFlagBits { - VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT = 0x00000002, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR = 0x00000001, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00000010, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_EMBEDDED_IMMUTABLE_SAMPLERS_BIT_EXT = 0x00000020, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_INDIRECT_BINDABLE_BIT_NV = 0x00000080, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT = 0x00000004, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_VALVE = VK_DESCRIPTOR_SET_LAYOUT_CREATE_HOST_ONLY_POOL_BIT_EXT, - VK_DESCRIPTOR_SET_LAYOUT_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorSetLayoutCreateFlagBits; -typedef VkFlags VkDescriptorSetLayoutCreateFlags; - -typedef enum VkAttachmentDescriptionFlagBits { - VK_ATTACHMENT_DESCRIPTION_MAY_ALIAS_BIT = 0x00000001, - VK_ATTACHMENT_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkAttachmentDescriptionFlagBits; -typedef VkFlags VkAttachmentDescriptionFlags; - -typedef enum VkDependencyFlagBits { - VK_DEPENDENCY_BY_REGION_BIT = 0x00000001, - VK_DEPENDENCY_DEVICE_GROUP_BIT = 0x00000004, - VK_DEPENDENCY_VIEW_LOCAL_BIT = 0x00000002, - VK_DEPENDENCY_FEEDBACK_LOOP_BIT_EXT = 0x00000008, - VK_DEPENDENCY_VIEW_LOCAL_BIT_KHR = VK_DEPENDENCY_VIEW_LOCAL_BIT, - VK_DEPENDENCY_DEVICE_GROUP_BIT_KHR = VK_DEPENDENCY_DEVICE_GROUP_BIT, - VK_DEPENDENCY_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDependencyFlagBits; -typedef VkFlags VkDependencyFlags; - -typedef enum VkFramebufferCreateFlagBits { - VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT = 0x00000001, - VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT_KHR = VK_FRAMEBUFFER_CREATE_IMAGELESS_BIT, - VK_FRAMEBUFFER_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFramebufferCreateFlagBits; -typedef VkFlags VkFramebufferCreateFlags; - -typedef enum VkRenderPassCreateFlagBits { - VK_RENDER_PASS_CREATE_TRANSFORM_BIT_QCOM = 0x00000002, - VK_RENDER_PASS_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkRenderPassCreateFlagBits; -typedef VkFlags VkRenderPassCreateFlags; - -typedef enum VkSubpassDescriptionFlagBits { - VK_SUBPASS_DESCRIPTION_PER_VIEW_ATTRIBUTES_BIT_NVX = 0x00000001, - VK_SUBPASS_DESCRIPTION_PER_VIEW_POSITION_X_ONLY_BIT_NVX = 0x00000002, - VK_SUBPASS_DESCRIPTION_FRAGMENT_REGION_BIT_QCOM = 0x00000004, - VK_SUBPASS_DESCRIPTION_SHADER_RESOLVE_BIT_QCOM = 0x00000008, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT = 0x00000010, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT = 0x00000020, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT = 0x00000040, - VK_SUBPASS_DESCRIPTION_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000080, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_COLOR_ACCESS_BIT_EXT, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_DEPTH_ACCESS_BIT_EXT, - VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_ARM = VK_SUBPASS_DESCRIPTION_RASTERIZATION_ORDER_ATTACHMENT_STENCIL_ACCESS_BIT_EXT, - VK_SUBPASS_DESCRIPTION_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubpassDescriptionFlagBits; -typedef VkFlags VkSubpassDescriptionFlags; - -typedef enum VkCommandPoolCreateFlagBits { - VK_COMMAND_POOL_CREATE_TRANSIENT_BIT = 0x00000001, - VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT = 0x00000002, - VK_COMMAND_POOL_CREATE_PROTECTED_BIT = 0x00000004, - VK_COMMAND_POOL_CREATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolCreateFlagBits; -typedef VkFlags VkCommandPoolCreateFlags; - -typedef enum VkCommandPoolResetFlagBits { - VK_COMMAND_POOL_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_POOL_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandPoolResetFlagBits; -typedef VkFlags VkCommandPoolResetFlags; - -typedef enum VkCommandBufferUsageFlagBits { - VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT = 0x00000001, - VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT = 0x00000002, - VK_COMMAND_BUFFER_USAGE_SIMULTANEOUS_USE_BIT = 0x00000004, - VK_COMMAND_BUFFER_USAGE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferUsageFlagBits; -typedef VkFlags VkCommandBufferUsageFlags; - -typedef enum VkQueryControlFlagBits { - VK_QUERY_CONTROL_PRECISE_BIT = 0x00000001, - VK_QUERY_CONTROL_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkQueryControlFlagBits; -typedef VkFlags VkQueryControlFlags; - -typedef enum VkCommandBufferResetFlagBits { - VK_COMMAND_BUFFER_RESET_RELEASE_RESOURCES_BIT = 0x00000001, - VK_COMMAND_BUFFER_RESET_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkCommandBufferResetFlagBits; -typedef VkFlags VkCommandBufferResetFlags; - -typedef enum VkStencilFaceFlagBits { - VK_STENCIL_FACE_FRONT_BIT = 0x00000001, - VK_STENCIL_FACE_BACK_BIT = 0x00000002, - VK_STENCIL_FACE_FRONT_AND_BACK = 0x00000003, - VK_STENCIL_FRONT_AND_BACK = VK_STENCIL_FACE_FRONT_AND_BACK, - VK_STENCIL_FACE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkStencilFaceFlagBits; -typedef VkFlags VkStencilFaceFlags; -typedef struct VkExtent2D { - uint32_t width; - uint32_t height; -} VkExtent2D; - -typedef struct VkExtent3D { - uint32_t width; - uint32_t height; - uint32_t depth; -} VkExtent3D; - -typedef struct VkOffset2D { - int32_t x; - int32_t y; -} VkOffset2D; - -typedef struct VkOffset3D { - int32_t x; - int32_t y; - int32_t z; -} VkOffset3D; - -typedef struct VkRect2D { - VkOffset2D offset; - VkExtent2D extent; -} VkRect2D; - -typedef struct VkBaseInStructure { - VkStructureType sType; - const struct VkBaseInStructure* pNext; -} VkBaseInStructure; - -typedef struct VkBaseOutStructure { - VkStructureType sType; - struct VkBaseOutStructure* pNext; -} VkBaseOutStructure; - -typedef struct VkBufferMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier; - -typedef struct VkDispatchIndirectCommand { - uint32_t x; - uint32_t y; - uint32_t z; -} VkDispatchIndirectCommand; - -typedef struct VkDrawIndexedIndirectCommand { - uint32_t indexCount; - uint32_t instanceCount; - uint32_t firstIndex; - int32_t vertexOffset; - uint32_t firstInstance; -} VkDrawIndexedIndirectCommand; - -typedef struct VkDrawIndirectCommand { - uint32_t vertexCount; - uint32_t instanceCount; - uint32_t firstVertex; - uint32_t firstInstance; -} VkDrawIndirectCommand; - -typedef struct VkImageSubresourceRange { - VkImageAspectFlags aspectMask; - uint32_t baseMipLevel; - uint32_t levelCount; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkImageSubresourceRange; - -typedef struct VkImageMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier; - -typedef struct VkMemoryBarrier { - VkStructureType sType; - const void* pNext; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; -} VkMemoryBarrier; - -typedef struct VkPipelineCacheHeaderVersionOne { - uint32_t headerSize; - VkPipelineCacheHeaderVersion headerVersion; - uint32_t vendorID; - uint32_t deviceID; - uint8_t pipelineCacheUUID[16U]; -} VkPipelineCacheHeaderVersionOne; - -typedef void* ( *PFN_vkAllocationFunction)( - void* pUserData, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - -typedef void ( *PFN_vkFreeFunction)( - void* pUserData, - void* pMemory); - -typedef void ( *PFN_vkInternalAllocationNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - -typedef void ( *PFN_vkInternalFreeNotification)( - void* pUserData, - size_t size, - VkInternalAllocationType allocationType, - VkSystemAllocationScope allocationScope); - -typedef void* ( *PFN_vkReallocationFunction)( - void* pUserData, - void* pOriginal, - size_t size, - size_t alignment, - VkSystemAllocationScope allocationScope); - -typedef void ( *PFN_vkVoidFunction)(void); -typedef struct VkAllocationCallbacks { - void* pUserData; - PFN_vkAllocationFunction pfnAllocation; - PFN_vkReallocationFunction pfnReallocation; - PFN_vkFreeFunction pfnFree; - PFN_vkInternalAllocationNotification pfnInternalAllocation; - PFN_vkInternalFreeNotification pfnInternalFree; -} VkAllocationCallbacks; - -typedef struct VkApplicationInfo { - VkStructureType sType; - const void* pNext; - const char* pApplicationName; - uint32_t applicationVersion; - const char* pEngineName; - uint32_t engineVersion; - uint32_t apiVersion; -} VkApplicationInfo; - -typedef struct VkFormatProperties { - VkFormatFeatureFlags linearTilingFeatures; - VkFormatFeatureFlags optimalTilingFeatures; - VkFormatFeatureFlags bufferFeatures; -} VkFormatProperties; - -typedef struct VkImageFormatProperties { - VkExtent3D maxExtent; - uint32_t maxMipLevels; - uint32_t maxArrayLayers; - VkSampleCountFlags sampleCounts; - VkDeviceSize maxResourceSize; -} VkImageFormatProperties; - -typedef struct VkInstanceCreateInfo { - VkStructureType sType; - const void* pNext; - VkInstanceCreateFlags flags; - const VkApplicationInfo* pApplicationInfo; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; -} VkInstanceCreateInfo; - -typedef struct VkMemoryHeap { - VkDeviceSize size; - VkMemoryHeapFlags flags; -} VkMemoryHeap; - -typedef struct VkMemoryType { - VkMemoryPropertyFlags propertyFlags; - uint32_t heapIndex; -} VkMemoryType; - -typedef struct VkPhysicalDeviceFeatures { - VkBool32 robustBufferAccess; - VkBool32 fullDrawIndexUint32; - VkBool32 imageCubeArray; - VkBool32 independentBlend; - VkBool32 geometryShader; - VkBool32 tessellationShader; - VkBool32 sampleRateShading; - VkBool32 dualSrcBlend; - VkBool32 logicOp; - VkBool32 multiDrawIndirect; - VkBool32 drawIndirectFirstInstance; - VkBool32 depthClamp; - VkBool32 depthBiasClamp; - VkBool32 fillModeNonSolid; - VkBool32 depthBounds; - VkBool32 wideLines; - VkBool32 largePoints; - VkBool32 alphaToOne; - VkBool32 multiViewport; - VkBool32 samplerAnisotropy; - VkBool32 textureCompressionETC2; - VkBool32 textureCompressionASTC_LDR; - VkBool32 textureCompressionBC; - VkBool32 occlusionQueryPrecise; - VkBool32 pipelineStatisticsQuery; - VkBool32 vertexPipelineStoresAndAtomics; - VkBool32 fragmentStoresAndAtomics; - VkBool32 shaderTessellationAndGeometryPointSize; - VkBool32 shaderImageGatherExtended; - VkBool32 shaderStorageImageExtendedFormats; - VkBool32 shaderStorageImageMultisample; - VkBool32 shaderStorageImageReadWithoutFormat; - VkBool32 shaderStorageImageWriteWithoutFormat; - VkBool32 shaderUniformBufferArrayDynamicIndexing; - VkBool32 shaderSampledImageArrayDynamicIndexing; - VkBool32 shaderStorageBufferArrayDynamicIndexing; - VkBool32 shaderStorageImageArrayDynamicIndexing; - VkBool32 shaderClipDistance; - VkBool32 shaderCullDistance; - VkBool32 shaderFloat64; - VkBool32 shaderInt64; - VkBool32 shaderInt16; - VkBool32 shaderResourceResidency; - VkBool32 shaderResourceMinLod; - VkBool32 sparseBinding; - VkBool32 sparseResidencyBuffer; - VkBool32 sparseResidencyImage2D; - VkBool32 sparseResidencyImage3D; - VkBool32 sparseResidency2Samples; - VkBool32 sparseResidency4Samples; - VkBool32 sparseResidency8Samples; - VkBool32 sparseResidency16Samples; - VkBool32 sparseResidencyAliased; - VkBool32 variableMultisampleRate; - VkBool32 inheritedQueries; -} VkPhysicalDeviceFeatures; - -typedef struct VkPhysicalDeviceLimits { - uint32_t maxImageDimension1D; - uint32_t maxImageDimension2D; - uint32_t maxImageDimension3D; - uint32_t maxImageDimensionCube; - uint32_t maxImageArrayLayers; - uint32_t maxTexelBufferElements; - uint32_t maxUniformBufferRange; - uint32_t maxStorageBufferRange; - uint32_t maxPushConstantsSize; - uint32_t maxMemoryAllocationCount; - uint32_t maxSamplerAllocationCount; - VkDeviceSize bufferImageGranularity; - VkDeviceSize sparseAddressSpaceSize; - uint32_t maxBoundDescriptorSets; - uint32_t maxPerStageDescriptorSamplers; - uint32_t maxPerStageDescriptorUniformBuffers; - uint32_t maxPerStageDescriptorStorageBuffers; - uint32_t maxPerStageDescriptorSampledImages; - uint32_t maxPerStageDescriptorStorageImages; - uint32_t maxPerStageDescriptorInputAttachments; - uint32_t maxPerStageResources; - uint32_t maxDescriptorSetSamplers; - uint32_t maxDescriptorSetUniformBuffers; - uint32_t maxDescriptorSetUniformBuffersDynamic; - uint32_t maxDescriptorSetStorageBuffers; - uint32_t maxDescriptorSetStorageBuffersDynamic; - uint32_t maxDescriptorSetSampledImages; - uint32_t maxDescriptorSetStorageImages; - uint32_t maxDescriptorSetInputAttachments; - uint32_t maxVertexInputAttributes; - uint32_t maxVertexInputBindings; - uint32_t maxVertexInputAttributeOffset; - uint32_t maxVertexInputBindingStride; - uint32_t maxVertexOutputComponents; - uint32_t maxTessellationGenerationLevel; - uint32_t maxTessellationPatchSize; - uint32_t maxTessellationControlPerVertexInputComponents; - uint32_t maxTessellationControlPerVertexOutputComponents; - uint32_t maxTessellationControlPerPatchOutputComponents; - uint32_t maxTessellationControlTotalOutputComponents; - uint32_t maxTessellationEvaluationInputComponents; - uint32_t maxTessellationEvaluationOutputComponents; - uint32_t maxGeometryShaderInvocations; - uint32_t maxGeometryInputComponents; - uint32_t maxGeometryOutputComponents; - uint32_t maxGeometryOutputVertices; - uint32_t maxGeometryTotalOutputComponents; - uint32_t maxFragmentInputComponents; - uint32_t maxFragmentOutputAttachments; - uint32_t maxFragmentDualSrcAttachments; - uint32_t maxFragmentCombinedOutputResources; - uint32_t maxComputeSharedMemorySize; - uint32_t maxComputeWorkGroupCount[3]; - uint32_t maxComputeWorkGroupInvocations; - uint32_t maxComputeWorkGroupSize[3]; - uint32_t subPixelPrecisionBits; - uint32_t subTexelPrecisionBits; - uint32_t mipmapPrecisionBits; - uint32_t maxDrawIndexedIndexValue; - uint32_t maxDrawIndirectCount; - float maxSamplerLodBias; - float maxSamplerAnisotropy; - uint32_t maxViewports; - uint32_t maxViewportDimensions[2]; - float viewportBoundsRange[2]; - uint32_t viewportSubPixelBits; - size_t minMemoryMapAlignment; - VkDeviceSize minTexelBufferOffsetAlignment; - VkDeviceSize minUniformBufferOffsetAlignment; - VkDeviceSize minStorageBufferOffsetAlignment; - int32_t minTexelOffset; - uint32_t maxTexelOffset; - int32_t minTexelGatherOffset; - uint32_t maxTexelGatherOffset; - float minInterpolationOffset; - float maxInterpolationOffset; - uint32_t subPixelInterpolationOffsetBits; - uint32_t maxFramebufferWidth; - uint32_t maxFramebufferHeight; - uint32_t maxFramebufferLayers; - VkSampleCountFlags framebufferColorSampleCounts; - VkSampleCountFlags framebufferDepthSampleCounts; - VkSampleCountFlags framebufferStencilSampleCounts; - VkSampleCountFlags framebufferNoAttachmentsSampleCounts; - uint32_t maxColorAttachments; - VkSampleCountFlags sampledImageColorSampleCounts; - VkSampleCountFlags sampledImageIntegerSampleCounts; - VkSampleCountFlags sampledImageDepthSampleCounts; - VkSampleCountFlags sampledImageStencilSampleCounts; - VkSampleCountFlags storageImageSampleCounts; - uint32_t maxSampleMaskWords; - VkBool32 timestampComputeAndGraphics; - float timestampPeriod; - uint32_t maxClipDistances; - uint32_t maxCullDistances; - uint32_t maxCombinedClipAndCullDistances; - uint32_t discreteQueuePriorities; - float pointSizeRange[2]; - float lineWidthRange[2]; - float pointSizeGranularity; - float lineWidthGranularity; - VkBool32 strictLines; - VkBool32 standardSampleLocations; - VkDeviceSize optimalBufferCopyOffsetAlignment; - VkDeviceSize optimalBufferCopyRowPitchAlignment; - VkDeviceSize nonCoherentAtomSize; -} VkPhysicalDeviceLimits; - -typedef struct VkPhysicalDeviceMemoryProperties { - uint32_t memoryTypeCount; - VkMemoryType memoryTypes[32U]; - uint32_t memoryHeapCount; - VkMemoryHeap memoryHeaps[16U]; -} VkPhysicalDeviceMemoryProperties; - -typedef struct VkPhysicalDeviceSparseProperties { - VkBool32 residencyStandard2DBlockShape; - VkBool32 residencyStandard2DMultisampleBlockShape; - VkBool32 residencyStandard3DBlockShape; - VkBool32 residencyAlignedMipSize; - VkBool32 residencyNonResidentStrict; -} VkPhysicalDeviceSparseProperties; - -typedef struct VkPhysicalDeviceProperties { - uint32_t apiVersion; - uint32_t driverVersion; - uint32_t vendorID; - uint32_t deviceID; - VkPhysicalDeviceType deviceType; - char deviceName[256U]; - uint8_t pipelineCacheUUID[16U]; - VkPhysicalDeviceLimits limits; - VkPhysicalDeviceSparseProperties sparseProperties; -} VkPhysicalDeviceProperties; - -typedef struct VkQueueFamilyProperties { - VkQueueFlags queueFlags; - uint32_t queueCount; - uint32_t timestampValidBits; - VkExtent3D minImageTransferGranularity; -} VkQueueFamilyProperties; - -typedef struct VkDeviceQueueCreateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueCount; - const float* pQueuePriorities; -} VkDeviceQueueCreateInfo; - -typedef struct VkDeviceCreateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceCreateFlags flags; - uint32_t queueCreateInfoCount; - const VkDeviceQueueCreateInfo* pQueueCreateInfos; - uint32_t enabledLayerCount; - const char* const* ppEnabledLayerNames; - uint32_t enabledExtensionCount; - const char* const* ppEnabledExtensionNames; - const VkPhysicalDeviceFeatures* pEnabledFeatures; -} VkDeviceCreateInfo; - -typedef struct VkExtensionProperties { - char extensionName[256U]; - uint32_t specVersion; -} VkExtensionProperties; - -typedef struct VkLayerProperties { - char layerName[256U]; - uint32_t specVersion; - uint32_t implementationVersion; - char description[256U]; -} VkLayerProperties; - -typedef struct VkSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - const VkPipelineStageFlags* pWaitDstStageMask; - uint32_t commandBufferCount; - const VkCommandBuffer* pCommandBuffers; - uint32_t signalSemaphoreCount; - const VkSemaphore* pSignalSemaphores; -} VkSubmitInfo; - -typedef struct VkMappedMemoryRange { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkDeviceSize offset; - VkDeviceSize size; -} VkMappedMemoryRange; - -typedef struct VkMemoryAllocateInfo { - VkStructureType sType; - const void* pNext; - VkDeviceSize allocationSize; - uint32_t memoryTypeIndex; -} VkMemoryAllocateInfo; - -typedef struct VkMemoryRequirements { - VkDeviceSize size; - VkDeviceSize alignment; - uint32_t memoryTypeBits; -} VkMemoryRequirements; - -typedef struct VkSparseMemoryBind { - VkDeviceSize resourceOffset; - VkDeviceSize size; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseMemoryBind; - -typedef struct VkSparseBufferMemoryBindInfo { - VkBuffer buffer; - uint32_t bindCount; - const VkSparseMemoryBind* pBinds; -} VkSparseBufferMemoryBindInfo; - -typedef struct VkSparseImageOpaqueMemoryBindInfo { - VkImage image; - uint32_t bindCount; - const VkSparseMemoryBind* pBinds; -} VkSparseImageOpaqueMemoryBindInfo; - -typedef struct VkImageSubresource { - VkImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t arrayLayer; -} VkImageSubresource; - -typedef struct VkSparseImageMemoryBind { - VkImageSubresource subresource; - VkOffset3D offset; - VkExtent3D extent; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkSparseMemoryBindFlags flags; -} VkSparseImageMemoryBind; - -typedef struct VkSparseImageMemoryBindInfo { - VkImage image; - uint32_t bindCount; - const VkSparseImageMemoryBind* pBinds; -} VkSparseImageMemoryBindInfo; - -typedef struct VkBindSparseInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - uint32_t bufferBindCount; - const VkSparseBufferMemoryBindInfo* pBufferBinds; - uint32_t imageOpaqueBindCount; - const VkSparseImageOpaqueMemoryBindInfo* pImageOpaqueBinds; - uint32_t imageBindCount; - const VkSparseImageMemoryBindInfo* pImageBinds; - uint32_t signalSemaphoreCount; - const VkSemaphore* pSignalSemaphores; -} VkBindSparseInfo; - -typedef struct VkSparseImageFormatProperties { - VkImageAspectFlags aspectMask; - VkExtent3D imageGranularity; - VkSparseImageFormatFlags flags; -} VkSparseImageFormatProperties; - -typedef struct VkSparseImageMemoryRequirements { - VkSparseImageFormatProperties formatProperties; - uint32_t imageMipTailFirstLod; - VkDeviceSize imageMipTailSize; - VkDeviceSize imageMipTailOffset; - VkDeviceSize imageMipTailStride; -} VkSparseImageMemoryRequirements; - -typedef struct VkFenceCreateInfo { - VkStructureType sType; - const void* pNext; - VkFenceCreateFlags flags; -} VkFenceCreateInfo; - -typedef struct VkSemaphoreCreateInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreCreateFlags flags; -} VkSemaphoreCreateInfo; - -typedef struct VkEventCreateInfo { - VkStructureType sType; - const void* pNext; - VkEventCreateFlags flags; -} VkEventCreateInfo; - -typedef struct VkQueryPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkQueryPoolCreateFlags flags; - VkQueryType queryType; - uint32_t queryCount; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkQueryPoolCreateInfo; - -typedef struct VkBufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferCreateFlags flags; - VkDeviceSize size; - VkBufferUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; -} VkBufferCreateInfo; - -typedef struct VkBufferViewCreateInfo { - VkStructureType sType; - const void* pNext; - VkBufferViewCreateFlags flags; - VkBuffer buffer; - VkFormat format; - VkDeviceSize offset; - VkDeviceSize range; -} VkBufferViewCreateInfo; - -typedef struct VkImageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageCreateFlags flags; - VkImageType imageType; - VkFormat format; - VkExtent3D extent; - uint32_t mipLevels; - uint32_t arrayLayers; - VkSampleCountFlagBits samples; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - VkImageLayout initialLayout; -} VkImageCreateInfo; - -typedef struct VkSubresourceLayout { - VkDeviceSize offset; - VkDeviceSize size; - VkDeviceSize rowPitch; - VkDeviceSize arrayPitch; - VkDeviceSize depthPitch; -} VkSubresourceLayout; - -typedef struct VkComponentMapping { - VkComponentSwizzle r; - VkComponentSwizzle g; - VkComponentSwizzle b; - VkComponentSwizzle a; -} VkComponentMapping; - -typedef struct VkImageViewCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageViewCreateFlags flags; - VkImage image; - VkImageViewType viewType; - VkFormat format; - VkComponentMapping components; - VkImageSubresourceRange subresourceRange; -} VkImageViewCreateInfo; - -typedef struct VkShaderModuleCreateInfo { - VkStructureType sType; - const void* pNext; - VkShaderModuleCreateFlags flags; - size_t codeSize; - const uint32_t* pCode; -} VkShaderModuleCreateInfo; - -typedef struct VkPipelineCacheCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCacheCreateFlags flags; - size_t initialDataSize; - const void* pInitialData; -} VkPipelineCacheCreateInfo; - -typedef struct VkSpecializationMapEntry { - uint32_t constantID; - uint32_t offset; - size_t size; -} VkSpecializationMapEntry; - -typedef struct VkSpecializationInfo { - uint32_t mapEntryCount; - const VkSpecializationMapEntry* pMapEntries; - size_t dataSize; - const void* pData; -} VkSpecializationInfo; - -typedef struct VkPipelineShaderStageCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineShaderStageCreateFlags flags; - VkShaderStageFlagBits stage; - VkShaderModule module; - const char* pName; - const VkSpecializationInfo* pSpecializationInfo; -} VkPipelineShaderStageCreateInfo; - -typedef struct VkComputePipelineCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - VkPipelineShaderStageCreateInfo stage; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkComputePipelineCreateInfo; - -typedef struct VkVertexInputBindingDescription { - uint32_t binding; - uint32_t stride; - VkVertexInputRate inputRate; -} VkVertexInputBindingDescription; - -typedef struct VkVertexInputAttributeDescription { - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offset; -} VkVertexInputAttributeDescription; - -typedef struct VkPipelineVertexInputStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineVertexInputStateCreateFlags flags; - uint32_t vertexBindingDescriptionCount; - const VkVertexInputBindingDescription* pVertexBindingDescriptions; - uint32_t vertexAttributeDescriptionCount; - const VkVertexInputAttributeDescription* pVertexAttributeDescriptions; -} VkPipelineVertexInputStateCreateInfo; - -typedef struct VkPipelineInputAssemblyStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineInputAssemblyStateCreateFlags flags; - VkPrimitiveTopology topology; - VkBool32 primitiveRestartEnable; -} VkPipelineInputAssemblyStateCreateInfo; - -typedef struct VkPipelineTessellationStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineTessellationStateCreateFlags flags; - uint32_t patchControlPoints; -} VkPipelineTessellationStateCreateInfo; - -typedef struct VkViewport { - float x; - float y; - float width; - float height; - float minDepth; - float maxDepth; -} VkViewport; - -typedef struct VkPipelineViewportStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineViewportStateCreateFlags flags; - uint32_t viewportCount; - const VkViewport* pViewports; - uint32_t scissorCount; - const VkRect2D* pScissors; -} VkPipelineViewportStateCreateInfo; - -typedef struct VkPipelineRasterizationStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationStateCreateFlags flags; - VkBool32 depthClampEnable; - VkBool32 rasterizerDiscardEnable; - VkPolygonMode polygonMode; - VkCullModeFlags cullMode; - VkFrontFace frontFace; - VkBool32 depthBiasEnable; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; - float lineWidth; -} VkPipelineRasterizationStateCreateInfo; - -typedef struct VkPipelineMultisampleStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineMultisampleStateCreateFlags flags; - VkSampleCountFlagBits rasterizationSamples; - VkBool32 sampleShadingEnable; - float minSampleShading; - const VkSampleMask* pSampleMask; - VkBool32 alphaToCoverageEnable; - VkBool32 alphaToOneEnable; -} VkPipelineMultisampleStateCreateInfo; - -typedef struct VkStencilOpState { - VkStencilOp failOp; - VkStencilOp passOp; - VkStencilOp depthFailOp; - VkCompareOp compareOp; - uint32_t compareMask; - uint32_t writeMask; - uint32_t reference; -} VkStencilOpState; - -typedef struct VkPipelineDepthStencilStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineDepthStencilStateCreateFlags flags; - VkBool32 depthTestEnable; - VkBool32 depthWriteEnable; - VkCompareOp depthCompareOp; - VkBool32 depthBoundsTestEnable; - VkBool32 stencilTestEnable; - VkStencilOpState front; - VkStencilOpState back; - float minDepthBounds; - float maxDepthBounds; -} VkPipelineDepthStencilStateCreateInfo; - -typedef struct VkPipelineColorBlendAttachmentState { - VkBool32 blendEnable; - VkBlendFactor srcColorBlendFactor; - VkBlendFactor dstColorBlendFactor; - VkBlendOp colorBlendOp; - VkBlendFactor srcAlphaBlendFactor; - VkBlendFactor dstAlphaBlendFactor; - VkBlendOp alphaBlendOp; - VkColorComponentFlags colorWriteMask; -} VkPipelineColorBlendAttachmentState; - -typedef struct VkPipelineColorBlendStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineColorBlendStateCreateFlags flags; - VkBool32 logicOpEnable; - VkLogicOp logicOp; - uint32_t attachmentCount; - const VkPipelineColorBlendAttachmentState* pAttachments; - float blendConstants[4]; -} VkPipelineColorBlendStateCreateInfo; - -typedef struct VkPipelineDynamicStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineDynamicStateCreateFlags flags; - uint32_t dynamicStateCount; - const VkDynamicState* pDynamicStates; -} VkPipelineDynamicStateCreateInfo; - -typedef struct VkGraphicsPipelineCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState; - const VkPipelineTessellationStateCreateInfo* pTessellationState; - const VkPipelineViewportStateCreateInfo* pViewportState; - const VkPipelineRasterizationStateCreateInfo* pRasterizationState; - const VkPipelineMultisampleStateCreateInfo* pMultisampleState; - const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState; - const VkPipelineColorBlendStateCreateInfo* pColorBlendState; - const VkPipelineDynamicStateCreateInfo* pDynamicState; - VkPipelineLayout layout; - VkRenderPass renderPass; - uint32_t subpass; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkGraphicsPipelineCreateInfo; - -typedef struct VkPushConstantRange { - VkShaderStageFlags stageFlags; - uint32_t offset; - uint32_t size; -} VkPushConstantRange; - -typedef struct VkPipelineLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineLayoutCreateFlags flags; - uint32_t setLayoutCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; -} VkPipelineLayoutCreateInfo; - -typedef struct VkSamplerCreateInfo { - VkStructureType sType; - const void* pNext; - VkSamplerCreateFlags flags; - VkFilter magFilter; - VkFilter minFilter; - VkSamplerMipmapMode mipmapMode; - VkSamplerAddressMode addressModeU; - VkSamplerAddressMode addressModeV; - VkSamplerAddressMode addressModeW; - float mipLodBias; - VkBool32 anisotropyEnable; - float maxAnisotropy; - VkBool32 compareEnable; - VkCompareOp compareOp; - float minLod; - float maxLod; - VkBorderColor borderColor; - VkBool32 unnormalizedCoordinates; -} VkSamplerCreateInfo; - -typedef struct VkCopyDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet srcSet; - uint32_t srcBinding; - uint32_t srcArrayElement; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; -} VkCopyDescriptorSet; - -typedef struct VkDescriptorBufferInfo { - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize range; -} VkDescriptorBufferInfo; - -typedef struct VkDescriptorImageInfo { - VkSampler sampler; - VkImageView imageView; - VkImageLayout imageLayout; -} VkDescriptorImageInfo; - -typedef struct VkDescriptorPoolSize { - VkDescriptorType type; - uint32_t descriptorCount; -} VkDescriptorPoolSize; - -typedef struct VkDescriptorPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPoolCreateFlags flags; - uint32_t maxSets; - uint32_t poolSizeCount; - const VkDescriptorPoolSize* pPoolSizes; -} VkDescriptorPoolCreateInfo; - -typedef struct VkDescriptorSetAllocateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorPool descriptorPool; - uint32_t descriptorSetCount; - const VkDescriptorSetLayout* pSetLayouts; -} VkDescriptorSetAllocateInfo; - -typedef struct VkDescriptorSetLayoutBinding { - uint32_t binding; - VkDescriptorType descriptorType; - uint32_t descriptorCount; - VkShaderStageFlags stageFlags; - const VkSampler* pImmutableSamplers; -} VkDescriptorSetLayoutBinding; - -typedef struct VkDescriptorSetLayoutCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorSetLayoutCreateFlags flags; - uint32_t bindingCount; - const VkDescriptorSetLayoutBinding* pBindings; -} VkDescriptorSetLayoutCreateInfo; - -typedef struct VkWriteDescriptorSet { - VkStructureType sType; - const void* pNext; - VkDescriptorSet dstSet; - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - const VkDescriptorImageInfo* pImageInfo; - const VkDescriptorBufferInfo* pBufferInfo; - const VkBufferView* pTexelBufferView; -} VkWriteDescriptorSet; - -typedef struct VkAttachmentDescription { - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription; - -typedef struct VkAttachmentReference { - uint32_t attachment; - VkImageLayout layout; -} VkAttachmentReference; - -typedef struct VkFramebufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkFramebufferCreateFlags flags; - VkRenderPass renderPass; - uint32_t attachmentCount; - const VkImageView* pAttachments; - uint32_t width; - uint32_t height; - uint32_t layers; -} VkFramebufferCreateInfo; - -typedef struct VkSubpassDescription { - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t inputAttachmentCount; - const VkAttachmentReference* pInputAttachments; - uint32_t colorAttachmentCount; - const VkAttachmentReference* pColorAttachments; - const VkAttachmentReference* pResolveAttachments; - const VkAttachmentReference* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; -} VkSubpassDescription; - -typedef struct VkSubpassDependency { - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; -} VkSubpassDependency; - -typedef struct VkRenderPassCreateInfo { - VkStructureType sType; - const void* pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - const VkAttachmentDescription* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency* pDependencies; -} VkRenderPassCreateInfo; - -typedef struct VkCommandPoolCreateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPoolCreateFlags flags; - uint32_t queueFamilyIndex; -} VkCommandPoolCreateInfo; - -typedef struct VkCommandBufferAllocateInfo { - VkStructureType sType; - const void* pNext; - VkCommandPool commandPool; - VkCommandBufferLevel level; - uint32_t commandBufferCount; -} VkCommandBufferAllocateInfo; - -typedef struct VkCommandBufferInheritanceInfo { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - uint32_t subpass; - VkFramebuffer framebuffer; - VkBool32 occlusionQueryEnable; - VkQueryControlFlags queryFlags; - VkQueryPipelineStatisticFlags pipelineStatistics; -} VkCommandBufferInheritanceInfo; - -typedef struct VkCommandBufferBeginInfo { - VkStructureType sType; - const void* pNext; - VkCommandBufferUsageFlags flags; - const VkCommandBufferInheritanceInfo* pInheritanceInfo; -} VkCommandBufferBeginInfo; - -typedef struct VkBufferCopy { - VkDeviceSize srcOffset; - VkDeviceSize dstOffset; - VkDeviceSize size; -} VkBufferCopy; - -typedef struct VkImageSubresourceLayers { - VkImageAspectFlags aspectMask; - uint32_t mipLevel; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkImageSubresourceLayers; - -typedef struct VkBufferImageCopy { - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy; - -typedef union VkClearColorValue { - float float32[4]; - int32_t int32[4]; - uint32_t uint32[4]; -} VkClearColorValue; - -typedef struct VkClearDepthStencilValue { - float depth; - uint32_t stencil; -} VkClearDepthStencilValue; - -typedef union VkClearValue { - VkClearColorValue color; - VkClearDepthStencilValue depthStencil; -} VkClearValue; - -typedef struct VkClearAttachment { - VkImageAspectFlags aspectMask; - uint32_t colorAttachment; - VkClearValue clearValue; -} VkClearAttachment; - -typedef struct VkClearRect { - VkRect2D rect; - uint32_t baseArrayLayer; - uint32_t layerCount; -} VkClearRect; - -typedef struct VkImageBlit { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffsets[2]; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffsets[2]; -} VkImageBlit; - -typedef struct VkImageCopy { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy; - -typedef struct VkImageResolve { - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve; - -typedef struct VkRenderPassBeginInfo { - VkStructureType sType; - const void* pNext; - VkRenderPass renderPass; - VkFramebuffer framebuffer; - VkRect2D renderArea; - uint32_t clearValueCount; - const VkClearValue* pClearValues; -} VkRenderPassBeginInfo; - -typedef VkResult ( *PFN_vkCreateInstance)(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance); -typedef void ( *PFN_vkDestroyInstance)(VkInstance instance, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkEnumeratePhysicalDevices)(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); -typedef void ( *PFN_vkGetPhysicalDeviceFeatures)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); -typedef void ( *PFN_vkGetPhysicalDeviceFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); -typedef VkResult ( *PFN_vkGetPhysicalDeviceImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); -typedef void ( *PFN_vkGetPhysicalDeviceProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); -typedef void ( *PFN_vkGetPhysicalDeviceQueueFamilyProperties)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); -typedef void ( *PFN_vkGetPhysicalDeviceMemoryProperties)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); -typedef PFN_vkVoidFunction ( *PFN_vkGetInstanceProcAddr)(VkInstance instance, const char* pName); -typedef PFN_vkVoidFunction ( *PFN_vkGetDeviceProcAddr)(VkDevice device, const char* pName); -typedef VkResult ( *PFN_vkCreateDevice)(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice); -typedef void ( *PFN_vkDestroyDevice)(VkDevice device, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkEnumerateInstanceExtensionProperties)(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -typedef VkResult ( *PFN_vkEnumerateDeviceExtensionProperties)(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties); -typedef VkResult ( *PFN_vkEnumerateInstanceLayerProperties)(uint32_t* pPropertyCount, VkLayerProperties* pProperties); -typedef VkResult ( *PFN_vkEnumerateDeviceLayerProperties)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties); -typedef void ( *PFN_vkGetDeviceQueue)(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); -typedef VkResult ( *PFN_vkQueueSubmit)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); -typedef VkResult ( *PFN_vkQueueWaitIdle)(VkQueue queue); -typedef VkResult ( *PFN_vkDeviceWaitIdle)(VkDevice device); -typedef VkResult ( *PFN_vkAllocateMemory)(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); -typedef void ( *PFN_vkFreeMemory)(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkMapMemory)(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); -typedef void ( *PFN_vkUnmapMemory)(VkDevice device, VkDeviceMemory memory); -typedef VkResult ( *PFN_vkFlushMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); -typedef VkResult ( *PFN_vkInvalidateMappedMemoryRanges)(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); -typedef void ( *PFN_vkGetDeviceMemoryCommitment)(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); -typedef VkResult ( *PFN_vkBindBufferMemory)(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); -typedef VkResult ( *PFN_vkBindImageMemory)(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); -typedef void ( *PFN_vkGetBufferMemoryRequirements)(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); -typedef void ( *PFN_vkGetImageMemoryRequirements)(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); -typedef void ( *PFN_vkGetImageSparseMemoryRequirements)(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); -typedef void ( *PFN_vkGetPhysicalDeviceSparseImageFormatProperties)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); -typedef VkResult ( *PFN_vkQueueBindSparse)(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); -typedef VkResult ( *PFN_vkCreateFence)(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef void ( *PFN_vkDestroyFence)(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkResetFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences); -typedef VkResult ( *PFN_vkGetFenceStatus)(VkDevice device, VkFence fence); -typedef VkResult ( *PFN_vkWaitForFences)(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); -typedef VkResult ( *PFN_vkCreateSemaphore)(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); -typedef void ( *PFN_vkDestroySemaphore)(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreateEvent)(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); -typedef void ( *PFN_vkDestroyEvent)(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkGetEventStatus)(VkDevice device, VkEvent event); -typedef VkResult ( *PFN_vkSetEvent)(VkDevice device, VkEvent event); -typedef VkResult ( *PFN_vkResetEvent)(VkDevice device, VkEvent event); -typedef VkResult ( *PFN_vkCreateQueryPool)(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); -typedef void ( *PFN_vkDestroyQueryPool)(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkGetQueryPoolResults)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); -typedef VkResult ( *PFN_vkCreateBuffer)(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); -typedef void ( *PFN_vkDestroyBuffer)(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreateBufferView)(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); -typedef void ( *PFN_vkDestroyBufferView)(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreateImage)(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); -typedef void ( *PFN_vkDestroyImage)(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkGetImageSubresourceLayout)(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); -typedef VkResult ( *PFN_vkCreateImageView)(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); -typedef void ( *PFN_vkDestroyImageView)(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreateShaderModule)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); -typedef void ( *PFN_vkDestroyShaderModule)(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreatePipelineCache)(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); -typedef void ( *PFN_vkDestroyPipelineCache)(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkGetPipelineCacheData)(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); -typedef VkResult ( *PFN_vkMergePipelineCaches)(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); -typedef VkResult ( *PFN_vkCreateGraphicsPipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult ( *PFN_vkCreateComputePipelines)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef void ( *PFN_vkDestroyPipeline)(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreatePipelineLayout)(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); -typedef void ( *PFN_vkDestroyPipelineLayout)(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreateSampler)(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); -typedef void ( *PFN_vkDestroySampler)(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreateDescriptorSetLayout)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); -typedef void ( *PFN_vkDestroyDescriptorSetLayout)(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreateDescriptorPool)(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); -typedef void ( *PFN_vkDestroyDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkResetDescriptorPool)(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); -typedef VkResult ( *PFN_vkAllocateDescriptorSets)(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); -typedef VkResult ( *PFN_vkFreeDescriptorSets)(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); -typedef void ( *PFN_vkUpdateDescriptorSets)(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); -typedef VkResult ( *PFN_vkCreateFramebuffer)(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); -typedef void ( *PFN_vkDestroyFramebuffer)(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreateRenderPass)(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void ( *PFN_vkDestroyRenderPass)(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkGetRenderAreaGranularity)(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); -typedef VkResult ( *PFN_vkCreateCommandPool)(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); -typedef void ( *PFN_vkDestroyCommandPool)(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkResetCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); -typedef VkResult ( *PFN_vkAllocateCommandBuffers)(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); -typedef void ( *PFN_vkFreeCommandBuffers)(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); -typedef VkResult ( *PFN_vkBeginCommandBuffer)(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); -typedef VkResult ( *PFN_vkEndCommandBuffer)(VkCommandBuffer commandBuffer); -typedef VkResult ( *PFN_vkResetCommandBuffer)(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); -typedef void ( *PFN_vkCmdBindPipeline)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef void ( *PFN_vkCmdSetViewport)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); -typedef void ( *PFN_vkCmdSetScissor)(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void ( *PFN_vkCmdSetLineWidth)(VkCommandBuffer commandBuffer, float lineWidth); -typedef void ( *PFN_vkCmdSetDepthBias)(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); -typedef void ( *PFN_vkCmdSetBlendConstants)(VkCommandBuffer commandBuffer, const float blendConstants[4]); -typedef void ( *PFN_vkCmdSetDepthBounds)(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); -typedef void ( *PFN_vkCmdSetStencilCompareMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); -typedef void ( *PFN_vkCmdSetStencilWriteMask)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); -typedef void ( *PFN_vkCmdSetStencilReference)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); -typedef void ( *PFN_vkCmdBindDescriptorSets)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); -typedef void ( *PFN_vkCmdBindIndexBuffer)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); -typedef void ( *PFN_vkCmdBindVertexBuffers)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); -typedef void ( *PFN_vkCmdDraw)(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); -typedef void ( *PFN_vkCmdDrawIndexed)(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); -typedef void ( *PFN_vkCmdDrawIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void ( *PFN_vkCmdDrawIndexedIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void ( *PFN_vkCmdDispatch)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef void ( *PFN_vkCmdDispatchIndirect)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); -typedef void ( *PFN_vkCmdCopyBuffer)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); -typedef void ( *PFN_vkCmdCopyImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); -typedef void ( *PFN_vkCmdBlitImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); -typedef void ( *PFN_vkCmdCopyBufferToImage)(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void ( *PFN_vkCmdCopyImageToBuffer)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); -typedef void ( *PFN_vkCmdUpdateBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData); -typedef void ( *PFN_vkCmdFillBuffer)(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); -typedef void ( *PFN_vkCmdClearColorImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void ( *PFN_vkCmdClearDepthStencilImage)(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); -typedef void ( *PFN_vkCmdClearAttachments)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); -typedef void ( *PFN_vkCmdResolveImage)(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); -typedef void ( *PFN_vkCmdSetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void ( *PFN_vkCmdResetEvent)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); -typedef void ( *PFN_vkCmdWaitEvents)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void ( *PFN_vkCmdPipelineBarrier)(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers); -typedef void ( *PFN_vkCmdBeginQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); -typedef void ( *PFN_vkCmdEndQuery)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); -typedef void ( *PFN_vkCmdResetQueryPool)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -typedef void ( *PFN_vkCmdWriteTimestamp)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); -typedef void ( *PFN_vkCmdCopyQueryPoolResults)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); -typedef void ( *PFN_vkCmdPushConstants)(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); -typedef void ( *PFN_vkCmdBeginRenderPass)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); -typedef void ( *PFN_vkCmdNextSubpass)(VkCommandBuffer commandBuffer, VkSubpassContents contents); -typedef void ( *PFN_vkCmdEndRenderPass)(VkCommandBuffer commandBuffer); -typedef void ( *PFN_vkCmdExecuteCommands)(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); -# 4933 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkSamplerYcbcrConversion_T *VkSamplerYcbcrConversion; -typedef struct VkDescriptorUpdateTemplate_T *VkDescriptorUpdateTemplate; - - - - -typedef enum VkPointClippingBehavior { - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES = 0, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY = 1, - VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES, - VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR = VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY, - VK_POINT_CLIPPING_BEHAVIOR_MAX_ENUM = 0x7FFFFFFF -} VkPointClippingBehavior; - -typedef enum VkTessellationDomainOrigin { - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT = 0, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT = 1, - VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR = VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT, - VK_TESSELLATION_DOMAIN_ORIGIN_MAX_ENUM = 0x7FFFFFFF -} VkTessellationDomainOrigin; - -typedef enum VkSamplerYcbcrModelConversion { - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY = 0, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY = 1, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 = 2, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 = 3, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 = 4, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR = VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020, - VK_SAMPLER_YCBCR_MODEL_CONVERSION_MAX_ENUM = 0x7FFFFFFF -} VkSamplerYcbcrModelConversion; - -typedef enum VkSamplerYcbcrRange { - VK_SAMPLER_YCBCR_RANGE_ITU_FULL = 0, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW = 1, - VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_FULL, - VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR = VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, - VK_SAMPLER_YCBCR_RANGE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerYcbcrRange; - -typedef enum VkChromaLocation { - VK_CHROMA_LOCATION_COSITED_EVEN = 0, - VK_CHROMA_LOCATION_MIDPOINT = 1, - VK_CHROMA_LOCATION_COSITED_EVEN_KHR = VK_CHROMA_LOCATION_COSITED_EVEN, - VK_CHROMA_LOCATION_MIDPOINT_KHR = VK_CHROMA_LOCATION_MIDPOINT, - VK_CHROMA_LOCATION_MAX_ENUM = 0x7FFFFFFF -} VkChromaLocation; - -typedef enum VkDescriptorUpdateTemplateType { - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET = 0, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR = 1, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR = VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET, - VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorUpdateTemplateType; - -typedef enum VkSubgroupFeatureFlagBits { - VK_SUBGROUP_FEATURE_BASIC_BIT = 0x00000001, - VK_SUBGROUP_FEATURE_VOTE_BIT = 0x00000002, - VK_SUBGROUP_FEATURE_ARITHMETIC_BIT = 0x00000004, - VK_SUBGROUP_FEATURE_BALLOT_BIT = 0x00000008, - VK_SUBGROUP_FEATURE_SHUFFLE_BIT = 0x00000010, - VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT = 0x00000020, - VK_SUBGROUP_FEATURE_CLUSTERED_BIT = 0x00000040, - VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080, - VK_SUBGROUP_FEATURE_PARTITIONED_BIT_NV = 0x00000100, - VK_SUBGROUP_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubgroupFeatureFlagBits; -typedef VkFlags VkSubgroupFeatureFlags; - -typedef enum VkPeerMemoryFeatureFlagBits { - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT = 0x00000001, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT = 0x00000002, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT = 0x00000004, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008, - VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, - VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, - VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, - VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR = VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, - VK_PEER_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPeerMemoryFeatureFlagBits; -typedef VkFlags VkPeerMemoryFeatureFlags; - -typedef enum VkMemoryAllocateFlagBits { - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT = 0x00000002, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT = 0x00000004, - VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_BIT, - VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = VK_MEMORY_ALLOCATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT, - VK_MEMORY_ALLOCATE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkMemoryAllocateFlagBits; -typedef VkFlags VkMemoryAllocateFlags; -typedef VkFlags VkCommandPoolTrimFlags; -typedef VkFlags VkDescriptorUpdateTemplateCreateFlags; - -typedef enum VkExternalMemoryHandleTypeFlagBits { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT = 0x00000010, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT = 0x00000020, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT = 0x00000040, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_DMA_BUF_BIT_EXT = 0x00000200, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000400, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_ALLOCATION_BIT_EXT = 0x00000080, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_HOST_MAPPED_FOREIGN_MEMORY_BIT_EXT = 0x00000100, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_ZIRCON_VMO_BIT_FUCHSIA = 0x00000800, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_RDMA_ADDRESS_BIT_NV = 0x00001000, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_SCREEN_BUFFER_BIT_QNX = 0x00004000, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR = VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalMemoryHandleTypeFlagBits; -typedef VkFlags VkExternalMemoryHandleTypeFlags; - -typedef enum VkExternalMemoryFeatureFlagBits { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004, - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalMemoryFeatureFlagBits; -typedef VkFlags VkExternalMemoryFeatureFlags; - -typedef enum VkExternalFenceHandleTypeFlagBits { - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, - VK_EXTERNAL_FENCE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalFenceHandleTypeFlagBits; -typedef VkFlags VkExternalFenceHandleTypeFlags; - -typedef enum VkExternalFenceFeatureFlagBits { - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_FENCE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalFenceFeatureFlagBits; -typedef VkFlags VkExternalFenceFeatureFlags; - -typedef enum VkFenceImportFlagBits { - VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001, - VK_FENCE_IMPORT_TEMPORARY_BIT_KHR = VK_FENCE_IMPORT_TEMPORARY_BIT, - VK_FENCE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkFenceImportFlagBits; -typedef VkFlags VkFenceImportFlags; - -typedef enum VkSemaphoreImportFlagBits { - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001, - VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR = VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, - VK_SEMAPHORE_IMPORT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreImportFlagBits; -typedef VkFlags VkSemaphoreImportFlags; - -typedef enum VkExternalSemaphoreHandleTypeFlagBits { - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT = 0x00000002, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT = 0x00000004, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT = 0x00000008, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_ZIRCON_EVENT_BIT_FUCHSIA = 0x00000080, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D11_FENCE_BIT = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, - VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalSemaphoreHandleTypeFlagBits; -typedef VkFlags VkExternalSemaphoreHandleTypeFlags; - -typedef enum VkExternalSemaphoreFeatureFlagBits { - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT = 0x00000001, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002, - VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, - VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR = VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, - VK_EXTERNAL_SEMAPHORE_FEATURE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkExternalSemaphoreFeatureFlagBits; -typedef VkFlags VkExternalSemaphoreFeatureFlags; -typedef struct VkPhysicalDeviceSubgroupProperties { - VkStructureType sType; - void* pNext; - uint32_t subgroupSize; - VkShaderStageFlags supportedStages; - VkSubgroupFeatureFlags supportedOperations; - VkBool32 quadOperationsInAllStages; -} VkPhysicalDeviceSubgroupProperties; - -typedef struct VkBindBufferMemoryInfo { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindBufferMemoryInfo; - -typedef struct VkBindImageMemoryInfo { - VkStructureType sType; - const void* pNext; - VkImage image; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; -} VkBindImageMemoryInfo; - -typedef struct VkPhysicalDevice16BitStorageFeatures { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; -} VkPhysicalDevice16BitStorageFeatures; - -typedef struct VkMemoryDedicatedRequirements { - VkStructureType sType; - void* pNext; - VkBool32 prefersDedicatedAllocation; - VkBool32 requiresDedicatedAllocation; -} VkMemoryDedicatedRequirements; - -typedef struct VkMemoryDedicatedAllocateInfo { - VkStructureType sType; - const void* pNext; - VkImage image; - VkBuffer buffer; -} VkMemoryDedicatedAllocateInfo; - -typedef struct VkMemoryAllocateFlagsInfo { - VkStructureType sType; - const void* pNext; - VkMemoryAllocateFlags flags; - uint32_t deviceMask; -} VkMemoryAllocateFlagsInfo; - -typedef struct VkDeviceGroupRenderPassBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceMask; - uint32_t deviceRenderAreaCount; - const VkRect2D* pDeviceRenderAreas; -} VkDeviceGroupRenderPassBeginInfo; - -typedef struct VkDeviceGroupCommandBufferBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceMask; -} VkDeviceGroupCommandBufferBeginInfo; - -typedef struct VkDeviceGroupSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const uint32_t* pWaitSemaphoreDeviceIndices; - uint32_t commandBufferCount; - const uint32_t* pCommandBufferDeviceMasks; - uint32_t signalSemaphoreCount; - const uint32_t* pSignalSemaphoreDeviceIndices; -} VkDeviceGroupSubmitInfo; - -typedef struct VkDeviceGroupBindSparseInfo { - VkStructureType sType; - const void* pNext; - uint32_t resourceDeviceIndex; - uint32_t memoryDeviceIndex; -} VkDeviceGroupBindSparseInfo; - -typedef struct VkBindBufferMemoryDeviceGroupInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; -} VkBindBufferMemoryDeviceGroupInfo; - -typedef struct VkBindImageMemoryDeviceGroupInfo { - VkStructureType sType; - const void* pNext; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; - uint32_t splitInstanceBindRegionCount; - const VkRect2D* pSplitInstanceBindRegions; -} VkBindImageMemoryDeviceGroupInfo; - -typedef struct VkPhysicalDeviceGroupProperties { - VkStructureType sType; - void* pNext; - uint32_t physicalDeviceCount; - VkPhysicalDevice physicalDevices[32U]; - VkBool32 subsetAllocation; -} VkPhysicalDeviceGroupProperties; - -typedef struct VkDeviceGroupDeviceCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t physicalDeviceCount; - const VkPhysicalDevice* pPhysicalDevices; -} VkDeviceGroupDeviceCreateInfo; - -typedef struct VkBufferMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferMemoryRequirementsInfo2; - -typedef struct VkImageMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageMemoryRequirementsInfo2; - -typedef struct VkImageSparseMemoryRequirementsInfo2 { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageSparseMemoryRequirementsInfo2; - -typedef struct VkMemoryRequirements2 { - VkStructureType sType; - void* pNext; - VkMemoryRequirements memoryRequirements; -} VkMemoryRequirements2; - -typedef struct VkSparseImageMemoryRequirements2 { - VkStructureType sType; - void* pNext; - VkSparseImageMemoryRequirements memoryRequirements; -} VkSparseImageMemoryRequirements2; - -typedef struct VkPhysicalDeviceFeatures2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceFeatures features; -} VkPhysicalDeviceFeatures2; - -typedef struct VkPhysicalDeviceProperties2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceProperties properties; -} VkPhysicalDeviceProperties2; - -typedef struct VkFormatProperties2 { - VkStructureType sType; - void* pNext; - VkFormatProperties formatProperties; -} VkFormatProperties2; - -typedef struct VkImageFormatProperties2 { - VkStructureType sType; - void* pNext; - VkImageFormatProperties imageFormatProperties; -} VkImageFormatProperties2; - -typedef struct VkPhysicalDeviceImageFormatInfo2 { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkImageType type; - VkImageTiling tiling; - VkImageUsageFlags usage; - VkImageCreateFlags flags; -} VkPhysicalDeviceImageFormatInfo2; - -typedef struct VkQueueFamilyProperties2 { - VkStructureType sType; - void* pNext; - VkQueueFamilyProperties queueFamilyProperties; -} VkQueueFamilyProperties2; - -typedef struct VkPhysicalDeviceMemoryProperties2 { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceMemoryProperties memoryProperties; -} VkPhysicalDeviceMemoryProperties2; - -typedef struct VkSparseImageFormatProperties2 { - VkStructureType sType; - void* pNext; - VkSparseImageFormatProperties properties; -} VkSparseImageFormatProperties2; - -typedef struct VkPhysicalDeviceSparseImageFormatInfo2 { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkImageType type; - VkSampleCountFlagBits samples; - VkImageUsageFlags usage; - VkImageTiling tiling; -} VkPhysicalDeviceSparseImageFormatInfo2; - -typedef struct VkPhysicalDevicePointClippingProperties { - VkStructureType sType; - void* pNext; - VkPointClippingBehavior pointClippingBehavior; -} VkPhysicalDevicePointClippingProperties; - -typedef struct VkInputAttachmentAspectReference { - uint32_t subpass; - uint32_t inputAttachmentIndex; - VkImageAspectFlags aspectMask; -} VkInputAttachmentAspectReference; - -typedef struct VkRenderPassInputAttachmentAspectCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t aspectReferenceCount; - const VkInputAttachmentAspectReference* pAspectReferences; -} VkRenderPassInputAttachmentAspectCreateInfo; - -typedef struct VkImageViewUsageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags usage; -} VkImageViewUsageCreateInfo; - -typedef struct VkPipelineTessellationDomainOriginStateCreateInfo { - VkStructureType sType; - const void* pNext; - VkTessellationDomainOrigin domainOrigin; -} VkPipelineTessellationDomainOriginStateCreateInfo; - -typedef struct VkRenderPassMultiviewCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t subpassCount; - const uint32_t* pViewMasks; - uint32_t dependencyCount; - const int32_t* pViewOffsets; - uint32_t correlationMaskCount; - const uint32_t* pCorrelationMasks; -} VkRenderPassMultiviewCreateInfo; - -typedef struct VkPhysicalDeviceMultiviewFeatures { - VkStructureType sType; - void* pNext; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; -} VkPhysicalDeviceMultiviewFeatures; - -typedef struct VkPhysicalDeviceMultiviewProperties { - VkStructureType sType; - void* pNext; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; -} VkPhysicalDeviceMultiviewProperties; - -typedef struct VkPhysicalDeviceVariablePointersFeatures { - VkStructureType sType; - void* pNext; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; -} VkPhysicalDeviceVariablePointersFeatures; - -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeatures; - -typedef struct VkPhysicalDeviceProtectedMemoryFeatures { - VkStructureType sType; - void* pNext; - VkBool32 protectedMemory; -} VkPhysicalDeviceProtectedMemoryFeatures; - -typedef struct VkPhysicalDeviceProtectedMemoryProperties { - VkStructureType sType; - void* pNext; - VkBool32 protectedNoFault; -} VkPhysicalDeviceProtectedMemoryProperties; - -typedef struct VkDeviceQueueInfo2 { - VkStructureType sType; - const void* pNext; - VkDeviceQueueCreateFlags flags; - uint32_t queueFamilyIndex; - uint32_t queueIndex; -} VkDeviceQueueInfo2; - -typedef struct VkProtectedSubmitInfo { - VkStructureType sType; - const void* pNext; - VkBool32 protectedSubmit; -} VkProtectedSubmitInfo; - -typedef struct VkSamplerYcbcrConversionCreateInfo { - VkStructureType sType; - const void* pNext; - VkFormat format; - VkSamplerYcbcrModelConversion ycbcrModel; - VkSamplerYcbcrRange ycbcrRange; - VkComponentMapping components; - VkChromaLocation xChromaOffset; - VkChromaLocation yChromaOffset; - VkFilter chromaFilter; - VkBool32 forceExplicitReconstruction; -} VkSamplerYcbcrConversionCreateInfo; - -typedef struct VkSamplerYcbcrConversionInfo { - VkStructureType sType; - const void* pNext; - VkSamplerYcbcrConversion conversion; -} VkSamplerYcbcrConversionInfo; - -typedef struct VkBindImagePlaneMemoryInfo { - VkStructureType sType; - const void* pNext; - VkImageAspectFlagBits planeAspect; -} VkBindImagePlaneMemoryInfo; - -typedef struct VkImagePlaneMemoryRequirementsInfo { - VkStructureType sType; - const void* pNext; - VkImageAspectFlagBits planeAspect; -} VkImagePlaneMemoryRequirementsInfo; - -typedef struct VkPhysicalDeviceSamplerYcbcrConversionFeatures { - VkStructureType sType; - void* pNext; - VkBool32 samplerYcbcrConversion; -} VkPhysicalDeviceSamplerYcbcrConversionFeatures; - -typedef struct VkSamplerYcbcrConversionImageFormatProperties { - VkStructureType sType; - void* pNext; - uint32_t combinedImageSamplerDescriptorCount; -} VkSamplerYcbcrConversionImageFormatProperties; - -typedef struct VkDescriptorUpdateTemplateEntry { - uint32_t dstBinding; - uint32_t dstArrayElement; - uint32_t descriptorCount; - VkDescriptorType descriptorType; - size_t offset; - size_t stride; -} VkDescriptorUpdateTemplateEntry; - -typedef struct VkDescriptorUpdateTemplateCreateInfo { - VkStructureType sType; - const void* pNext; - VkDescriptorUpdateTemplateCreateFlags flags; - uint32_t descriptorUpdateEntryCount; - const VkDescriptorUpdateTemplateEntry* pDescriptorUpdateEntries; - VkDescriptorUpdateTemplateType templateType; - VkDescriptorSetLayout descriptorSetLayout; - VkPipelineBindPoint pipelineBindPoint; - VkPipelineLayout pipelineLayout; - uint32_t set; -} VkDescriptorUpdateTemplateCreateInfo; - -typedef struct VkExternalMemoryProperties { - VkExternalMemoryFeatureFlags externalMemoryFeatures; - VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes; - VkExternalMemoryHandleTypeFlags compatibleHandleTypes; -} VkExternalMemoryProperties; - -typedef struct VkPhysicalDeviceExternalImageFormatInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalImageFormatInfo; - -typedef struct VkExternalImageFormatProperties { - VkStructureType sType; - void* pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalImageFormatProperties; - -typedef struct VkPhysicalDeviceExternalBufferInfo { - VkStructureType sType; - const void* pNext; - VkBufferCreateFlags flags; - VkBufferUsageFlags usage; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalBufferInfo; - -typedef struct VkExternalBufferProperties { - VkStructureType sType; - void* pNext; - VkExternalMemoryProperties externalMemoryProperties; -} VkExternalBufferProperties; - -typedef struct VkPhysicalDeviceIDProperties { - VkStructureType sType; - void* pNext; - uint8_t deviceUUID[16U]; - uint8_t driverUUID[16U]; - uint8_t deviceLUID[8U]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; -} VkPhysicalDeviceIDProperties; - -typedef struct VkExternalMemoryImageCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryImageCreateInfo; - -typedef struct VkExternalMemoryBufferCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExternalMemoryBufferCreateInfo; - -typedef struct VkExportMemoryAllocateInfo { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlags handleTypes; -} VkExportMemoryAllocateInfo; - -typedef struct VkPhysicalDeviceExternalFenceInfo { - VkStructureType sType; - const void* pNext; - VkExternalFenceHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalFenceInfo; - -typedef struct VkExternalFenceProperties { - VkStructureType sType; - void* pNext; - VkExternalFenceHandleTypeFlags exportFromImportedHandleTypes; - VkExternalFenceHandleTypeFlags compatibleHandleTypes; - VkExternalFenceFeatureFlags externalFenceFeatures; -} VkExternalFenceProperties; - -typedef struct VkExportFenceCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalFenceHandleTypeFlags handleTypes; -} VkExportFenceCreateInfo; - -typedef struct VkExportSemaphoreCreateInfo { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlags handleTypes; -} VkExportSemaphoreCreateInfo; - -typedef struct VkPhysicalDeviceExternalSemaphoreInfo { - VkStructureType sType; - const void* pNext; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkPhysicalDeviceExternalSemaphoreInfo; - -typedef struct VkExternalSemaphoreProperties { - VkStructureType sType; - void* pNext; - VkExternalSemaphoreHandleTypeFlags exportFromImportedHandleTypes; - VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes; - VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures; -} VkExternalSemaphoreProperties; - -typedef struct VkPhysicalDeviceMaintenance3Properties { - VkStructureType sType; - void* pNext; - uint32_t maxPerSetDescriptors; - VkDeviceSize maxMemoryAllocationSize; -} VkPhysicalDeviceMaintenance3Properties; - -typedef struct VkDescriptorSetLayoutSupport { - VkStructureType sType; - void* pNext; - VkBool32 supported; -} VkDescriptorSetLayoutSupport; - -typedef struct VkPhysicalDeviceShaderDrawParametersFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceShaderDrawParametersFeatures; - -typedef VkPhysicalDeviceShaderDrawParametersFeatures VkPhysicalDeviceShaderDrawParameterFeatures; - -typedef VkResult ( *PFN_vkEnumerateInstanceVersion)(uint32_t* pApiVersion); -typedef VkResult ( *PFN_vkBindBufferMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -typedef VkResult ( *PFN_vkBindImageMemory2)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); -typedef void ( *PFN_vkGetDeviceGroupPeerMemoryFeatures)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -typedef void ( *PFN_vkCmdSetDeviceMask)(VkCommandBuffer commandBuffer, uint32_t deviceMask); -typedef void ( *PFN_vkCmdDispatchBase)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef VkResult ( *PFN_vkEnumeratePhysicalDeviceGroups)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -typedef void ( *PFN_vkGetImageMemoryRequirements2)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkGetBufferMemoryRequirements2)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkGetImageSparseMemoryRequirements2)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -typedef void ( *PFN_vkGetPhysicalDeviceFeatures2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -typedef void ( *PFN_vkGetPhysicalDeviceProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -typedef void ( *PFN_vkGetPhysicalDeviceFormatProperties2)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -typedef VkResult ( *PFN_vkGetPhysicalDeviceImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -typedef void ( *PFN_vkGetPhysicalDeviceQueueFamilyProperties2)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -typedef void ( *PFN_vkGetPhysicalDeviceMemoryProperties2)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -typedef void ( *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); -typedef void ( *PFN_vkTrimCommandPool)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); -typedef void ( *PFN_vkGetDeviceQueue2)(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue); -typedef VkResult ( *PFN_vkCreateSamplerYcbcrConversion)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -typedef void ( *PFN_vkDestroySamplerYcbcrConversion)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkCreateDescriptorUpdateTemplate)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -typedef void ( *PFN_vkDestroyDescriptorUpdateTemplate)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkUpdateDescriptorSetWithTemplate)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); -typedef void ( *PFN_vkGetPhysicalDeviceExternalBufferProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); -typedef void ( *PFN_vkGetPhysicalDeviceExternalFenceProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); -typedef void ( *PFN_vkGetPhysicalDeviceExternalSemaphoreProperties)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -typedef void ( *PFN_vkGetDescriptorSetLayoutSupport)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); -# 5803 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkDriverId { - VK_DRIVER_ID_AMD_PROPRIETARY = 1, - VK_DRIVER_ID_AMD_OPEN_SOURCE = 2, - VK_DRIVER_ID_MESA_RADV = 3, - VK_DRIVER_ID_NVIDIA_PROPRIETARY = 4, - VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS = 5, - VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA = 6, - VK_DRIVER_ID_IMAGINATION_PROPRIETARY = 7, - VK_DRIVER_ID_QUALCOMM_PROPRIETARY = 8, - VK_DRIVER_ID_ARM_PROPRIETARY = 9, - VK_DRIVER_ID_GOOGLE_SWIFTSHADER = 10, - VK_DRIVER_ID_GGP_PROPRIETARY = 11, - VK_DRIVER_ID_BROADCOM_PROPRIETARY = 12, - VK_DRIVER_ID_MESA_LLVMPIPE = 13, - VK_DRIVER_ID_MOLTENVK = 14, - VK_DRIVER_ID_COREAVI_PROPRIETARY = 15, - VK_DRIVER_ID_JUICE_PROPRIETARY = 16, - VK_DRIVER_ID_VERISILICON_PROPRIETARY = 17, - VK_DRIVER_ID_MESA_TURNIP = 18, - VK_DRIVER_ID_MESA_V3DV = 19, - VK_DRIVER_ID_MESA_PANVK = 20, - VK_DRIVER_ID_SAMSUNG_PROPRIETARY = 21, - VK_DRIVER_ID_MESA_VENUS = 22, - VK_DRIVER_ID_MESA_DOZEN = 23, - VK_DRIVER_ID_MESA_NVK = 24, - VK_DRIVER_ID_IMAGINATION_OPEN_SOURCE_MESA = 25, - VK_DRIVER_ID_MESA_AGXV = 26, - VK_DRIVER_ID_AMD_PROPRIETARY_KHR = VK_DRIVER_ID_AMD_PROPRIETARY, - VK_DRIVER_ID_AMD_OPEN_SOURCE_KHR = VK_DRIVER_ID_AMD_OPEN_SOURCE, - VK_DRIVER_ID_MESA_RADV_KHR = VK_DRIVER_ID_MESA_RADV, - VK_DRIVER_ID_NVIDIA_PROPRIETARY_KHR = VK_DRIVER_ID_NVIDIA_PROPRIETARY, - VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS_KHR = VK_DRIVER_ID_INTEL_PROPRIETARY_WINDOWS, - VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA_KHR = VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA, - VK_DRIVER_ID_IMAGINATION_PROPRIETARY_KHR = VK_DRIVER_ID_IMAGINATION_PROPRIETARY, - VK_DRIVER_ID_QUALCOMM_PROPRIETARY_KHR = VK_DRIVER_ID_QUALCOMM_PROPRIETARY, - VK_DRIVER_ID_ARM_PROPRIETARY_KHR = VK_DRIVER_ID_ARM_PROPRIETARY, - VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR = VK_DRIVER_ID_GOOGLE_SWIFTSHADER, - VK_DRIVER_ID_GGP_PROPRIETARY_KHR = VK_DRIVER_ID_GGP_PROPRIETARY, - VK_DRIVER_ID_BROADCOM_PROPRIETARY_KHR = VK_DRIVER_ID_BROADCOM_PROPRIETARY, - VK_DRIVER_ID_MAX_ENUM = 0x7FFFFFFF -} VkDriverId; - -typedef enum VkShaderFloatControlsIndependence { - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY = 0, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL = 1, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE = 2, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_32_BIT_ONLY, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE_KHR = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE, - VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_MAX_ENUM = 0x7FFFFFFF -} VkShaderFloatControlsIndependence; - -typedef enum VkSamplerReductionMode { - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE = 0, - VK_SAMPLER_REDUCTION_MODE_MIN = 1, - VK_SAMPLER_REDUCTION_MODE_MAX = 2, - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_RANGECLAMP_QCOM = 1000521000, - VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT = VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE, - VK_SAMPLER_REDUCTION_MODE_MIN_EXT = VK_SAMPLER_REDUCTION_MODE_MIN, - VK_SAMPLER_REDUCTION_MODE_MAX_EXT = VK_SAMPLER_REDUCTION_MODE_MAX, - VK_SAMPLER_REDUCTION_MODE_MAX_ENUM = 0x7FFFFFFF -} VkSamplerReductionMode; - -typedef enum VkSemaphoreType { - VK_SEMAPHORE_TYPE_BINARY = 0, - VK_SEMAPHORE_TYPE_TIMELINE = 1, - VK_SEMAPHORE_TYPE_BINARY_KHR = VK_SEMAPHORE_TYPE_BINARY, - VK_SEMAPHORE_TYPE_TIMELINE_KHR = VK_SEMAPHORE_TYPE_TIMELINE, - VK_SEMAPHORE_TYPE_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreType; - -typedef enum VkResolveModeFlagBits { - VK_RESOLVE_MODE_NONE = 0, - VK_RESOLVE_MODE_SAMPLE_ZERO_BIT = 0x00000001, - VK_RESOLVE_MODE_AVERAGE_BIT = 0x00000002, - VK_RESOLVE_MODE_MIN_BIT = 0x00000004, - VK_RESOLVE_MODE_MAX_BIT = 0x00000008, - VK_RESOLVE_MODE_EXTERNAL_FORMAT_DOWNSAMPLE_ANDROID = 0x00000010, - VK_RESOLVE_MODE_NONE_KHR = VK_RESOLVE_MODE_NONE, - VK_RESOLVE_MODE_SAMPLE_ZERO_BIT_KHR = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT, - VK_RESOLVE_MODE_AVERAGE_BIT_KHR = VK_RESOLVE_MODE_AVERAGE_BIT, - VK_RESOLVE_MODE_MIN_BIT_KHR = VK_RESOLVE_MODE_MIN_BIT, - VK_RESOLVE_MODE_MAX_BIT_KHR = VK_RESOLVE_MODE_MAX_BIT, - VK_RESOLVE_MODE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkResolveModeFlagBits; -typedef VkFlags VkResolveModeFlags; - -typedef enum VkDescriptorBindingFlagBits { - VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT = 0x00000001, - VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT = 0x00000002, - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT = 0x00000004, - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT = 0x00000008, - VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT, - VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT_EXT = VK_DESCRIPTOR_BINDING_UPDATE_UNUSED_WHILE_PENDING_BIT, - VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT = VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT, - VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT = VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT, - VK_DESCRIPTOR_BINDING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkDescriptorBindingFlagBits; -typedef VkFlags VkDescriptorBindingFlags; - -typedef enum VkSemaphoreWaitFlagBits { - VK_SEMAPHORE_WAIT_ANY_BIT = 0x00000001, - VK_SEMAPHORE_WAIT_ANY_BIT_KHR = VK_SEMAPHORE_WAIT_ANY_BIT, - VK_SEMAPHORE_WAIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSemaphoreWaitFlagBits; -typedef VkFlags VkSemaphoreWaitFlags; -typedef struct VkPhysicalDeviceVulkan11Features { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer16BitAccess; - VkBool32 uniformAndStorageBuffer16BitAccess; - VkBool32 storagePushConstant16; - VkBool32 storageInputOutput16; - VkBool32 multiview; - VkBool32 multiviewGeometryShader; - VkBool32 multiviewTessellationShader; - VkBool32 variablePointersStorageBuffer; - VkBool32 variablePointers; - VkBool32 protectedMemory; - VkBool32 samplerYcbcrConversion; - VkBool32 shaderDrawParameters; -} VkPhysicalDeviceVulkan11Features; - -typedef struct VkPhysicalDeviceVulkan11Properties { - VkStructureType sType; - void* pNext; - uint8_t deviceUUID[16U]; - uint8_t driverUUID[16U]; - uint8_t deviceLUID[8U]; - uint32_t deviceNodeMask; - VkBool32 deviceLUIDValid; - uint32_t subgroupSize; - VkShaderStageFlags subgroupSupportedStages; - VkSubgroupFeatureFlags subgroupSupportedOperations; - VkBool32 subgroupQuadOperationsInAllStages; - VkPointClippingBehavior pointClippingBehavior; - uint32_t maxMultiviewViewCount; - uint32_t maxMultiviewInstanceIndex; - VkBool32 protectedNoFault; - uint32_t maxPerSetDescriptors; - VkDeviceSize maxMemoryAllocationSize; -} VkPhysicalDeviceVulkan11Properties; - -typedef struct VkPhysicalDeviceVulkan12Features { - VkStructureType sType; - void* pNext; - VkBool32 samplerMirrorClampToEdge; - VkBool32 drawIndirectCount; - VkBool32 storageBuffer8BitAccess; - VkBool32 uniformAndStorageBuffer8BitAccess; - VkBool32 storagePushConstant8; - VkBool32 shaderBufferInt64Atomics; - VkBool32 shaderSharedInt64Atomics; - VkBool32 shaderFloat16; - VkBool32 shaderInt8; - VkBool32 descriptorIndexing; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; - VkBool32 samplerFilterMinmax; - VkBool32 scalarBlockLayout; - VkBool32 imagelessFramebuffer; - VkBool32 uniformBufferStandardLayout; - VkBool32 shaderSubgroupExtendedTypes; - VkBool32 separateDepthStencilLayouts; - VkBool32 hostQueryReset; - VkBool32 timelineSemaphore; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; - VkBool32 vulkanMemoryModel; - VkBool32 vulkanMemoryModelDeviceScope; - VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; - VkBool32 shaderOutputViewportIndex; - VkBool32 shaderOutputLayer; - VkBool32 subgroupBroadcastDynamicId; -} VkPhysicalDeviceVulkan12Features; - -typedef struct VkConformanceVersion { - uint8_t major; - uint8_t minor; - uint8_t subminor; - uint8_t patch; -} VkConformanceVersion; - -typedef struct VkPhysicalDeviceVulkan12Properties { - VkStructureType sType; - void* pNext; - VkDriverId driverID; - char driverName[256U]; - char driverInfo[256U]; - VkConformanceVersion conformanceVersion; - VkShaderFloatControlsIndependence denormBehaviorIndependence; - VkShaderFloatControlsIndependence roundingModeIndependence; - VkBool32 shaderSignedZeroInfNanPreserveFloat16; - VkBool32 shaderSignedZeroInfNanPreserveFloat32; - VkBool32 shaderSignedZeroInfNanPreserveFloat64; - VkBool32 shaderDenormPreserveFloat16; - VkBool32 shaderDenormPreserveFloat32; - VkBool32 shaderDenormPreserveFloat64; - VkBool32 shaderDenormFlushToZeroFloat16; - VkBool32 shaderDenormFlushToZeroFloat32; - VkBool32 shaderDenormFlushToZeroFloat64; - VkBool32 shaderRoundingModeRTEFloat16; - VkBool32 shaderRoundingModeRTEFloat32; - VkBool32 shaderRoundingModeRTEFloat64; - VkBool32 shaderRoundingModeRTZFloat16; - VkBool32 shaderRoundingModeRTZFloat32; - VkBool32 shaderRoundingModeRTZFloat64; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; - VkBool32 shaderSampledImageArrayNonUniformIndexingNative; - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; - VkBool32 shaderStorageImageArrayNonUniformIndexingNative; - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; - VkBool32 robustBufferAccessUpdateAfterBind; - VkBool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; - VkResolveModeFlags supportedDepthResolveModes; - VkResolveModeFlags supportedStencilResolveModes; - VkBool32 independentResolveNone; - VkBool32 independentResolve; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; - uint64_t maxTimelineSemaphoreValueDifference; - VkSampleCountFlags framebufferIntegerColorSampleCounts; -} VkPhysicalDeviceVulkan12Properties; - -typedef struct VkImageFormatListCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t viewFormatCount; - const VkFormat* pViewFormats; -} VkImageFormatListCreateInfo; - -typedef struct VkAttachmentDescription2 { - VkStructureType sType; - const void* pNext; - VkAttachmentDescriptionFlags flags; - VkFormat format; - VkSampleCountFlagBits samples; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkAttachmentLoadOp stencilLoadOp; - VkAttachmentStoreOp stencilStoreOp; - VkImageLayout initialLayout; - VkImageLayout finalLayout; -} VkAttachmentDescription2; - -typedef struct VkAttachmentReference2 { - VkStructureType sType; - const void* pNext; - uint32_t attachment; - VkImageLayout layout; - VkImageAspectFlags aspectMask; -} VkAttachmentReference2; - -typedef struct VkSubpassDescription2 { - VkStructureType sType; - const void* pNext; - VkSubpassDescriptionFlags flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t viewMask; - uint32_t inputAttachmentCount; - const VkAttachmentReference2* pInputAttachments; - uint32_t colorAttachmentCount; - const VkAttachmentReference2* pColorAttachments; - const VkAttachmentReference2* pResolveAttachments; - const VkAttachmentReference2* pDepthStencilAttachment; - uint32_t preserveAttachmentCount; - const uint32_t* pPreserveAttachments; -} VkSubpassDescription2; - -typedef struct VkSubpassDependency2 { - VkStructureType sType; - const void* pNext; - uint32_t srcSubpass; - uint32_t dstSubpass; - VkPipelineStageFlags srcStageMask; - VkPipelineStageFlags dstStageMask; - VkAccessFlags srcAccessMask; - VkAccessFlags dstAccessMask; - VkDependencyFlags dependencyFlags; - int32_t viewOffset; -} VkSubpassDependency2; - -typedef struct VkRenderPassCreateInfo2 { - VkStructureType sType; - const void* pNext; - VkRenderPassCreateFlags flags; - uint32_t attachmentCount; - const VkAttachmentDescription2* pAttachments; - uint32_t subpassCount; - const VkSubpassDescription2* pSubpasses; - uint32_t dependencyCount; - const VkSubpassDependency2* pDependencies; - uint32_t correlatedViewMaskCount; - const uint32_t* pCorrelatedViewMasks; -} VkRenderPassCreateInfo2; - -typedef struct VkSubpassBeginInfo { - VkStructureType sType; - const void* pNext; - VkSubpassContents contents; -} VkSubpassBeginInfo; - -typedef struct VkSubpassEndInfo { - VkStructureType sType; - const void* pNext; -} VkSubpassEndInfo; - -typedef struct VkPhysicalDevice8BitStorageFeatures { - VkStructureType sType; - void* pNext; - VkBool32 storageBuffer8BitAccess; - VkBool32 uniformAndStorageBuffer8BitAccess; - VkBool32 storagePushConstant8; -} VkPhysicalDevice8BitStorageFeatures; - -typedef struct VkPhysicalDeviceDriverProperties { - VkStructureType sType; - void* pNext; - VkDriverId driverID; - char driverName[256U]; - char driverInfo[256U]; - VkConformanceVersion conformanceVersion; -} VkPhysicalDeviceDriverProperties; - -typedef struct VkPhysicalDeviceShaderAtomicInt64Features { - VkStructureType sType; - void* pNext; - VkBool32 shaderBufferInt64Atomics; - VkBool32 shaderSharedInt64Atomics; -} VkPhysicalDeviceShaderAtomicInt64Features; - -typedef struct VkPhysicalDeviceShaderFloat16Int8Features { - VkStructureType sType; - void* pNext; - VkBool32 shaderFloat16; - VkBool32 shaderInt8; -} VkPhysicalDeviceShaderFloat16Int8Features; - -typedef struct VkPhysicalDeviceFloatControlsProperties { - VkStructureType sType; - void* pNext; - VkShaderFloatControlsIndependence denormBehaviorIndependence; - VkShaderFloatControlsIndependence roundingModeIndependence; - VkBool32 shaderSignedZeroInfNanPreserveFloat16; - VkBool32 shaderSignedZeroInfNanPreserveFloat32; - VkBool32 shaderSignedZeroInfNanPreserveFloat64; - VkBool32 shaderDenormPreserveFloat16; - VkBool32 shaderDenormPreserveFloat32; - VkBool32 shaderDenormPreserveFloat64; - VkBool32 shaderDenormFlushToZeroFloat16; - VkBool32 shaderDenormFlushToZeroFloat32; - VkBool32 shaderDenormFlushToZeroFloat64; - VkBool32 shaderRoundingModeRTEFloat16; - VkBool32 shaderRoundingModeRTEFloat32; - VkBool32 shaderRoundingModeRTEFloat64; - VkBool32 shaderRoundingModeRTZFloat16; - VkBool32 shaderRoundingModeRTZFloat32; - VkBool32 shaderRoundingModeRTZFloat64; -} VkPhysicalDeviceFloatControlsProperties; - -typedef struct VkDescriptorSetLayoutBindingFlagsCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t bindingCount; - const VkDescriptorBindingFlags* pBindingFlags; -} VkDescriptorSetLayoutBindingFlagsCreateInfo; - -typedef struct VkPhysicalDeviceDescriptorIndexingFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderInputAttachmentArrayDynamicIndexing; - VkBool32 shaderUniformTexelBufferArrayDynamicIndexing; - VkBool32 shaderStorageTexelBufferArrayDynamicIndexing; - VkBool32 shaderUniformBufferArrayNonUniformIndexing; - VkBool32 shaderSampledImageArrayNonUniformIndexing; - VkBool32 shaderStorageBufferArrayNonUniformIndexing; - VkBool32 shaderStorageImageArrayNonUniformIndexing; - VkBool32 shaderInputAttachmentArrayNonUniformIndexing; - VkBool32 shaderUniformTexelBufferArrayNonUniformIndexing; - VkBool32 shaderStorageTexelBufferArrayNonUniformIndexing; - VkBool32 descriptorBindingUniformBufferUpdateAfterBind; - VkBool32 descriptorBindingSampledImageUpdateAfterBind; - VkBool32 descriptorBindingStorageImageUpdateAfterBind; - VkBool32 descriptorBindingStorageBufferUpdateAfterBind; - VkBool32 descriptorBindingUniformTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingStorageTexelBufferUpdateAfterBind; - VkBool32 descriptorBindingUpdateUnusedWhilePending; - VkBool32 descriptorBindingPartiallyBound; - VkBool32 descriptorBindingVariableDescriptorCount; - VkBool32 runtimeDescriptorArray; -} VkPhysicalDeviceDescriptorIndexingFeatures; - -typedef struct VkPhysicalDeviceDescriptorIndexingProperties { - VkStructureType sType; - void* pNext; - uint32_t maxUpdateAfterBindDescriptorsInAllPools; - VkBool32 shaderUniformBufferArrayNonUniformIndexingNative; - VkBool32 shaderSampledImageArrayNonUniformIndexingNative; - VkBool32 shaderStorageBufferArrayNonUniformIndexingNative; - VkBool32 shaderStorageImageArrayNonUniformIndexingNative; - VkBool32 shaderInputAttachmentArrayNonUniformIndexingNative; - VkBool32 robustBufferAccessUpdateAfterBind; - VkBool32 quadDivergentImplicitLod; - uint32_t maxPerStageDescriptorUpdateAfterBindSamplers; - uint32_t maxPerStageDescriptorUpdateAfterBindUniformBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageBuffers; - uint32_t maxPerStageDescriptorUpdateAfterBindSampledImages; - uint32_t maxPerStageDescriptorUpdateAfterBindStorageImages; - uint32_t maxPerStageDescriptorUpdateAfterBindInputAttachments; - uint32_t maxPerStageUpdateAfterBindResources; - uint32_t maxDescriptorSetUpdateAfterBindSamplers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffers; - uint32_t maxDescriptorSetUpdateAfterBindUniformBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffers; - uint32_t maxDescriptorSetUpdateAfterBindStorageBuffersDynamic; - uint32_t maxDescriptorSetUpdateAfterBindSampledImages; - uint32_t maxDescriptorSetUpdateAfterBindStorageImages; - uint32_t maxDescriptorSetUpdateAfterBindInputAttachments; -} VkPhysicalDeviceDescriptorIndexingProperties; - -typedef struct VkDescriptorSetVariableDescriptorCountAllocateInfo { - VkStructureType sType; - const void* pNext; - uint32_t descriptorSetCount; - const uint32_t* pDescriptorCounts; -} VkDescriptorSetVariableDescriptorCountAllocateInfo; - -typedef struct VkDescriptorSetVariableDescriptorCountLayoutSupport { - VkStructureType sType; - void* pNext; - uint32_t maxVariableDescriptorCount; -} VkDescriptorSetVariableDescriptorCountLayoutSupport; - -typedef struct VkSubpassDescriptionDepthStencilResolve { - VkStructureType sType; - const void* pNext; - VkResolveModeFlagBits depthResolveMode; - VkResolveModeFlagBits stencilResolveMode; - const VkAttachmentReference2* pDepthStencilResolveAttachment; -} VkSubpassDescriptionDepthStencilResolve; - -typedef struct VkPhysicalDeviceDepthStencilResolveProperties { - VkStructureType sType; - void* pNext; - VkResolveModeFlags supportedDepthResolveModes; - VkResolveModeFlags supportedStencilResolveModes; - VkBool32 independentResolveNone; - VkBool32 independentResolve; -} VkPhysicalDeviceDepthStencilResolveProperties; - -typedef struct VkPhysicalDeviceScalarBlockLayoutFeatures { - VkStructureType sType; - void* pNext; - VkBool32 scalarBlockLayout; -} VkPhysicalDeviceScalarBlockLayoutFeatures; - -typedef struct VkImageStencilUsageCreateInfo { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags stencilUsage; -} VkImageStencilUsageCreateInfo; - -typedef struct VkSamplerReductionModeCreateInfo { - VkStructureType sType; - const void* pNext; - VkSamplerReductionMode reductionMode; -} VkSamplerReductionModeCreateInfo; - -typedef struct VkPhysicalDeviceSamplerFilterMinmaxProperties { - VkStructureType sType; - void* pNext; - VkBool32 filterMinmaxSingleComponentFormats; - VkBool32 filterMinmaxImageComponentMapping; -} VkPhysicalDeviceSamplerFilterMinmaxProperties; - -typedef struct VkPhysicalDeviceVulkanMemoryModelFeatures { - VkStructureType sType; - void* pNext; - VkBool32 vulkanMemoryModel; - VkBool32 vulkanMemoryModelDeviceScope; - VkBool32 vulkanMemoryModelAvailabilityVisibilityChains; -} VkPhysicalDeviceVulkanMemoryModelFeatures; - -typedef struct VkPhysicalDeviceImagelessFramebufferFeatures { - VkStructureType sType; - void* pNext; - VkBool32 imagelessFramebuffer; -} VkPhysicalDeviceImagelessFramebufferFeatures; - -typedef struct VkFramebufferAttachmentImageInfo { - VkStructureType sType; - const void* pNext; - VkImageCreateFlags flags; - VkImageUsageFlags usage; - uint32_t width; - uint32_t height; - uint32_t layerCount; - uint32_t viewFormatCount; - const VkFormat* pViewFormats; -} VkFramebufferAttachmentImageInfo; - -typedef struct VkFramebufferAttachmentsCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t attachmentImageInfoCount; - const VkFramebufferAttachmentImageInfo* pAttachmentImageInfos; -} VkFramebufferAttachmentsCreateInfo; - -typedef struct VkRenderPassAttachmentBeginInfo { - VkStructureType sType; - const void* pNext; - uint32_t attachmentCount; - const VkImageView* pAttachments; -} VkRenderPassAttachmentBeginInfo; - -typedef struct VkPhysicalDeviceUniformBufferStandardLayoutFeatures { - VkStructureType sType; - void* pNext; - VkBool32 uniformBufferStandardLayout; -} VkPhysicalDeviceUniformBufferStandardLayoutFeatures; - -typedef struct VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupExtendedTypes; -} VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures; - -typedef struct VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures { - VkStructureType sType; - void* pNext; - VkBool32 separateDepthStencilLayouts; -} VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures; - -typedef struct VkAttachmentReferenceStencilLayout { - VkStructureType sType; - void* pNext; - VkImageLayout stencilLayout; -} VkAttachmentReferenceStencilLayout; - -typedef struct VkAttachmentDescriptionStencilLayout { - VkStructureType sType; - void* pNext; - VkImageLayout stencilInitialLayout; - VkImageLayout stencilFinalLayout; -} VkAttachmentDescriptionStencilLayout; - -typedef struct VkPhysicalDeviceHostQueryResetFeatures { - VkStructureType sType; - void* pNext; - VkBool32 hostQueryReset; -} VkPhysicalDeviceHostQueryResetFeatures; - -typedef struct VkPhysicalDeviceTimelineSemaphoreFeatures { - VkStructureType sType; - void* pNext; - VkBool32 timelineSemaphore; -} VkPhysicalDeviceTimelineSemaphoreFeatures; - -typedef struct VkPhysicalDeviceTimelineSemaphoreProperties { - VkStructureType sType; - void* pNext; - uint64_t maxTimelineSemaphoreValueDifference; -} VkPhysicalDeviceTimelineSemaphoreProperties; - -typedef struct VkSemaphoreTypeCreateInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreType semaphoreType; - uint64_t initialValue; -} VkSemaphoreTypeCreateInfo; - -typedef struct VkTimelineSemaphoreSubmitInfo { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreValueCount; - const uint64_t* pWaitSemaphoreValues; - uint32_t signalSemaphoreValueCount; - const uint64_t* pSignalSemaphoreValues; -} VkTimelineSemaphoreSubmitInfo; - -typedef struct VkSemaphoreWaitInfo { - VkStructureType sType; - const void* pNext; - VkSemaphoreWaitFlags flags; - uint32_t semaphoreCount; - const VkSemaphore* pSemaphores; - const uint64_t* pValues; -} VkSemaphoreWaitInfo; - -typedef struct VkSemaphoreSignalInfo { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - uint64_t value; -} VkSemaphoreSignalInfo; - -typedef struct VkPhysicalDeviceBufferDeviceAddressFeatures { - VkStructureType sType; - void* pNext; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; -} VkPhysicalDeviceBufferDeviceAddressFeatures; - -typedef struct VkBufferDeviceAddressInfo { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferDeviceAddressInfo; - -typedef struct VkBufferOpaqueCaptureAddressCreateInfo { - VkStructureType sType; - const void* pNext; - uint64_t opaqueCaptureAddress; -} VkBufferOpaqueCaptureAddressCreateInfo; - -typedef struct VkMemoryOpaqueCaptureAddressAllocateInfo { - VkStructureType sType; - const void* pNext; - uint64_t opaqueCaptureAddress; -} VkMemoryOpaqueCaptureAddressAllocateInfo; - -typedef struct VkDeviceMemoryOpaqueCaptureAddressInfo { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; -} VkDeviceMemoryOpaqueCaptureAddressInfo; - -typedef void ( *PFN_vkCmdDrawIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void ( *PFN_vkCmdDrawIndexedIndirectCount)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef VkResult ( *PFN_vkCreateRenderPass2)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void ( *PFN_vkCmdBeginRenderPass2)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); -typedef void ( *PFN_vkCmdNextSubpass2)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); -typedef void ( *PFN_vkCmdEndRenderPass2)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); -typedef void ( *PFN_vkResetQueryPool)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -typedef VkResult ( *PFN_vkGetSemaphoreCounterValue)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); -typedef VkResult ( *PFN_vkWaitSemaphores)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); -typedef VkResult ( *PFN_vkSignalSemaphore)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); -typedef VkDeviceAddress ( *PFN_vkGetBufferDeviceAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t ( *PFN_vkGetBufferOpaqueCaptureAddress)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t ( *PFN_vkGetDeviceMemoryOpaqueCaptureAddress)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); -# 6558 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef uint64_t VkFlags64; -typedef struct VkPrivateDataSlot_T *VkPrivateDataSlot; - -typedef enum VkPipelineCreationFeedbackFlagBits { - VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT = 0x00000001, - VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT = 0x00000002, - VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT = 0x00000004, - VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_VALID_BIT, - VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_APPLICATION_PIPELINE_CACHE_HIT_BIT, - VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT_EXT = VK_PIPELINE_CREATION_FEEDBACK_BASE_PIPELINE_ACCELERATION_BIT, - VK_PIPELINE_CREATION_FEEDBACK_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkPipelineCreationFeedbackFlagBits; -typedef VkFlags VkPipelineCreationFeedbackFlags; - -typedef enum VkToolPurposeFlagBits { - VK_TOOL_PURPOSE_VALIDATION_BIT = 0x00000001, - VK_TOOL_PURPOSE_PROFILING_BIT = 0x00000002, - VK_TOOL_PURPOSE_TRACING_BIT = 0x00000004, - VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT = 0x00000008, - VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT = 0x00000010, - VK_TOOL_PURPOSE_DEBUG_REPORTING_BIT_EXT = 0x00000020, - VK_TOOL_PURPOSE_DEBUG_MARKERS_BIT_EXT = 0x00000040, - VK_TOOL_PURPOSE_VALIDATION_BIT_EXT = VK_TOOL_PURPOSE_VALIDATION_BIT, - VK_TOOL_PURPOSE_PROFILING_BIT_EXT = VK_TOOL_PURPOSE_PROFILING_BIT, - VK_TOOL_PURPOSE_TRACING_BIT_EXT = VK_TOOL_PURPOSE_TRACING_BIT, - VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_ADDITIONAL_FEATURES_BIT, - VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT_EXT = VK_TOOL_PURPOSE_MODIFYING_FEATURES_BIT, - VK_TOOL_PURPOSE_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkToolPurposeFlagBits; -typedef VkFlags VkToolPurposeFlags; -typedef VkFlags VkPrivateDataSlotCreateFlags; -typedef VkFlags64 VkPipelineStageFlags2; - - -typedef VkFlags64 VkPipelineStageFlagBits2; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE = 0ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_NONE_KHR = 0ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT = 0x00000001ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TOP_OF_PIPE_BIT_KHR = 0x00000001ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT = 0x00000002ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_DRAW_INDIRECT_BIT_KHR = 0x00000002ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT = 0x00000004ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_INPUT_BIT_KHR = 0x00000004ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT = 0x00000008ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_SHADER_BIT_KHR = 0x00000008ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT = 0x00000010ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_CONTROL_SHADER_BIT_KHR = 0x00000010ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT = 0x00000020ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TESSELLATION_EVALUATION_SHADER_BIT_KHR = 0x00000020ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT = 0x00000040ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_GEOMETRY_SHADER_BIT_KHR = 0x00000040ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT = 0x00000080ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADER_BIT_KHR = 0x00000080ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT = 0x00000100ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_EARLY_FRAGMENT_TESTS_BIT_KHR = 0x00000100ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT = 0x00000200ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_LATE_FRAGMENT_TESTS_BIT_KHR = 0x00000200ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT = 0x00000400ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COLOR_ATTACHMENT_OUTPUT_BIT_KHR = 0x00000400ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT = 0x00000800ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMPUTE_SHADER_BIT_KHR = 0x00000800ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT = 0x00001000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_TRANSFER_BIT_KHR = 0x00001000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT = 0x00001000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFER_BIT_KHR = 0x00001000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT = 0x00002000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BOTTOM_OF_PIPE_BIT_KHR = 0x00002000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT = 0x00004000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_HOST_BIT_KHR = 0x00004000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT = 0x00008000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_GRAPHICS_BIT_KHR = 0x00008000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT = 0x00010000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT_KHR = 0x00010000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT = 0x100000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COPY_BIT_KHR = 0x100000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT = 0x200000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RESOLVE_BIT_KHR = 0x200000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT = 0x400000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_BLIT_BIT_KHR = 0x400000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT = 0x800000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLEAR_BIT_KHR = 0x800000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT = 0x1000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INDEX_INPUT_BIT_KHR = 0x1000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT = 0x2000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VERTEX_ATTRIBUTE_INPUT_BIT_KHR = 0x2000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT = 0x4000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_PRE_RASTERIZATION_SHADERS_BIT_KHR = 0x4000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_VIDEO_DECODE_BIT_KHR = 0x04000000ULL; - - - -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TRANSFORM_FEEDBACK_BIT_EXT = 0x01000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00040000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_COMMAND_PREPROCESS_BIT_NV = 0x00020000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00400000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SHADING_RATE_IMAGE_BIT_NV = 0x00400000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_KHR = 0x02000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_KHR = 0x00200000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_RAY_TRACING_SHADER_BIT_NV = 0x00200000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_BUILD_BIT_NV = 0x02000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_FRAGMENT_DENSITY_PROCESS_BIT_EXT = 0x00800000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_NV = 0x00080000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_NV = 0x00100000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_TASK_SHADER_BIT_EXT = 0x00080000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MESH_SHADER_BIT_EXT = 0x00100000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADER_BIT_HUAWEI = 0x8000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_SUBPASS_SHADING_BIT_HUAWEI = 0x8000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_INVOCATION_MASK_BIT_HUAWEI = 0x10000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_ACCELERATION_STRUCTURE_COPY_BIT_KHR = 0x10000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_MICROMAP_BUILD_BIT_EXT = 0x40000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_CLUSTER_CULLING_SHADER_BIT_HUAWEI = 0x20000000000ULL; -static const VkPipelineStageFlagBits2 VK_PIPELINE_STAGE_2_OPTICAL_FLOW_BIT_NV = 0x20000000ULL; - -typedef VkFlags64 VkAccessFlags2; - - -typedef VkFlags64 VkAccessFlagBits2; -static const VkAccessFlagBits2 VK_ACCESS_2_NONE = 0ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_NONE_KHR = 0ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT = 0x00000001ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INDIRECT_COMMAND_READ_BIT_KHR = 0x00000001ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT = 0x00000002ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INDEX_READ_BIT_KHR = 0x00000002ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT = 0x00000004ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VERTEX_ATTRIBUTE_READ_BIT_KHR = 0x00000004ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT = 0x00000008ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_UNIFORM_READ_BIT_KHR = 0x00000008ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT = 0x00000010ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INPUT_ATTACHMENT_READ_BIT_KHR = 0x00000010ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT = 0x00000020ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_READ_BIT_KHR = 0x00000020ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT = 0x00000040ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_WRITE_BIT_KHR = 0x00000040ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT = 0x00000080ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_BIT_KHR = 0x00000080ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT = 0x00000100ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_WRITE_BIT_KHR = 0x00000100ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT = 0x00000200ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_READ_BIT_KHR = 0x00000200ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT = 0x00000400ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT_KHR = 0x00000400ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT = 0x00000800ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_READ_BIT_KHR = 0x00000800ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT = 0x00001000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFER_WRITE_BIT_KHR = 0x00001000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT = 0x00002000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_HOST_READ_BIT_KHR = 0x00002000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT = 0x00004000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_HOST_WRITE_BIT_KHR = 0x00004000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT = 0x00008000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_READ_BIT_KHR = 0x00008000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT = 0x00010000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MEMORY_WRITE_BIT_KHR = 0x00010000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT = 0x100000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_SAMPLED_READ_BIT_KHR = 0x100000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT = 0x200000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_READ_BIT_KHR = 0x200000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT = 0x400000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_STORAGE_WRITE_BIT_KHR = 0x400000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_READ_BIT_KHR = 0x800000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_VIDEO_DECODE_WRITE_BIT_KHR = 0x1000000000ULL; - - - - - - -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_WRITE_BIT_EXT = 0x02000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_READ_BIT_EXT = 0x04000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_TRANSFORM_FEEDBACK_COUNTER_WRITE_BIT_EXT = 0x08000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_CONDITIONAL_RENDERING_READ_BIT_EXT = 0x00100000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_READ_BIT_NV = 0x00020000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COMMAND_PREPROCESS_WRITE_BIT_NV = 0x00040000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_SHADING_RATE_ATTACHMENT_READ_BIT_KHR = 0x00800000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADING_RATE_IMAGE_READ_BIT_NV = 0x00800000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_KHR = 0x00200000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_KHR = 0x00400000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_READ_BIT_NV = 0x00200000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_ACCELERATION_STRUCTURE_WRITE_BIT_NV = 0x00400000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_FRAGMENT_DENSITY_MAP_READ_BIT_EXT = 0x01000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_COLOR_ATTACHMENT_READ_NONCOHERENT_BIT_EXT = 0x00080000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_DESCRIPTOR_BUFFER_READ_BIT_EXT = 0x20000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_INVOCATION_MASK_READ_BIT_HUAWEI = 0x8000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_SHADER_BINDING_TABLE_READ_BIT_KHR = 0x10000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_READ_BIT_EXT = 0x100000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_MICROMAP_WRITE_BIT_EXT = 0x200000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_READ_BIT_NV = 0x40000000000ULL; -static const VkAccessFlagBits2 VK_ACCESS_2_OPTICAL_FLOW_WRITE_BIT_NV = 0x80000000000ULL; - - -typedef enum VkSubmitFlagBits { - VK_SUBMIT_PROTECTED_BIT = 0x00000001, - VK_SUBMIT_PROTECTED_BIT_KHR = VK_SUBMIT_PROTECTED_BIT, - VK_SUBMIT_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkSubmitFlagBits; -typedef VkFlags VkSubmitFlags; - -typedef enum VkRenderingFlagBits { - VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT = 0x00000001, - VK_RENDERING_SUSPENDING_BIT = 0x00000002, - VK_RENDERING_RESUMING_BIT = 0x00000004, - VK_RENDERING_CONTENTS_INLINE_BIT_EXT = 0x00000010, - VK_RENDERING_ENABLE_LEGACY_DITHERING_BIT_EXT = 0x00000008, - VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT_KHR = VK_RENDERING_CONTENTS_SECONDARY_COMMAND_BUFFERS_BIT, - VK_RENDERING_SUSPENDING_BIT_KHR = VK_RENDERING_SUSPENDING_BIT, - VK_RENDERING_RESUMING_BIT_KHR = VK_RENDERING_RESUMING_BIT, - VK_RENDERING_FLAG_BITS_MAX_ENUM = 0x7FFFFFFF -} VkRenderingFlagBits; -typedef VkFlags VkRenderingFlags; -typedef VkFlags64 VkFormatFeatureFlags2; - - -typedef VkFlags64 VkFormatFeatureFlagBits2; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT = 0x00000001ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_BIT_KHR = 0x00000001ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT = 0x00000002ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_BIT_KHR = 0x00000002ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT = 0x00000004ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_IMAGE_ATOMIC_BIT_KHR = 0x00000004ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT = 0x00000008ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT = 0x00000010ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000010ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT = 0x00000020ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_TEXEL_BUFFER_ATOMIC_BIT_KHR = 0x00000020ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT = 0x00000040ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VERTEX_BUFFER_BIT_KHR = 0x00000040ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT = 0x00000080ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BIT_KHR = 0x00000080ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT = 0x00000100ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COLOR_ATTACHMENT_BLEND_BIT_KHR = 0x00000100ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT = 0x00000200ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DEPTH_STENCIL_ATTACHMENT_BIT_KHR = 0x00000200ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT = 0x00000400ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_SRC_BIT_KHR = 0x00000400ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT = 0x00000800ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLIT_DST_BIT_KHR = 0x00000800ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT = 0x00001000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_LINEAR_BIT_KHR = 0x00001000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT = 0x00002000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_CUBIC_BIT_EXT = 0x00002000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT = 0x00004000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_SRC_BIT_KHR = 0x00004000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT = 0x00008000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_TRANSFER_DST_BIT_KHR = 0x00008000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT = 0x00010000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR = 0x00010000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT = 0x00020000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_MIDPOINT_CHROMA_SAMPLES_BIT_KHR = 0x00020000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT = 0x00040000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR = 0x00040000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT = 0x00080000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR = 0x00080000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT = 0x00100000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR = 0x00100000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT = 0x00200000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR = 0x00200000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT = 0x00400000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_DISJOINT_BIT_KHR = 0x00400000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT = 0x00800000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_COSITED_CHROMA_SAMPLES_BIT_KHR = 0x00800000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT = 0x80000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_READ_WITHOUT_FORMAT_BIT_KHR = 0x80000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT = 0x100000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_STORAGE_WRITE_WITHOUT_FORMAT_BIT_KHR = 0x100000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT = 0x200000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT_KHR = 0x200000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_OUTPUT_BIT_KHR = 0x02000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_VIDEO_DECODE_DPB_BIT_KHR = 0x04000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_ACCELERATION_STRUCTURE_VERTEX_BUFFER_BIT_KHR = 0x20000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_DENSITY_MAP_BIT_EXT = 0x01000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x40000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_HOST_IMAGE_TRANSFER_BIT_EXT = 0x400000000000ULL; - - - - - - -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_LINEAR_COLOR_ATTACHMENT_BIT_NV = 0x4000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_IMAGE_BIT_QCOM = 0x400000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_WEIGHT_SAMPLED_IMAGE_BIT_QCOM = 0x800000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BLOCK_MATCHING_BIT_QCOM = 0x1000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_BOX_FILTER_SAMPLED_BIT_QCOM = 0x2000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_IMAGE_BIT_NV = 0x10000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_VECTOR_BIT_NV = 0x20000000000ULL; -static const VkFormatFeatureFlagBits2 VK_FORMAT_FEATURE_2_OPTICAL_FLOW_COST_BIT_NV = 0x40000000000ULL; - -typedef struct VkPhysicalDeviceVulkan13Features { - VkStructureType sType; - void* pNext; - VkBool32 robustImageAccess; - VkBool32 inlineUniformBlock; - VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; - VkBool32 pipelineCreationCacheControl; - VkBool32 privateData; - VkBool32 shaderDemoteToHelperInvocation; - VkBool32 shaderTerminateInvocation; - VkBool32 subgroupSizeControl; - VkBool32 computeFullSubgroups; - VkBool32 synchronization2; - VkBool32 textureCompressionASTC_HDR; - VkBool32 shaderZeroInitializeWorkgroupMemory; - VkBool32 dynamicRendering; - VkBool32 shaderIntegerDotProduct; - VkBool32 maintenance4; -} VkPhysicalDeviceVulkan13Features; - -typedef struct VkPhysicalDeviceVulkan13Properties { - VkStructureType sType; - void* pNext; - uint32_t minSubgroupSize; - uint32_t maxSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; - VkShaderStageFlags requiredSubgroupSizeStages; - uint32_t maxInlineUniformBlockSize; - uint32_t maxPerStageDescriptorInlineUniformBlocks; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - uint32_t maxDescriptorSetInlineUniformBlocks; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; - uint32_t maxInlineUniformTotalSize; - VkBool32 integerDotProduct8BitUnsignedAccelerated; - VkBool32 integerDotProduct8BitSignedAccelerated; - VkBool32 integerDotProduct8BitMixedSignednessAccelerated; - VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProduct16BitUnsignedAccelerated; - VkBool32 integerDotProduct16BitSignedAccelerated; - VkBool32 integerDotProduct16BitMixedSignednessAccelerated; - VkBool32 integerDotProduct32BitUnsignedAccelerated; - VkBool32 integerDotProduct32BitSignedAccelerated; - VkBool32 integerDotProduct32BitMixedSignednessAccelerated; - VkBool32 integerDotProduct64BitUnsignedAccelerated; - VkBool32 integerDotProduct64BitSignedAccelerated; - VkBool32 integerDotProduct64BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; - VkDeviceSize storageTexelBufferOffsetAlignmentBytes; - VkBool32 storageTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; - VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize maxBufferSize; -} VkPhysicalDeviceVulkan13Properties; - -typedef struct VkPipelineCreationFeedback { - VkPipelineCreationFeedbackFlags flags; - uint64_t duration; -} VkPipelineCreationFeedback; - -typedef struct VkPipelineCreationFeedbackCreateInfo { - VkStructureType sType; - const void* pNext; - VkPipelineCreationFeedback* pPipelineCreationFeedback; - uint32_t pipelineStageCreationFeedbackCount; - VkPipelineCreationFeedback* pPipelineStageCreationFeedbacks; -} VkPipelineCreationFeedbackCreateInfo; - -typedef struct VkPhysicalDeviceShaderTerminateInvocationFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderTerminateInvocation; -} VkPhysicalDeviceShaderTerminateInvocationFeatures; - -typedef struct VkPhysicalDeviceToolProperties { - VkStructureType sType; - void* pNext; - char name[256U]; - char version[256U]; - VkToolPurposeFlags purposes; - char description[256U]; - char layer[256U]; -} VkPhysicalDeviceToolProperties; - -typedef struct VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderDemoteToHelperInvocation; -} VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures; - -typedef struct VkPhysicalDevicePrivateDataFeatures { - VkStructureType sType; - void* pNext; - VkBool32 privateData; -} VkPhysicalDevicePrivateDataFeatures; - -typedef struct VkDevicePrivateDataCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t privateDataSlotRequestCount; -} VkDevicePrivateDataCreateInfo; - -typedef struct VkPrivateDataSlotCreateInfo { - VkStructureType sType; - const void* pNext; - VkPrivateDataSlotCreateFlags flags; -} VkPrivateDataSlotCreateInfo; - -typedef struct VkPhysicalDevicePipelineCreationCacheControlFeatures { - VkStructureType sType; - void* pNext; - VkBool32 pipelineCreationCacheControl; -} VkPhysicalDevicePipelineCreationCacheControlFeatures; - -typedef struct VkMemoryBarrier2 { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2 srcStageMask; - VkAccessFlags2 srcAccessMask; - VkPipelineStageFlags2 dstStageMask; - VkAccessFlags2 dstAccessMask; -} VkMemoryBarrier2; - -typedef struct VkBufferMemoryBarrier2 { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2 srcStageMask; - VkAccessFlags2 srcAccessMask; - VkPipelineStageFlags2 dstStageMask; - VkAccessFlags2 dstAccessMask; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; -} VkBufferMemoryBarrier2; - -typedef struct VkImageMemoryBarrier2 { - VkStructureType sType; - const void* pNext; - VkPipelineStageFlags2 srcStageMask; - VkAccessFlags2 srcAccessMask; - VkPipelineStageFlags2 dstStageMask; - VkAccessFlags2 dstAccessMask; - VkImageLayout oldLayout; - VkImageLayout newLayout; - uint32_t srcQueueFamilyIndex; - uint32_t dstQueueFamilyIndex; - VkImage image; - VkImageSubresourceRange subresourceRange; -} VkImageMemoryBarrier2; - -typedef struct VkDependencyInfo { - VkStructureType sType; - const void* pNext; - VkDependencyFlags dependencyFlags; - uint32_t memoryBarrierCount; - const VkMemoryBarrier2* pMemoryBarriers; - uint32_t bufferMemoryBarrierCount; - const VkBufferMemoryBarrier2* pBufferMemoryBarriers; - uint32_t imageMemoryBarrierCount; - const VkImageMemoryBarrier2* pImageMemoryBarriers; -} VkDependencyInfo; - -typedef struct VkSemaphoreSubmitInfo { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - uint64_t value; - VkPipelineStageFlags2 stageMask; - uint32_t deviceIndex; -} VkSemaphoreSubmitInfo; - -typedef struct VkCommandBufferSubmitInfo { - VkStructureType sType; - const void* pNext; - VkCommandBuffer commandBuffer; - uint32_t deviceMask; -} VkCommandBufferSubmitInfo; - -typedef struct VkSubmitInfo2 { - VkStructureType sType; - const void* pNext; - VkSubmitFlags flags; - uint32_t waitSemaphoreInfoCount; - const VkSemaphoreSubmitInfo* pWaitSemaphoreInfos; - uint32_t commandBufferInfoCount; - const VkCommandBufferSubmitInfo* pCommandBufferInfos; - uint32_t signalSemaphoreInfoCount; - const VkSemaphoreSubmitInfo* pSignalSemaphoreInfos; -} VkSubmitInfo2; - -typedef struct VkPhysicalDeviceSynchronization2Features { - VkStructureType sType; - void* pNext; - VkBool32 synchronization2; -} VkPhysicalDeviceSynchronization2Features; - -typedef struct VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderZeroInitializeWorkgroupMemory; -} VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures; - -typedef struct VkPhysicalDeviceImageRobustnessFeatures { - VkStructureType sType; - void* pNext; - VkBool32 robustImageAccess; -} VkPhysicalDeviceImageRobustnessFeatures; - -typedef struct VkBufferCopy2 { - VkStructureType sType; - const void* pNext; - VkDeviceSize srcOffset; - VkDeviceSize dstOffset; - VkDeviceSize size; -} VkBufferCopy2; - -typedef struct VkCopyBufferInfo2 { - VkStructureType sType; - const void* pNext; - VkBuffer srcBuffer; - VkBuffer dstBuffer; - uint32_t regionCount; - const VkBufferCopy2* pRegions; -} VkCopyBufferInfo2; - -typedef struct VkImageCopy2 { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageCopy2; - -typedef struct VkCopyImageInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageCopy2* pRegions; -} VkCopyImageInfo2; - -typedef struct VkBufferImageCopy2 { - VkStructureType sType; - const void* pNext; - VkDeviceSize bufferOffset; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkBufferImageCopy2; - -typedef struct VkCopyBufferToImageInfo2 { - VkStructureType sType; - const void* pNext; - VkBuffer srcBuffer; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkBufferImageCopy2* pRegions; -} VkCopyBufferToImageInfo2; - -typedef struct VkCopyImageToBufferInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkBuffer dstBuffer; - uint32_t regionCount; - const VkBufferImageCopy2* pRegions; -} VkCopyImageToBufferInfo2; - -typedef struct VkImageBlit2 { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffsets[2]; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffsets[2]; -} VkImageBlit2; - -typedef struct VkBlitImageInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageBlit2* pRegions; - VkFilter filter; -} VkBlitImageInfo2; - -typedef struct VkImageResolve2 { - VkStructureType sType; - const void* pNext; - VkImageSubresourceLayers srcSubresource; - VkOffset3D srcOffset; - VkImageSubresourceLayers dstSubresource; - VkOffset3D dstOffset; - VkExtent3D extent; -} VkImageResolve2; - -typedef struct VkResolveImageInfo2 { - VkStructureType sType; - const void* pNext; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageResolve2* pRegions; -} VkResolveImageInfo2; - -typedef struct VkPhysicalDeviceSubgroupSizeControlFeatures { - VkStructureType sType; - void* pNext; - VkBool32 subgroupSizeControl; - VkBool32 computeFullSubgroups; -} VkPhysicalDeviceSubgroupSizeControlFeatures; - -typedef struct VkPhysicalDeviceSubgroupSizeControlProperties { - VkStructureType sType; - void* pNext; - uint32_t minSubgroupSize; - uint32_t maxSubgroupSize; - uint32_t maxComputeWorkgroupSubgroups; - VkShaderStageFlags requiredSubgroupSizeStages; -} VkPhysicalDeviceSubgroupSizeControlProperties; - -typedef struct VkPipelineShaderStageRequiredSubgroupSizeCreateInfo { - VkStructureType sType; - void* pNext; - uint32_t requiredSubgroupSize; -} VkPipelineShaderStageRequiredSubgroupSizeCreateInfo; - -typedef struct VkPhysicalDeviceInlineUniformBlockFeatures { - VkStructureType sType; - void* pNext; - VkBool32 inlineUniformBlock; - VkBool32 descriptorBindingInlineUniformBlockUpdateAfterBind; -} VkPhysicalDeviceInlineUniformBlockFeatures; - -typedef struct VkPhysicalDeviceInlineUniformBlockProperties { - VkStructureType sType; - void* pNext; - uint32_t maxInlineUniformBlockSize; - uint32_t maxPerStageDescriptorInlineUniformBlocks; - uint32_t maxPerStageDescriptorUpdateAfterBindInlineUniformBlocks; - uint32_t maxDescriptorSetInlineUniformBlocks; - uint32_t maxDescriptorSetUpdateAfterBindInlineUniformBlocks; -} VkPhysicalDeviceInlineUniformBlockProperties; - -typedef struct VkWriteDescriptorSetInlineUniformBlock { - VkStructureType sType; - const void* pNext; - uint32_t dataSize; - const void* pData; -} VkWriteDescriptorSetInlineUniformBlock; - -typedef struct VkDescriptorPoolInlineUniformBlockCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t maxInlineUniformBlockBindings; -} VkDescriptorPoolInlineUniformBlockCreateInfo; - -typedef struct VkPhysicalDeviceTextureCompressionASTCHDRFeatures { - VkStructureType sType; - void* pNext; - VkBool32 textureCompressionASTC_HDR; -} VkPhysicalDeviceTextureCompressionASTCHDRFeatures; - -typedef struct VkRenderingAttachmentInfo { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkImageLayout imageLayout; - VkResolveModeFlagBits resolveMode; - VkImageView resolveImageView; - VkImageLayout resolveImageLayout; - VkAttachmentLoadOp loadOp; - VkAttachmentStoreOp storeOp; - VkClearValue clearValue; -} VkRenderingAttachmentInfo; - -typedef struct VkRenderingInfo { - VkStructureType sType; - const void* pNext; - VkRenderingFlags flags; - VkRect2D renderArea; - uint32_t layerCount; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkRenderingAttachmentInfo* pColorAttachments; - const VkRenderingAttachmentInfo* pDepthAttachment; - const VkRenderingAttachmentInfo* pStencilAttachment; -} VkRenderingInfo; - -typedef struct VkPipelineRenderingCreateInfo { - VkStructureType sType; - const void* pNext; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; -} VkPipelineRenderingCreateInfo; - -typedef struct VkPhysicalDeviceDynamicRenderingFeatures { - VkStructureType sType; - void* pNext; - VkBool32 dynamicRendering; -} VkPhysicalDeviceDynamicRenderingFeatures; - -typedef struct VkCommandBufferInheritanceRenderingInfo { - VkStructureType sType; - const void* pNext; - VkRenderingFlags flags; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; - VkSampleCountFlagBits rasterizationSamples; -} VkCommandBufferInheritanceRenderingInfo; - -typedef struct VkPhysicalDeviceShaderIntegerDotProductFeatures { - VkStructureType sType; - void* pNext; - VkBool32 shaderIntegerDotProduct; -} VkPhysicalDeviceShaderIntegerDotProductFeatures; - -typedef struct VkPhysicalDeviceShaderIntegerDotProductProperties { - VkStructureType sType; - void* pNext; - VkBool32 integerDotProduct8BitUnsignedAccelerated; - VkBool32 integerDotProduct8BitSignedAccelerated; - VkBool32 integerDotProduct8BitMixedSignednessAccelerated; - VkBool32 integerDotProduct4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedSignedAccelerated; - VkBool32 integerDotProduct4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProduct16BitUnsignedAccelerated; - VkBool32 integerDotProduct16BitSignedAccelerated; - VkBool32 integerDotProduct16BitMixedSignednessAccelerated; - VkBool32 integerDotProduct32BitUnsignedAccelerated; - VkBool32 integerDotProduct32BitSignedAccelerated; - VkBool32 integerDotProduct32BitMixedSignednessAccelerated; - VkBool32 integerDotProduct64BitUnsignedAccelerated; - VkBool32 integerDotProduct64BitSignedAccelerated; - VkBool32 integerDotProduct64BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating8BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating4x8BitPackedMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating16BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating32BitMixedSignednessAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitUnsignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitSignedAccelerated; - VkBool32 integerDotProductAccumulatingSaturating64BitMixedSignednessAccelerated; -} VkPhysicalDeviceShaderIntegerDotProductProperties; - -typedef struct VkPhysicalDeviceTexelBufferAlignmentProperties { - VkStructureType sType; - void* pNext; - VkDeviceSize storageTexelBufferOffsetAlignmentBytes; - VkBool32 storageTexelBufferOffsetSingleTexelAlignment; - VkDeviceSize uniformTexelBufferOffsetAlignmentBytes; - VkBool32 uniformTexelBufferOffsetSingleTexelAlignment; -} VkPhysicalDeviceTexelBufferAlignmentProperties; - -typedef struct VkFormatProperties3 { - VkStructureType sType; - void* pNext; - VkFormatFeatureFlags2 linearTilingFeatures; - VkFormatFeatureFlags2 optimalTilingFeatures; - VkFormatFeatureFlags2 bufferFeatures; -} VkFormatProperties3; - -typedef struct VkPhysicalDeviceMaintenance4Features { - VkStructureType sType; - void* pNext; - VkBool32 maintenance4; -} VkPhysicalDeviceMaintenance4Features; - -typedef struct VkPhysicalDeviceMaintenance4Properties { - VkStructureType sType; - void* pNext; - VkDeviceSize maxBufferSize; -} VkPhysicalDeviceMaintenance4Properties; - -typedef struct VkDeviceBufferMemoryRequirements { - VkStructureType sType; - const void* pNext; - const VkBufferCreateInfo* pCreateInfo; -} VkDeviceBufferMemoryRequirements; - -typedef struct VkDeviceImageMemoryRequirements { - VkStructureType sType; - const void* pNext; - const VkImageCreateInfo* pCreateInfo; - VkImageAspectFlagBits planeAspect; -} VkDeviceImageMemoryRequirements; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceToolProperties)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); -typedef VkResult ( *PFN_vkCreatePrivateDataSlot)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); -typedef void ( *PFN_vkDestroyPrivateDataSlot)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkSetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); -typedef void ( *PFN_vkGetPrivateData)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); -typedef void ( *PFN_vkCmdSetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); -typedef void ( *PFN_vkCmdResetEvent2)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); -typedef void ( *PFN_vkCmdWaitEvents2)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); -typedef void ( *PFN_vkCmdPipelineBarrier2)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); -typedef void ( *PFN_vkCmdWriteTimestamp2)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); -typedef VkResult ( *PFN_vkQueueSubmit2)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); -typedef void ( *PFN_vkCmdCopyBuffer2)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); -typedef void ( *PFN_vkCmdCopyImage2)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); -typedef void ( *PFN_vkCmdCopyBufferToImage2)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); -typedef void ( *PFN_vkCmdCopyImageToBuffer2)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); -typedef void ( *PFN_vkCmdBlitImage2)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); -typedef void ( *PFN_vkCmdResolveImage2)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); -typedef void ( *PFN_vkCmdBeginRendering)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); -typedef void ( *PFN_vkCmdEndRendering)(VkCommandBuffer commandBuffer); -typedef void ( *PFN_vkCmdSetCullMode)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); -typedef void ( *PFN_vkCmdSetFrontFace)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); -typedef void ( *PFN_vkCmdSetPrimitiveTopology)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); -typedef void ( *PFN_vkCmdSetViewportWithCount)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); -typedef void ( *PFN_vkCmdSetScissorWithCount)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void ( *PFN_vkCmdBindVertexBuffers2)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); -typedef void ( *PFN_vkCmdSetDepthTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); -typedef void ( *PFN_vkCmdSetDepthWriteEnable)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); -typedef void ( *PFN_vkCmdSetDepthCompareOp)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); -typedef void ( *PFN_vkCmdSetDepthBoundsTestEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); -typedef void ( *PFN_vkCmdSetStencilTestEnable)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); -typedef void ( *PFN_vkCmdSetStencilOp)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); -typedef void ( *PFN_vkCmdSetRasterizerDiscardEnable)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); -typedef void ( *PFN_vkCmdSetDepthBiasEnable)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); -typedef void ( *PFN_vkCmdSetPrimitiveRestartEnable)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); -typedef void ( *PFN_vkGetDeviceBufferMemoryRequirements)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkGetDeviceImageMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkGetDeviceImageSparseMemoryRequirements)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -# 7600 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkSurfaceKHR_T *VkSurfaceKHR; - - - -typedef enum VkPresentModeKHR { - VK_PRESENT_MODE_IMMEDIATE_KHR = 0, - VK_PRESENT_MODE_MAILBOX_KHR = 1, - VK_PRESENT_MODE_FIFO_KHR = 2, - VK_PRESENT_MODE_FIFO_RELAXED_KHR = 3, - VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR = 1000111000, - VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR = 1000111001, - VK_PRESENT_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPresentModeKHR; - -typedef enum VkColorSpaceKHR { - VK_COLOR_SPACE_SRGB_NONLINEAR_KHR = 0, - VK_COLOR_SPACE_DISPLAY_P3_NONLINEAR_EXT = 1000104001, - VK_COLOR_SPACE_EXTENDED_SRGB_LINEAR_EXT = 1000104002, - VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT = 1000104003, - VK_COLOR_SPACE_DCI_P3_NONLINEAR_EXT = 1000104004, - VK_COLOR_SPACE_BT709_LINEAR_EXT = 1000104005, - VK_COLOR_SPACE_BT709_NONLINEAR_EXT = 1000104006, - VK_COLOR_SPACE_BT2020_LINEAR_EXT = 1000104007, - VK_COLOR_SPACE_HDR10_ST2084_EXT = 1000104008, - VK_COLOR_SPACE_DOLBYVISION_EXT = 1000104009, - VK_COLOR_SPACE_HDR10_HLG_EXT = 1000104010, - VK_COLOR_SPACE_ADOBERGB_LINEAR_EXT = 1000104011, - VK_COLOR_SPACE_ADOBERGB_NONLINEAR_EXT = 1000104012, - VK_COLOR_SPACE_PASS_THROUGH_EXT = 1000104013, - VK_COLOR_SPACE_EXTENDED_SRGB_NONLINEAR_EXT = 1000104014, - VK_COLOR_SPACE_DISPLAY_NATIVE_AMD = 1000213000, - VK_COLORSPACE_SRGB_NONLINEAR_KHR = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR, - VK_COLOR_SPACE_DCI_P3_LINEAR_EXT = VK_COLOR_SPACE_DISPLAY_P3_LINEAR_EXT, - VK_COLOR_SPACE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkColorSpaceKHR; - -typedef enum VkSurfaceTransformFlagBitsKHR { - VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR = 0x00000001, - VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR = 0x00000002, - VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR = 0x00000004, - VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR = 0x00000008, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR = 0x00000010, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR = 0x00000020, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR = 0x00000040, - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR = 0x00000080, - VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR = 0x00000100, - VK_SURFACE_TRANSFORM_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkSurfaceTransformFlagBitsKHR; - -typedef enum VkCompositeAlphaFlagBitsKHR { - VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR = 0x00000002, - VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR = 0x00000004, - VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR = 0x00000008, - VK_COMPOSITE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkCompositeAlphaFlagBitsKHR; -typedef VkFlags VkCompositeAlphaFlagsKHR; -typedef VkFlags VkSurfaceTransformFlagsKHR; -typedef struct VkSurfaceCapabilitiesKHR { - uint32_t minImageCount; - uint32_t maxImageCount; - VkExtent2D currentExtent; - VkExtent2D minImageExtent; - VkExtent2D maxImageExtent; - uint32_t maxImageArrayLayers; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkSurfaceTransformFlagBitsKHR currentTransform; - VkCompositeAlphaFlagsKHR supportedCompositeAlpha; - VkImageUsageFlags supportedUsageFlags; -} VkSurfaceCapabilitiesKHR; - -typedef struct VkSurfaceFormatKHR { - VkFormat format; - VkColorSpaceKHR colorSpace; -} VkSurfaceFormatKHR; - -typedef void ( *PFN_vkDestroySurfaceKHR)(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceSupportKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); -typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); -typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceFormatsKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); -typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfacePresentModesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); -# 7715 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkSwapchainKHR_T *VkSwapchainKHR; - - - -typedef enum VkSwapchainCreateFlagBitsKHR { - VK_SWAPCHAIN_CREATE_SPLIT_INSTANCE_BIND_REGIONS_BIT_KHR = 0x00000001, - VK_SWAPCHAIN_CREATE_PROTECTED_BIT_KHR = 0x00000002, - VK_SWAPCHAIN_CREATE_MUTABLE_FORMAT_BIT_KHR = 0x00000004, - VK_SWAPCHAIN_CREATE_DEFERRED_MEMORY_ALLOCATION_BIT_EXT = 0x00000008, - VK_SWAPCHAIN_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkSwapchainCreateFlagBitsKHR; -typedef VkFlags VkSwapchainCreateFlagsKHR; - -typedef enum VkDeviceGroupPresentModeFlagBitsKHR { - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR = 0x00000001, - VK_DEVICE_GROUP_PRESENT_MODE_REMOTE_BIT_KHR = 0x00000002, - VK_DEVICE_GROUP_PRESENT_MODE_SUM_BIT_KHR = 0x00000004, - VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_MULTI_DEVICE_BIT_KHR = 0x00000008, - VK_DEVICE_GROUP_PRESENT_MODE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkDeviceGroupPresentModeFlagBitsKHR; -typedef VkFlags VkDeviceGroupPresentModeFlagsKHR; -typedef struct VkSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainCreateFlagsKHR flags; - VkSurfaceKHR surface; - uint32_t minImageCount; - VkFormat imageFormat; - VkColorSpaceKHR imageColorSpace; - VkExtent2D imageExtent; - uint32_t imageArrayLayers; - VkImageUsageFlags imageUsage; - VkSharingMode imageSharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; - VkSurfaceTransformFlagBitsKHR preTransform; - VkCompositeAlphaFlagBitsKHR compositeAlpha; - VkPresentModeKHR presentMode; - VkBool32 clipped; - VkSwapchainKHR oldSwapchain; -} VkSwapchainCreateInfoKHR; - -typedef struct VkPresentInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t waitSemaphoreCount; - const VkSemaphore* pWaitSemaphores; - uint32_t swapchainCount; - const VkSwapchainKHR* pSwapchains; - const uint32_t* pImageIndices; - VkResult* pResults; -} VkPresentInfoKHR; - -typedef struct VkImageSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; -} VkImageSwapchainCreateInfoKHR; - -typedef struct VkBindImageMemorySwapchainInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint32_t imageIndex; -} VkBindImageMemorySwapchainInfoKHR; - -typedef struct VkAcquireNextImageInfoKHR { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint64_t timeout; - VkSemaphore semaphore; - VkFence fence; - uint32_t deviceMask; -} VkAcquireNextImageInfoKHR; - -typedef struct VkDeviceGroupPresentCapabilitiesKHR { - VkStructureType sType; - void* pNext; - uint32_t presentMask[32U]; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupPresentCapabilitiesKHR; - -typedef struct VkDeviceGroupPresentInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const uint32_t* pDeviceMasks; - VkDeviceGroupPresentModeFlagBitsKHR mode; -} VkDeviceGroupPresentInfoKHR; - -typedef struct VkDeviceGroupSwapchainCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceGroupPresentModeFlagsKHR modes; -} VkDeviceGroupSwapchainCreateInfoKHR; - -typedef VkResult ( *PFN_vkCreateSwapchainKHR)(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); -typedef void ( *PFN_vkDestroySwapchainKHR)(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkGetSwapchainImagesKHR)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); -typedef VkResult ( *PFN_vkAcquireNextImageKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); -typedef VkResult ( *PFN_vkQueuePresentKHR)(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); -typedef VkResult ( *PFN_vkGetDeviceGroupPresentCapabilitiesKHR)(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); -typedef VkResult ( *PFN_vkGetDeviceGroupSurfacePresentModesKHR)(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes); -typedef VkResult ( *PFN_vkGetPhysicalDevicePresentRectanglesKHR)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects); -typedef VkResult ( *PFN_vkAcquireNextImage2KHR)(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex); -# 7876 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkDisplayKHR_T *VkDisplayKHR; -typedef struct VkDisplayModeKHR_T *VkDisplayModeKHR; - - -typedef VkFlags VkDisplayModeCreateFlagsKHR; - -typedef enum VkDisplayPlaneAlphaFlagBitsKHR { - VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR = 0x00000001, - VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR = 0x00000002, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR = 0x00000004, - VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR = 0x00000008, - VK_DISPLAY_PLANE_ALPHA_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkDisplayPlaneAlphaFlagBitsKHR; -typedef VkFlags VkDisplayPlaneAlphaFlagsKHR; -typedef VkFlags VkDisplaySurfaceCreateFlagsKHR; -typedef struct VkDisplayModeParametersKHR { - VkExtent2D visibleRegion; - uint32_t refreshRate; -} VkDisplayModeParametersKHR; - -typedef struct VkDisplayModeCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDisplayModeCreateFlagsKHR flags; - VkDisplayModeParametersKHR parameters; -} VkDisplayModeCreateInfoKHR; - -typedef struct VkDisplayModePropertiesKHR { - VkDisplayModeKHR displayMode; - VkDisplayModeParametersKHR parameters; -} VkDisplayModePropertiesKHR; - -typedef struct VkDisplayPlaneCapabilitiesKHR { - VkDisplayPlaneAlphaFlagsKHR supportedAlpha; - VkOffset2D minSrcPosition; - VkOffset2D maxSrcPosition; - VkExtent2D minSrcExtent; - VkExtent2D maxSrcExtent; - VkOffset2D minDstPosition; - VkOffset2D maxDstPosition; - VkExtent2D minDstExtent; - VkExtent2D maxDstExtent; -} VkDisplayPlaneCapabilitiesKHR; - -typedef struct VkDisplayPlanePropertiesKHR { - VkDisplayKHR currentDisplay; - uint32_t currentStackIndex; -} VkDisplayPlanePropertiesKHR; - -typedef struct VkDisplayPropertiesKHR { - VkDisplayKHR display; - const char* displayName; - VkExtent2D physicalDimensions; - VkExtent2D physicalResolution; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkBool32 planeReorderPossible; - VkBool32 persistentContent; -} VkDisplayPropertiesKHR; - -typedef struct VkDisplaySurfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkDisplaySurfaceCreateFlagsKHR flags; - VkDisplayModeKHR displayMode; - uint32_t planeIndex; - uint32_t planeStackIndex; - VkSurfaceTransformFlagBitsKHR transform; - float globalAlpha; - VkDisplayPlaneAlphaFlagBitsKHR alphaMode; - VkExtent2D imageExtent; -} VkDisplaySurfaceCreateInfoKHR; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceDisplayPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties); -typedef VkResult ( *PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties); -typedef VkResult ( *PFN_vkGetDisplayPlaneSupportedDisplaysKHR)(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays); -typedef VkResult ( *PFN_vkGetDisplayModePropertiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties); -typedef VkResult ( *PFN_vkCreateDisplayModeKHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode); -typedef VkResult ( *PFN_vkGetDisplayPlaneCapabilitiesKHR)(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities); -typedef VkResult ( *PFN_vkCreateDisplayPlaneSurfaceKHR)(VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -# 8004 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkDisplayPresentInfoKHR { - VkStructureType sType; - const void* pNext; - VkRect2D srcRect; - VkRect2D dstRect; - VkBool32 persistent; -} VkDisplayPresentInfoKHR; - -typedef VkResult ( *PFN_vkCreateSharedSwapchainsKHR)(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains); -# 8032 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkVideoSessionKHR_T *VkVideoSessionKHR; -typedef struct VkVideoSessionParametersKHR_T *VkVideoSessionParametersKHR; - - - -typedef enum VkQueryResultStatusKHR { - VK_QUERY_RESULT_STATUS_ERROR_KHR = -1, - VK_QUERY_RESULT_STATUS_NOT_READY_KHR = 0, - VK_QUERY_RESULT_STATUS_COMPLETE_KHR = 1, - VK_QUERY_RESULT_STATUS_INSUFFICIENT_BITSTREAM_BUFFER_RANGE_KHR = -1000299000, - VK_QUERY_RESULT_STATUS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkQueryResultStatusKHR; - -typedef enum VkVideoCodecOperationFlagBitsKHR { - VK_VIDEO_CODEC_OPERATION_NONE_KHR = 0, - - - - - - - VK_VIDEO_CODEC_OPERATION_DECODE_H264_BIT_KHR = 0x00000001, - VK_VIDEO_CODEC_OPERATION_DECODE_H265_BIT_KHR = 0x00000002, - VK_VIDEO_CODEC_OPERATION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoCodecOperationFlagBitsKHR; -typedef VkFlags VkVideoCodecOperationFlagsKHR; - -typedef enum VkVideoChromaSubsamplingFlagBitsKHR { - VK_VIDEO_CHROMA_SUBSAMPLING_INVALID_KHR = 0, - VK_VIDEO_CHROMA_SUBSAMPLING_MONOCHROME_BIT_KHR = 0x00000001, - VK_VIDEO_CHROMA_SUBSAMPLING_420_BIT_KHR = 0x00000002, - VK_VIDEO_CHROMA_SUBSAMPLING_422_BIT_KHR = 0x00000004, - VK_VIDEO_CHROMA_SUBSAMPLING_444_BIT_KHR = 0x00000008, - VK_VIDEO_CHROMA_SUBSAMPLING_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoChromaSubsamplingFlagBitsKHR; -typedef VkFlags VkVideoChromaSubsamplingFlagsKHR; - -typedef enum VkVideoComponentBitDepthFlagBitsKHR { - VK_VIDEO_COMPONENT_BIT_DEPTH_INVALID_KHR = 0, - VK_VIDEO_COMPONENT_BIT_DEPTH_8_BIT_KHR = 0x00000001, - VK_VIDEO_COMPONENT_BIT_DEPTH_10_BIT_KHR = 0x00000004, - VK_VIDEO_COMPONENT_BIT_DEPTH_12_BIT_KHR = 0x00000010, - VK_VIDEO_COMPONENT_BIT_DEPTH_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoComponentBitDepthFlagBitsKHR; -typedef VkFlags VkVideoComponentBitDepthFlagsKHR; - -typedef enum VkVideoCapabilityFlagBitsKHR { - VK_VIDEO_CAPABILITY_PROTECTED_CONTENT_BIT_KHR = 0x00000001, - VK_VIDEO_CAPABILITY_SEPARATE_REFERENCE_IMAGES_BIT_KHR = 0x00000002, - VK_VIDEO_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoCapabilityFlagBitsKHR; -typedef VkFlags VkVideoCapabilityFlagsKHR; - -typedef enum VkVideoSessionCreateFlagBitsKHR { - VK_VIDEO_SESSION_CREATE_PROTECTED_CONTENT_BIT_KHR = 0x00000001, - - - - VK_VIDEO_SESSION_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoSessionCreateFlagBitsKHR; -typedef VkFlags VkVideoSessionCreateFlagsKHR; -typedef VkFlags VkVideoSessionParametersCreateFlagsKHR; -typedef VkFlags VkVideoBeginCodingFlagsKHR; -typedef VkFlags VkVideoEndCodingFlagsKHR; - -typedef enum VkVideoCodingControlFlagBitsKHR { - VK_VIDEO_CODING_CONTROL_RESET_BIT_KHR = 0x00000001, - - - - - - - VK_VIDEO_CODING_CONTROL_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoCodingControlFlagBitsKHR; -typedef VkFlags VkVideoCodingControlFlagsKHR; -typedef struct VkQueueFamilyQueryResultStatusPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 queryResultStatusSupport; -} VkQueueFamilyQueryResultStatusPropertiesKHR; - -typedef struct VkQueueFamilyVideoPropertiesKHR { - VkStructureType sType; - void* pNext; - VkVideoCodecOperationFlagsKHR videoCodecOperations; -} VkQueueFamilyVideoPropertiesKHR; - -typedef struct VkVideoProfileInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoCodecOperationFlagBitsKHR videoCodecOperation; - VkVideoChromaSubsamplingFlagsKHR chromaSubsampling; - VkVideoComponentBitDepthFlagsKHR lumaBitDepth; - VkVideoComponentBitDepthFlagsKHR chromaBitDepth; -} VkVideoProfileInfoKHR; - -typedef struct VkVideoProfileListInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t profileCount; - const VkVideoProfileInfoKHR* pProfiles; -} VkVideoProfileListInfoKHR; - -typedef struct VkVideoCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoCapabilityFlagsKHR flags; - VkDeviceSize minBitstreamBufferOffsetAlignment; - VkDeviceSize minBitstreamBufferSizeAlignment; - VkExtent2D pictureAccessGranularity; - VkExtent2D minCodedExtent; - VkExtent2D maxCodedExtent; - uint32_t maxDpbSlots; - uint32_t maxActiveReferencePictures; - VkExtensionProperties stdHeaderVersion; -} VkVideoCapabilitiesKHR; - -typedef struct VkPhysicalDeviceVideoFormatInfoKHR { - VkStructureType sType; - const void* pNext; - VkImageUsageFlags imageUsage; -} VkPhysicalDeviceVideoFormatInfoKHR; - -typedef struct VkVideoFormatPropertiesKHR { - VkStructureType sType; - void* pNext; - VkFormat format; - VkComponentMapping componentMapping; - VkImageCreateFlags imageCreateFlags; - VkImageType imageType; - VkImageTiling imageTiling; - VkImageUsageFlags imageUsageFlags; -} VkVideoFormatPropertiesKHR; - -typedef struct VkVideoPictureResourceInfoKHR { - VkStructureType sType; - const void* pNext; - VkOffset2D codedOffset; - VkExtent2D codedExtent; - uint32_t baseArrayLayer; - VkImageView imageViewBinding; -} VkVideoPictureResourceInfoKHR; - -typedef struct VkVideoReferenceSlotInfoKHR { - VkStructureType sType; - const void* pNext; - int32_t slotIndex; - const VkVideoPictureResourceInfoKHR* pPictureResource; -} VkVideoReferenceSlotInfoKHR; - -typedef struct VkVideoSessionMemoryRequirementsKHR { - VkStructureType sType; - void* pNext; - uint32_t memoryBindIndex; - VkMemoryRequirements memoryRequirements; -} VkVideoSessionMemoryRequirementsKHR; - -typedef struct VkBindVideoSessionMemoryInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t memoryBindIndex; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - VkDeviceSize memorySize; -} VkBindVideoSessionMemoryInfoKHR; - -typedef struct VkVideoSessionCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t queueFamilyIndex; - VkVideoSessionCreateFlagsKHR flags; - const VkVideoProfileInfoKHR* pVideoProfile; - VkFormat pictureFormat; - VkExtent2D maxCodedExtent; - VkFormat referencePictureFormat; - uint32_t maxDpbSlots; - uint32_t maxActiveReferencePictures; - const VkExtensionProperties* pStdHeaderVersion; -} VkVideoSessionCreateInfoKHR; - -typedef struct VkVideoSessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoSessionParametersCreateFlagsKHR flags; - VkVideoSessionParametersKHR videoSessionParametersTemplate; - VkVideoSessionKHR videoSession; -} VkVideoSessionParametersCreateInfoKHR; - -typedef struct VkVideoSessionParametersUpdateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t updateSequenceCount; -} VkVideoSessionParametersUpdateInfoKHR; - -typedef struct VkVideoBeginCodingInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoBeginCodingFlagsKHR flags; - VkVideoSessionKHR videoSession; - VkVideoSessionParametersKHR videoSessionParameters; - uint32_t referenceSlotCount; - const VkVideoReferenceSlotInfoKHR* pReferenceSlots; -} VkVideoBeginCodingInfoKHR; - -typedef struct VkVideoEndCodingInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoEndCodingFlagsKHR flags; -} VkVideoEndCodingInfoKHR; - -typedef struct VkVideoCodingControlInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoCodingControlFlagsKHR flags; -} VkVideoCodingControlInfoKHR; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR)(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities); -typedef VkResult ( *PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties); -typedef VkResult ( *PFN_vkCreateVideoSessionKHR)(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession); -typedef void ( *PFN_vkDestroyVideoSessionKHR)(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkGetVideoSessionMemoryRequirementsKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); -typedef VkResult ( *PFN_vkBindVideoSessionMemoryKHR)(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); -typedef VkResult ( *PFN_vkCreateVideoSessionParametersKHR)(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters); -typedef VkResult ( *PFN_vkUpdateVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); -typedef void ( *PFN_vkDestroyVideoSessionParametersKHR)(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkCmdBeginVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo); -typedef void ( *PFN_vkCmdEndVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo); -typedef void ( *PFN_vkCmdControlVideoCodingKHR)(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo); -# 8332 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkVideoDecodeCapabilityFlagBitsKHR { - VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR = 0x00000001, - VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR = 0x00000002, - VK_VIDEO_DECODE_CAPABILITY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoDecodeCapabilityFlagBitsKHR; -typedef VkFlags VkVideoDecodeCapabilityFlagsKHR; - -typedef enum VkVideoDecodeUsageFlagBitsKHR { - VK_VIDEO_DECODE_USAGE_DEFAULT_KHR = 0, - VK_VIDEO_DECODE_USAGE_TRANSCODING_BIT_KHR = 0x00000001, - VK_VIDEO_DECODE_USAGE_OFFLINE_BIT_KHR = 0x00000002, - VK_VIDEO_DECODE_USAGE_STREAMING_BIT_KHR = 0x00000004, - VK_VIDEO_DECODE_USAGE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoDecodeUsageFlagBitsKHR; -typedef VkFlags VkVideoDecodeUsageFlagsKHR; -typedef VkFlags VkVideoDecodeFlagsKHR; -typedef struct VkVideoDecodeCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkVideoDecodeCapabilityFlagsKHR flags; -} VkVideoDecodeCapabilitiesKHR; - -typedef struct VkVideoDecodeUsageInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoDecodeUsageFlagsKHR videoUsageHints; -} VkVideoDecodeUsageInfoKHR; - -typedef struct VkVideoDecodeInfoKHR { - VkStructureType sType; - const void* pNext; - VkVideoDecodeFlagsKHR flags; - VkBuffer srcBuffer; - VkDeviceSize srcBufferOffset; - VkDeviceSize srcBufferRange; - VkVideoPictureResourceInfoKHR dstPictureResource; - const VkVideoReferenceSlotInfoKHR* pSetupReferenceSlot; - uint32_t referenceSlotCount; - const VkVideoReferenceSlotInfoKHR* pReferenceSlots; -} VkVideoDecodeInfoKHR; - -typedef void ( *PFN_vkCmdDecodeVideoKHR)(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo); -# 8384 "/usr/include/vulkan/vulkan_core.h" 3 4 -# 1 "/usr/include/vk_video/vulkan_video_codec_h264std.h" 1 3 4 -# 17 "/usr/include/vk_video/vulkan_video_codec_h264std.h" 3 4 -extern "C" { - - - - - - -# 1 "/usr/include/vk_video/vulkan_video_codecs_common.h" 1 3 4 -# 17 "/usr/include/vk_video/vulkan_video_codecs_common.h" 3 4 -extern "C" { -# 33 "/usr/include/vk_video/vulkan_video_codecs_common.h" 3 4 -} -# 25 "/usr/include/vk_video/vulkan_video_codec_h264std.h" 2 3 4 -# 34 "/usr/include/vk_video/vulkan_video_codec_h264std.h" 3 4 -typedef enum StdVideoH264ChromaFormatIdc { - STD_VIDEO_H264_CHROMA_FORMAT_IDC_MONOCHROME = 0, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_420 = 1, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_422 = 2, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_444 = 3, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264ChromaFormatIdc; - -typedef enum StdVideoH264ProfileIdc { - STD_VIDEO_H264_PROFILE_IDC_BASELINE = 66, - STD_VIDEO_H264_PROFILE_IDC_MAIN = 77, - STD_VIDEO_H264_PROFILE_IDC_HIGH = 100, - STD_VIDEO_H264_PROFILE_IDC_HIGH_444_PREDICTIVE = 244, - STD_VIDEO_H264_PROFILE_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264ProfileIdc; - -typedef enum StdVideoH264LevelIdc { - STD_VIDEO_H264_LEVEL_IDC_1_0 = 0, - STD_VIDEO_H264_LEVEL_IDC_1_1 = 1, - STD_VIDEO_H264_LEVEL_IDC_1_2 = 2, - STD_VIDEO_H264_LEVEL_IDC_1_3 = 3, - STD_VIDEO_H264_LEVEL_IDC_2_0 = 4, - STD_VIDEO_H264_LEVEL_IDC_2_1 = 5, - STD_VIDEO_H264_LEVEL_IDC_2_2 = 6, - STD_VIDEO_H264_LEVEL_IDC_3_0 = 7, - STD_VIDEO_H264_LEVEL_IDC_3_1 = 8, - STD_VIDEO_H264_LEVEL_IDC_3_2 = 9, - STD_VIDEO_H264_LEVEL_IDC_4_0 = 10, - STD_VIDEO_H264_LEVEL_IDC_4_1 = 11, - STD_VIDEO_H264_LEVEL_IDC_4_2 = 12, - STD_VIDEO_H264_LEVEL_IDC_5_0 = 13, - STD_VIDEO_H264_LEVEL_IDC_5_1 = 14, - STD_VIDEO_H264_LEVEL_IDC_5_2 = 15, - STD_VIDEO_H264_LEVEL_IDC_6_0 = 16, - STD_VIDEO_H264_LEVEL_IDC_6_1 = 17, - STD_VIDEO_H264_LEVEL_IDC_6_2 = 18, - STD_VIDEO_H264_LEVEL_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264LevelIdc; - -typedef enum StdVideoH264PocType { - STD_VIDEO_H264_POC_TYPE_0 = 0, - STD_VIDEO_H264_POC_TYPE_1 = 1, - STD_VIDEO_H264_POC_TYPE_2 = 2, - STD_VIDEO_H264_POC_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_POC_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264PocType; - -typedef enum StdVideoH264AspectRatioIdc { - STD_VIDEO_H264_ASPECT_RATIO_IDC_UNSPECIFIED = 0, - STD_VIDEO_H264_ASPECT_RATIO_IDC_SQUARE = 1, - STD_VIDEO_H264_ASPECT_RATIO_IDC_12_11 = 2, - STD_VIDEO_H264_ASPECT_RATIO_IDC_10_11 = 3, - STD_VIDEO_H264_ASPECT_RATIO_IDC_16_11 = 4, - STD_VIDEO_H264_ASPECT_RATIO_IDC_40_33 = 5, - STD_VIDEO_H264_ASPECT_RATIO_IDC_24_11 = 6, - STD_VIDEO_H264_ASPECT_RATIO_IDC_20_11 = 7, - STD_VIDEO_H264_ASPECT_RATIO_IDC_32_11 = 8, - STD_VIDEO_H264_ASPECT_RATIO_IDC_80_33 = 9, - STD_VIDEO_H264_ASPECT_RATIO_IDC_18_11 = 10, - STD_VIDEO_H264_ASPECT_RATIO_IDC_15_11 = 11, - STD_VIDEO_H264_ASPECT_RATIO_IDC_64_33 = 12, - STD_VIDEO_H264_ASPECT_RATIO_IDC_160_99 = 13, - STD_VIDEO_H264_ASPECT_RATIO_IDC_4_3 = 14, - STD_VIDEO_H264_ASPECT_RATIO_IDC_3_2 = 15, - STD_VIDEO_H264_ASPECT_RATIO_IDC_2_1 = 16, - STD_VIDEO_H264_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, - STD_VIDEO_H264_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264AspectRatioIdc; - -typedef enum StdVideoH264WeightedBipredIdc { - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_DEFAULT = 0, - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_EXPLICIT = 1, - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_IMPLICIT = 2, - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_WEIGHTED_BIPRED_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264WeightedBipredIdc; - -typedef enum StdVideoH264ModificationOfPicNumsIdc { - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_SUBTRACT = 0, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_SHORT_TERM_ADD = 1, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_LONG_TERM = 2, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_END = 3, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_MODIFICATION_OF_PIC_NUMS_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264ModificationOfPicNumsIdc; - -typedef enum StdVideoH264MemMgmtControlOp { - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_END = 0, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_SHORT_TERM = 1, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_LONG_TERM = 2, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_LONG_TERM = 3, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_SET_MAX_LONG_TERM_INDEX = 4, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_UNMARK_ALL = 5, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MARK_CURRENT_AS_LONG_TERM = 6, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_MEM_MGMT_CONTROL_OP_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264MemMgmtControlOp; - -typedef enum StdVideoH264CabacInitIdc { - STD_VIDEO_H264_CABAC_INIT_IDC_0 = 0, - STD_VIDEO_H264_CABAC_INIT_IDC_1 = 1, - STD_VIDEO_H264_CABAC_INIT_IDC_2 = 2, - STD_VIDEO_H264_CABAC_INIT_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_CABAC_INIT_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264CabacInitIdc; - -typedef enum StdVideoH264DisableDeblockingFilterIdc { - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_DISABLED = 0, - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_ENABLED = 1, - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_PARTIAL = 2, - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_DISABLE_DEBLOCKING_FILTER_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264DisableDeblockingFilterIdc; - -typedef enum StdVideoH264SliceType { - STD_VIDEO_H264_SLICE_TYPE_P = 0, - STD_VIDEO_H264_SLICE_TYPE_B = 1, - STD_VIDEO_H264_SLICE_TYPE_I = 2, - STD_VIDEO_H264_SLICE_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264SliceType; - -typedef enum StdVideoH264PictureType { - STD_VIDEO_H264_PICTURE_TYPE_P = 0, - STD_VIDEO_H264_PICTURE_TYPE_B = 1, - STD_VIDEO_H264_PICTURE_TYPE_I = 2, - STD_VIDEO_H264_PICTURE_TYPE_IDR = 5, - STD_VIDEO_H264_PICTURE_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264PictureType; - -typedef enum StdVideoH264NonVclNaluType { - STD_VIDEO_H264_NON_VCL_NALU_TYPE_SPS = 0, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_PPS = 1, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_AUD = 2, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_PREFIX = 3, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_SEQUENCE = 4, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_END_OF_STREAM = 5, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_PRECODED = 6, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H264_NON_VCL_NALU_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH264NonVclNaluType; -typedef struct StdVideoH264SpsVuiFlags { - uint32_t aspect_ratio_info_present_flag : 1; - uint32_t overscan_info_present_flag : 1; - uint32_t overscan_appropriate_flag : 1; - uint32_t video_signal_type_present_flag : 1; - uint32_t video_full_range_flag : 1; - uint32_t color_description_present_flag : 1; - uint32_t chroma_loc_info_present_flag : 1; - uint32_t timing_info_present_flag : 1; - uint32_t fixed_frame_rate_flag : 1; - uint32_t bitstream_restriction_flag : 1; - uint32_t nal_hrd_parameters_present_flag : 1; - uint32_t vcl_hrd_parameters_present_flag : 1; -} StdVideoH264SpsVuiFlags; - -typedef struct StdVideoH264HrdParameters { - uint8_t cpb_cnt_minus1; - uint8_t bit_rate_scale; - uint8_t cpb_size_scale; - uint8_t reserved1; - uint32_t bit_rate_value_minus1[32]; - uint32_t cpb_size_value_minus1[32]; - uint8_t cbr_flag[32]; - uint32_t initial_cpb_removal_delay_length_minus1; - uint32_t cpb_removal_delay_length_minus1; - uint32_t dpb_output_delay_length_minus1; - uint32_t time_offset_length; -} StdVideoH264HrdParameters; - -typedef struct StdVideoH264SequenceParameterSetVui { - StdVideoH264SpsVuiFlags flags; - StdVideoH264AspectRatioIdc aspect_ratio_idc; - uint16_t sar_width; - uint16_t sar_height; - uint8_t video_format; - uint8_t colour_primaries; - uint8_t transfer_characteristics; - uint8_t matrix_coefficients; - uint32_t num_units_in_tick; - uint32_t time_scale; - uint8_t max_num_reorder_frames; - uint8_t max_dec_frame_buffering; - uint8_t chroma_sample_loc_type_top_field; - uint8_t chroma_sample_loc_type_bottom_field; - uint32_t reserved1; - const StdVideoH264HrdParameters* pHrdParameters; -} StdVideoH264SequenceParameterSetVui; - -typedef struct StdVideoH264SpsFlags { - uint32_t constraint_set0_flag : 1; - uint32_t constraint_set1_flag : 1; - uint32_t constraint_set2_flag : 1; - uint32_t constraint_set3_flag : 1; - uint32_t constraint_set4_flag : 1; - uint32_t constraint_set5_flag : 1; - uint32_t direct_8x8_inference_flag : 1; - uint32_t mb_adaptive_frame_field_flag : 1; - uint32_t frame_mbs_only_flag : 1; - uint32_t delta_pic_order_always_zero_flag : 1; - uint32_t separate_colour_plane_flag : 1; - uint32_t gaps_in_frame_num_value_allowed_flag : 1; - uint32_t qpprime_y_zero_transform_bypass_flag : 1; - uint32_t frame_cropping_flag : 1; - uint32_t seq_scaling_matrix_present_flag : 1; - uint32_t vui_parameters_present_flag : 1; -} StdVideoH264SpsFlags; - -typedef struct StdVideoH264ScalingLists { - uint16_t scaling_list_present_mask; - uint16_t use_default_scaling_matrix_mask; - uint8_t ScalingList4x4[6][16]; - uint8_t ScalingList8x8[6][64]; -} StdVideoH264ScalingLists; - -typedef struct StdVideoH264SequenceParameterSet { - StdVideoH264SpsFlags flags; - StdVideoH264ProfileIdc profile_idc; - StdVideoH264LevelIdc level_idc; - StdVideoH264ChromaFormatIdc chroma_format_idc; - uint8_t seq_parameter_set_id; - uint8_t bit_depth_luma_minus8; - uint8_t bit_depth_chroma_minus8; - uint8_t log2_max_frame_num_minus4; - StdVideoH264PocType pic_order_cnt_type; - int32_t offset_for_non_ref_pic; - int32_t offset_for_top_to_bottom_field; - uint8_t log2_max_pic_order_cnt_lsb_minus4; - uint8_t num_ref_frames_in_pic_order_cnt_cycle; - uint8_t max_num_ref_frames; - uint8_t reserved1; - uint32_t pic_width_in_mbs_minus1; - uint32_t pic_height_in_map_units_minus1; - uint32_t frame_crop_left_offset; - uint32_t frame_crop_right_offset; - uint32_t frame_crop_top_offset; - uint32_t frame_crop_bottom_offset; - uint32_t reserved2; - const int32_t* pOffsetForRefFrame; - const StdVideoH264ScalingLists* pScalingLists; - const StdVideoH264SequenceParameterSetVui* pSequenceParameterSetVui; -} StdVideoH264SequenceParameterSet; - -typedef struct StdVideoH264PpsFlags { - uint32_t transform_8x8_mode_flag : 1; - uint32_t redundant_pic_cnt_present_flag : 1; - uint32_t constrained_intra_pred_flag : 1; - uint32_t deblocking_filter_control_present_flag : 1; - uint32_t weighted_pred_flag : 1; - uint32_t bottom_field_pic_order_in_frame_present_flag : 1; - uint32_t entropy_coding_mode_flag : 1; - uint32_t pic_scaling_matrix_present_flag : 1; -} StdVideoH264PpsFlags; - -typedef struct StdVideoH264PictureParameterSet { - StdVideoH264PpsFlags flags; - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint8_t num_ref_idx_l0_default_active_minus1; - uint8_t num_ref_idx_l1_default_active_minus1; - StdVideoH264WeightedBipredIdc weighted_bipred_idc; - int8_t pic_init_qp_minus26; - int8_t pic_init_qs_minus26; - int8_t chroma_qp_index_offset; - int8_t second_chroma_qp_index_offset; - const StdVideoH264ScalingLists* pScalingLists; -} StdVideoH264PictureParameterSet; - - - -} -# 8385 "/usr/include/vulkan/vulkan_core.h" 2 3 4 -# 1 "/usr/include/vk_video/vulkan_video_codec_h264std_decode.h" 1 3 4 -# 17 "/usr/include/vk_video/vulkan_video_codec_h264std_decode.h" 3 4 -extern "C" { -# 32 "/usr/include/vk_video/vulkan_video_codec_h264std_decode.h" 3 4 -typedef enum StdVideoDecodeH264FieldOrderCount { - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_TOP = 0, - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_BOTTOM = 1, - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_INVALID = 0x7FFFFFFF, - STD_VIDEO_DECODE_H264_FIELD_ORDER_COUNT_MAX_ENUM = 0x7FFFFFFF -} StdVideoDecodeH264FieldOrderCount; -typedef struct StdVideoDecodeH264PictureInfoFlags { - uint32_t field_pic_flag : 1; - uint32_t is_intra : 1; - uint32_t IdrPicFlag : 1; - uint32_t bottom_field_flag : 1; - uint32_t is_reference : 1; - uint32_t complementary_field_pair : 1; -} StdVideoDecodeH264PictureInfoFlags; - -typedef struct StdVideoDecodeH264PictureInfo { - StdVideoDecodeH264PictureInfoFlags flags; - uint8_t seq_parameter_set_id; - uint8_t pic_parameter_set_id; - uint8_t reserved1; - uint8_t reserved2; - uint16_t frame_num; - uint16_t idr_pic_id; - int32_t PicOrderCnt[2]; -} StdVideoDecodeH264PictureInfo; - -typedef struct StdVideoDecodeH264ReferenceInfoFlags { - uint32_t top_field_flag : 1; - uint32_t bottom_field_flag : 1; - uint32_t used_for_long_term_reference : 1; - uint32_t is_non_existing : 1; -} StdVideoDecodeH264ReferenceInfoFlags; - -typedef struct StdVideoDecodeH264ReferenceInfo { - StdVideoDecodeH264ReferenceInfoFlags flags; - uint16_t FrameNum; - uint16_t reserved; - int32_t PicOrderCnt[2]; -} StdVideoDecodeH264ReferenceInfo; - - - -} -# 8386 "/usr/include/vulkan/vulkan_core.h" 2 3 4 - - - -typedef enum VkVideoDecodeH264PictureLayoutFlagBitsKHR { - VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_PROGRESSIVE_KHR = 0, - VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_INTERLEAVED_LINES_BIT_KHR = 0x00000001, - VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_INTERLACED_SEPARATE_PLANES_BIT_KHR = 0x00000002, - VK_VIDEO_DECODE_H264_PICTURE_LAYOUT_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkVideoDecodeH264PictureLayoutFlagBitsKHR; -typedef VkFlags VkVideoDecodeH264PictureLayoutFlagsKHR; -typedef struct VkVideoDecodeH264ProfileInfoKHR { - VkStructureType sType; - const void* pNext; - StdVideoH264ProfileIdc stdProfileIdc; - VkVideoDecodeH264PictureLayoutFlagBitsKHR pictureLayout; -} VkVideoDecodeH264ProfileInfoKHR; - -typedef struct VkVideoDecodeH264CapabilitiesKHR { - VkStructureType sType; - void* pNext; - StdVideoH264LevelIdc maxLevelIdc; - VkOffset2D fieldOffsetGranularity; -} VkVideoDecodeH264CapabilitiesKHR; - -typedef struct VkVideoDecodeH264SessionParametersAddInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t stdSPSCount; - const StdVideoH264SequenceParameterSet* pStdSPSs; - uint32_t stdPPSCount; - const StdVideoH264PictureParameterSet* pStdPPSs; -} VkVideoDecodeH264SessionParametersAddInfoKHR; - -typedef struct VkVideoDecodeH264SessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - const VkVideoDecodeH264SessionParametersAddInfoKHR* pParametersAddInfo; -} VkVideoDecodeH264SessionParametersCreateInfoKHR; - -typedef struct VkVideoDecodeH264PictureInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeH264PictureInfo* pStdPictureInfo; - uint32_t sliceCount; - const uint32_t* pSliceOffsets; -} VkVideoDecodeH264PictureInfoKHR; - -typedef struct VkVideoDecodeH264DpbSlotInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeH264ReferenceInfo* pStdReferenceInfo; -} VkVideoDecodeH264DpbSlotInfoKHR; - - - - - - - -typedef VkRenderingFlags VkRenderingFlagsKHR; - -typedef VkRenderingFlagBits VkRenderingFlagBitsKHR; - -typedef VkRenderingInfo VkRenderingInfoKHR; - -typedef VkRenderingAttachmentInfo VkRenderingAttachmentInfoKHR; - -typedef VkPipelineRenderingCreateInfo VkPipelineRenderingCreateInfoKHR; - -typedef VkPhysicalDeviceDynamicRenderingFeatures VkPhysicalDeviceDynamicRenderingFeaturesKHR; - -typedef VkCommandBufferInheritanceRenderingInfo VkCommandBufferInheritanceRenderingInfoKHR; - -typedef struct VkRenderingFragmentShadingRateAttachmentInfoKHR { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkImageLayout imageLayout; - VkExtent2D shadingRateAttachmentTexelSize; -} VkRenderingFragmentShadingRateAttachmentInfoKHR; - -typedef struct VkRenderingFragmentDensityMapAttachmentInfoEXT { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkImageLayout imageLayout; -} VkRenderingFragmentDensityMapAttachmentInfoEXT; - -typedef struct VkAttachmentSampleCountInfoAMD { - VkStructureType sType; - const void* pNext; - uint32_t colorAttachmentCount; - const VkSampleCountFlagBits* pColorAttachmentSamples; - VkSampleCountFlagBits depthStencilAttachmentSamples; -} VkAttachmentSampleCountInfoAMD; - -typedef VkAttachmentSampleCountInfoAMD VkAttachmentSampleCountInfoNV; - -typedef struct VkMultiviewPerViewAttributesInfoNVX { - VkStructureType sType; - const void* pNext; - VkBool32 perViewAttributes; - VkBool32 perViewAttributesPositionXOnly; -} VkMultiviewPerViewAttributesInfoNVX; - -typedef void ( *PFN_vkCmdBeginRenderingKHR)(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo); -typedef void ( *PFN_vkCmdEndRenderingKHR)(VkCommandBuffer commandBuffer); -# 8510 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR; - -typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR; - -typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR; - - - - - - - -typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR; - -typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR; - -typedef VkFormatProperties2 VkFormatProperties2KHR; - -typedef VkImageFormatProperties2 VkImageFormatProperties2KHR; - -typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR; - -typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR; - -typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR; - -typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR; - -typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR; - -typedef void ( *PFN_vkGetPhysicalDeviceFeatures2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures); -typedef void ( *PFN_vkGetPhysicalDeviceProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties); -typedef void ( *PFN_vkGetPhysicalDeviceFormatProperties2KHR)(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties); -typedef VkResult ( *PFN_vkGetPhysicalDeviceImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties); -typedef void ( *PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties); -typedef void ( *PFN_vkGetPhysicalDeviceMemoryProperties2KHR)(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties); -typedef void ( *PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2* pProperties); -# 8588 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR; - -typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR; - -typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR; - -typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR; - -typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR; - -typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR; - -typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR; - -typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR; - -typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR; - -typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR; - -typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR; - -typedef void ( *PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR)(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); -typedef void ( *PFN_vkCmdSetDeviceMaskKHR)(VkCommandBuffer commandBuffer, uint32_t deviceMask); -typedef void ( *PFN_vkCmdDispatchBaseKHR)(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -# 8649 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR; - -typedef void ( *PFN_vkTrimCommandPoolKHR)(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags); -# 8666 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR; - -typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR; - -typedef VkResult ( *PFN_vkEnumeratePhysicalDeviceGroupsKHR)(VkInstance instance, uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); -# 8685 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR; - -typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR; - -typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR; - -typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR; - -typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR; - -typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR; - -typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR; - -typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR; - -typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR; - -typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR; - -typedef void ( *PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties); -# 8720 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR; - -typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR; - -typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR; - - - - - - - -typedef struct VkImportMemoryFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - int fd; -} VkImportMemoryFdInfoKHR; - -typedef struct VkMemoryFdPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryFdPropertiesKHR; - -typedef struct VkMemoryGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetFdInfoKHR; - -typedef VkResult ( *PFN_vkGetMemoryFdKHR)(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd); -typedef VkResult ( *PFN_vkGetMemoryFdPropertiesKHR)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties); -# 8773 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR; - -typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR; - -typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR; - -typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR; - -typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR; - -typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR; - -typedef void ( *PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties); -# 8799 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR; - -typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR; - -typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR; - - - - - - - -typedef struct VkImportSemaphoreFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkSemaphoreImportFlags flags; - VkExternalSemaphoreHandleTypeFlagBits handleType; - int fd; -} VkImportSemaphoreFdInfoKHR; - -typedef struct VkSemaphoreGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkSemaphore semaphore; - VkExternalSemaphoreHandleTypeFlagBits handleType; -} VkSemaphoreGetFdInfoKHR; - -typedef VkResult ( *PFN_vkImportSemaphoreFdKHR)(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); -typedef VkResult ( *PFN_vkGetSemaphoreFdKHR)(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd); -# 8846 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDevicePushDescriptorPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t maxPushDescriptors; -} VkPhysicalDevicePushDescriptorPropertiesKHR; - -typedef void ( *PFN_vkCmdPushDescriptorSetKHR)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites); -typedef void ( *PFN_vkCmdPushDescriptorSetWithTemplateKHR)(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData); -# 8877 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceShaderFloat16Int8FeaturesKHR; - -typedef VkPhysicalDeviceShaderFloat16Int8Features VkPhysicalDeviceFloat16Int8FeaturesKHR; - - - - - - - -typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR; - - - - - - - -typedef struct VkRectLayerKHR { - VkOffset2D offset; - VkExtent2D extent; - uint32_t layer; -} VkRectLayerKHR; - -typedef struct VkPresentRegionKHR { - uint32_t rectangleCount; - const VkRectLayerKHR* pRectangles; -} VkPresentRegionKHR; - -typedef struct VkPresentRegionsKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentRegionKHR* pRegions; -} VkPresentRegionsKHR; - - - - - -typedef VkDescriptorUpdateTemplate VkDescriptorUpdateTemplateKHR; - - - -typedef VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR; - -typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR; - -typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR; - -typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR; - -typedef VkResult ( *PFN_vkCreateDescriptorUpdateTemplateKHR)(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); -typedef void ( *PFN_vkDestroyDescriptorUpdateTemplateKHR)(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkUpdateDescriptorSetWithTemplateKHR)(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData); -# 8957 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceImagelessFramebufferFeatures VkPhysicalDeviceImagelessFramebufferFeaturesKHR; - -typedef VkFramebufferAttachmentsCreateInfo VkFramebufferAttachmentsCreateInfoKHR; - -typedef VkFramebufferAttachmentImageInfo VkFramebufferAttachmentImageInfoKHR; - -typedef VkRenderPassAttachmentBeginInfo VkRenderPassAttachmentBeginInfoKHR; - - - - - - - -typedef VkRenderPassCreateInfo2 VkRenderPassCreateInfo2KHR; - -typedef VkAttachmentDescription2 VkAttachmentDescription2KHR; - -typedef VkAttachmentReference2 VkAttachmentReference2KHR; - -typedef VkSubpassDescription2 VkSubpassDescription2KHR; - -typedef VkSubpassDependency2 VkSubpassDependency2KHR; - -typedef VkSubpassBeginInfo VkSubpassBeginInfoKHR; - -typedef VkSubpassEndInfo VkSubpassEndInfoKHR; - -typedef VkResult ( *PFN_vkCreateRenderPass2KHR)(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); -typedef void ( *PFN_vkCmdBeginRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo); -typedef void ( *PFN_vkCmdNextSubpass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo); -typedef void ( *PFN_vkCmdEndRenderPass2KHR)(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo); -# 9017 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkSharedPresentSurfaceCapabilitiesKHR { - VkStructureType sType; - void* pNext; - VkImageUsageFlags sharedPresentSupportedUsageFlags; -} VkSharedPresentSurfaceCapabilitiesKHR; - -typedef VkResult ( *PFN_vkGetSwapchainStatusKHR)(VkDevice device, VkSwapchainKHR swapchain); -# 9036 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR; - -typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR; - -typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR; - -typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR; - -typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR; - -typedef VkExternalFenceProperties VkExternalFencePropertiesKHR; - -typedef void ( *PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties); -# 9062 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkFenceImportFlags VkFenceImportFlagsKHR; - -typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR; - -typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR; - - - - - - - -typedef struct VkImportFenceFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkFenceImportFlags flags; - VkExternalFenceHandleTypeFlagBits handleType; - int fd; -} VkImportFenceFdInfoKHR; - -typedef struct VkFenceGetFdInfoKHR { - VkStructureType sType; - const void* pNext; - VkFence fence; - VkExternalFenceHandleTypeFlagBits handleType; -} VkFenceGetFdInfoKHR; - -typedef VkResult ( *PFN_vkImportFenceFdKHR)(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo); -typedef VkResult ( *PFN_vkGetFenceFdKHR)(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd); -# 9110 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkPerformanceCounterUnitKHR { - VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR = 0, - VK_PERFORMANCE_COUNTER_UNIT_PERCENTAGE_KHR = 1, - VK_PERFORMANCE_COUNTER_UNIT_NANOSECONDS_KHR = 2, - VK_PERFORMANCE_COUNTER_UNIT_BYTES_KHR = 3, - VK_PERFORMANCE_COUNTER_UNIT_BYTES_PER_SECOND_KHR = 4, - VK_PERFORMANCE_COUNTER_UNIT_KELVIN_KHR = 5, - VK_PERFORMANCE_COUNTER_UNIT_WATTS_KHR = 6, - VK_PERFORMANCE_COUNTER_UNIT_VOLTS_KHR = 7, - VK_PERFORMANCE_COUNTER_UNIT_AMPS_KHR = 8, - VK_PERFORMANCE_COUNTER_UNIT_HERTZ_KHR = 9, - VK_PERFORMANCE_COUNTER_UNIT_CYCLES_KHR = 10, - VK_PERFORMANCE_COUNTER_UNIT_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterUnitKHR; - -typedef enum VkPerformanceCounterScopeKHR { - VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR = 0, - VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR = 1, - VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR = 2, - VK_QUERY_SCOPE_COMMAND_BUFFER_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_BUFFER_KHR, - VK_QUERY_SCOPE_RENDER_PASS_KHR = VK_PERFORMANCE_COUNTER_SCOPE_RENDER_PASS_KHR, - VK_QUERY_SCOPE_COMMAND_KHR = VK_PERFORMANCE_COUNTER_SCOPE_COMMAND_KHR, - VK_PERFORMANCE_COUNTER_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterScopeKHR; - -typedef enum VkPerformanceCounterStorageKHR { - VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR = 0, - VK_PERFORMANCE_COUNTER_STORAGE_INT64_KHR = 1, - VK_PERFORMANCE_COUNTER_STORAGE_UINT32_KHR = 2, - VK_PERFORMANCE_COUNTER_STORAGE_UINT64_KHR = 3, - VK_PERFORMANCE_COUNTER_STORAGE_FLOAT32_KHR = 4, - VK_PERFORMANCE_COUNTER_STORAGE_FLOAT64_KHR = 5, - VK_PERFORMANCE_COUNTER_STORAGE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterStorageKHR; - -typedef enum VkPerformanceCounterDescriptionFlagBitsKHR { - VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR = 0x00000001, - VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR = 0x00000002, - VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_PERFORMANCE_IMPACTING_BIT_KHR, - VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_KHR = VK_PERFORMANCE_COUNTER_DESCRIPTION_CONCURRENTLY_IMPACTED_BIT_KHR, - VK_PERFORMANCE_COUNTER_DESCRIPTION_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPerformanceCounterDescriptionFlagBitsKHR; -typedef VkFlags VkPerformanceCounterDescriptionFlagsKHR; - -typedef enum VkAcquireProfilingLockFlagBitsKHR { - VK_ACQUIRE_PROFILING_LOCK_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAcquireProfilingLockFlagBitsKHR; -typedef VkFlags VkAcquireProfilingLockFlagsKHR; -typedef struct VkPhysicalDevicePerformanceQueryFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 performanceCounterQueryPools; - VkBool32 performanceCounterMultipleQueryPools; -} VkPhysicalDevicePerformanceQueryFeaturesKHR; - -typedef struct VkPhysicalDevicePerformanceQueryPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 allowCommandBufferQueryCopies; -} VkPhysicalDevicePerformanceQueryPropertiesKHR; - -typedef struct VkPerformanceCounterKHR { - VkStructureType sType; - void* pNext; - VkPerformanceCounterUnitKHR unit; - VkPerformanceCounterScopeKHR scope; - VkPerformanceCounterStorageKHR storage; - uint8_t uuid[16U]; -} VkPerformanceCounterKHR; - -typedef struct VkPerformanceCounterDescriptionKHR { - VkStructureType sType; - void* pNext; - VkPerformanceCounterDescriptionFlagsKHR flags; - char name[256U]; - char category[256U]; - char description[256U]; -} VkPerformanceCounterDescriptionKHR; - -typedef struct VkQueryPoolPerformanceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t queueFamilyIndex; - uint32_t counterIndexCount; - const uint32_t* pCounterIndices; -} VkQueryPoolPerformanceCreateInfoKHR; - -typedef union VkPerformanceCounterResultKHR { - int32_t int32; - int64_t int64; - uint32_t uint32; - uint64_t uint64; - float float32; - double float64; -} VkPerformanceCounterResultKHR; - -typedef struct VkAcquireProfilingLockInfoKHR { - VkStructureType sType; - const void* pNext; - VkAcquireProfilingLockFlagsKHR flags; - uint64_t timeout; -} VkAcquireProfilingLockInfoKHR; - -typedef struct VkPerformanceQuerySubmitInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t counterPassIndex; -} VkPerformanceQuerySubmitInfoKHR; - -typedef VkResult ( *PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR)(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions); -typedef void ( *PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR)(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses); -typedef VkResult ( *PFN_vkAcquireProfilingLockKHR)(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo); -typedef void ( *PFN_vkReleaseProfilingLockKHR)(VkDevice device); -# 9252 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPointClippingBehavior VkPointClippingBehaviorKHR; - -typedef VkTessellationDomainOrigin VkTessellationDomainOriginKHR; - -typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR; - -typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR; - -typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR; - -typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR; - -typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR; - - - - - - - -typedef struct VkPhysicalDeviceSurfaceInfo2KHR { - VkStructureType sType; - const void* pNext; - VkSurfaceKHR surface; -} VkPhysicalDeviceSurfaceInfo2KHR; - -typedef struct VkSurfaceCapabilities2KHR { - VkStructureType sType; - void* pNext; - VkSurfaceCapabilitiesKHR surfaceCapabilities; -} VkSurfaceCapabilities2KHR; - -typedef struct VkSurfaceFormat2KHR { - VkStructureType sType; - void* pNext; - VkSurfaceFormatKHR surfaceFormat; -} VkSurfaceFormat2KHR; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities); -typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceFormats2KHR)(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats); -# 9311 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointerFeaturesKHR; - -typedef VkPhysicalDeviceVariablePointersFeatures VkPhysicalDeviceVariablePointersFeaturesKHR; - - - - - - - -typedef struct VkDisplayProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPropertiesKHR displayProperties; -} VkDisplayProperties2KHR; - -typedef struct VkDisplayPlaneProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPlanePropertiesKHR displayPlaneProperties; -} VkDisplayPlaneProperties2KHR; - -typedef struct VkDisplayModeProperties2KHR { - VkStructureType sType; - void* pNext; - VkDisplayModePropertiesKHR displayModeProperties; -} VkDisplayModeProperties2KHR; - -typedef struct VkDisplayPlaneInfo2KHR { - VkStructureType sType; - const void* pNext; - VkDisplayModeKHR mode; - uint32_t planeIndex; -} VkDisplayPlaneInfo2KHR; - -typedef struct VkDisplayPlaneCapabilities2KHR { - VkStructureType sType; - void* pNext; - VkDisplayPlaneCapabilitiesKHR capabilities; -} VkDisplayPlaneCapabilities2KHR; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceDisplayProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties); -typedef VkResult ( *PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties); -typedef VkResult ( *PFN_vkGetDisplayModeProperties2KHR)(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties); -typedef VkResult ( *PFN_vkGetDisplayPlaneCapabilities2KHR)(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities); -# 9385 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR; - -typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR; -# 9407 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR; - -typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR; - -typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR; - -typedef VkMemoryRequirements2 VkMemoryRequirements2KHR; - -typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR; - -typedef void ( *PFN_vkGetImageMemoryRequirements2KHR)(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkGetBufferMemoryRequirements2KHR)(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkGetImageSparseMemoryRequirements2KHR)(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -# 9444 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkImageFormatListCreateInfo VkImageFormatListCreateInfoKHR; - - - - - -typedef VkSamplerYcbcrConversion VkSamplerYcbcrConversionKHR; - - - -typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR; - -typedef VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR; - -typedef VkChromaLocation VkChromaLocationKHR; - -typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR; - -typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR; - -typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR; - -typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR; - -typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR; - -typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR; - -typedef VkResult ( *PFN_vkCreateSamplerYcbcrConversionKHR)(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion); -typedef void ( *PFN_vkDestroySamplerYcbcrConversionKHR)(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator); -# 9493 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR; - -typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR; - -typedef VkResult ( *PFN_vkBindBufferMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos); -typedef VkResult ( *PFN_vkBindImageMemory2KHR)(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos); -# 9519 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR; - -typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR; - -typedef void ( *PFN_vkGetDescriptorSetLayoutSupportKHR)(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport); -# 9537 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef void ( *PFN_vkCmdDrawIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void ( *PFN_vkCmdDrawIndexedIndirectCountKHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -# 9565 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR; - - - - - - - -typedef VkPhysicalDevice8BitStorageFeatures VkPhysicalDevice8BitStorageFeaturesKHR; - - - - - - - -typedef VkPhysicalDeviceShaderAtomicInt64Features VkPhysicalDeviceShaderAtomicInt64FeaturesKHR; - - - - - - - -typedef struct VkPhysicalDeviceShaderClockFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupClock; - VkBool32 shaderDeviceClock; -} VkPhysicalDeviceShaderClockFeaturesKHR; - - - - - -# 1 "/usr/include/vk_video/vulkan_video_codec_h265std.h" 1 3 4 -# 17 "/usr/include/vk_video/vulkan_video_codec_h265std.h" 3 4 -extern "C" { -# 49 "/usr/include/vk_video/vulkan_video_codec_h265std.h" 3 4 -typedef enum StdVideoH265ChromaFormatIdc { - STD_VIDEO_H265_CHROMA_FORMAT_IDC_MONOCHROME = 0, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_420 = 1, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_422 = 2, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_444 = 3, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_CHROMA_FORMAT_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265ChromaFormatIdc; - -typedef enum StdVideoH265ProfileIdc { - STD_VIDEO_H265_PROFILE_IDC_MAIN = 1, - STD_VIDEO_H265_PROFILE_IDC_MAIN_10 = 2, - STD_VIDEO_H265_PROFILE_IDC_MAIN_STILL_PICTURE = 3, - STD_VIDEO_H265_PROFILE_IDC_FORMAT_RANGE_EXTENSIONS = 4, - STD_VIDEO_H265_PROFILE_IDC_SCC_EXTENSIONS = 9, - STD_VIDEO_H265_PROFILE_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_PROFILE_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265ProfileIdc; - -typedef enum StdVideoH265LevelIdc { - STD_VIDEO_H265_LEVEL_IDC_1_0 = 0, - STD_VIDEO_H265_LEVEL_IDC_2_0 = 1, - STD_VIDEO_H265_LEVEL_IDC_2_1 = 2, - STD_VIDEO_H265_LEVEL_IDC_3_0 = 3, - STD_VIDEO_H265_LEVEL_IDC_3_1 = 4, - STD_VIDEO_H265_LEVEL_IDC_4_0 = 5, - STD_VIDEO_H265_LEVEL_IDC_4_1 = 6, - STD_VIDEO_H265_LEVEL_IDC_5_0 = 7, - STD_VIDEO_H265_LEVEL_IDC_5_1 = 8, - STD_VIDEO_H265_LEVEL_IDC_5_2 = 9, - STD_VIDEO_H265_LEVEL_IDC_6_0 = 10, - STD_VIDEO_H265_LEVEL_IDC_6_1 = 11, - STD_VIDEO_H265_LEVEL_IDC_6_2 = 12, - STD_VIDEO_H265_LEVEL_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_LEVEL_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265LevelIdc; - -typedef enum StdVideoH265SliceType { - STD_VIDEO_H265_SLICE_TYPE_B = 0, - STD_VIDEO_H265_SLICE_TYPE_P = 1, - STD_VIDEO_H265_SLICE_TYPE_I = 2, - STD_VIDEO_H265_SLICE_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_SLICE_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265SliceType; - -typedef enum StdVideoH265PictureType { - STD_VIDEO_H265_PICTURE_TYPE_P = 0, - STD_VIDEO_H265_PICTURE_TYPE_B = 1, - STD_VIDEO_H265_PICTURE_TYPE_I = 2, - STD_VIDEO_H265_PICTURE_TYPE_IDR = 3, - STD_VIDEO_H265_PICTURE_TYPE_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_PICTURE_TYPE_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265PictureType; - -typedef enum StdVideoH265AspectRatioIdc { - STD_VIDEO_H265_ASPECT_RATIO_IDC_UNSPECIFIED = 0, - STD_VIDEO_H265_ASPECT_RATIO_IDC_SQUARE = 1, - STD_VIDEO_H265_ASPECT_RATIO_IDC_12_11 = 2, - STD_VIDEO_H265_ASPECT_RATIO_IDC_10_11 = 3, - STD_VIDEO_H265_ASPECT_RATIO_IDC_16_11 = 4, - STD_VIDEO_H265_ASPECT_RATIO_IDC_40_33 = 5, - STD_VIDEO_H265_ASPECT_RATIO_IDC_24_11 = 6, - STD_VIDEO_H265_ASPECT_RATIO_IDC_20_11 = 7, - STD_VIDEO_H265_ASPECT_RATIO_IDC_32_11 = 8, - STD_VIDEO_H265_ASPECT_RATIO_IDC_80_33 = 9, - STD_VIDEO_H265_ASPECT_RATIO_IDC_18_11 = 10, - STD_VIDEO_H265_ASPECT_RATIO_IDC_15_11 = 11, - STD_VIDEO_H265_ASPECT_RATIO_IDC_64_33 = 12, - STD_VIDEO_H265_ASPECT_RATIO_IDC_160_99 = 13, - STD_VIDEO_H265_ASPECT_RATIO_IDC_4_3 = 14, - STD_VIDEO_H265_ASPECT_RATIO_IDC_3_2 = 15, - STD_VIDEO_H265_ASPECT_RATIO_IDC_2_1 = 16, - STD_VIDEO_H265_ASPECT_RATIO_IDC_EXTENDED_SAR = 255, - STD_VIDEO_H265_ASPECT_RATIO_IDC_INVALID = 0x7FFFFFFF, - STD_VIDEO_H265_ASPECT_RATIO_IDC_MAX_ENUM = 0x7FFFFFFF -} StdVideoH265AspectRatioIdc; -typedef struct StdVideoH265DecPicBufMgr { - uint32_t max_latency_increase_plus1[7]; - uint8_t max_dec_pic_buffering_minus1[7]; - uint8_t max_num_reorder_pics[7]; -} StdVideoH265DecPicBufMgr; - -typedef struct StdVideoH265SubLayerHrdParameters { - uint32_t bit_rate_value_minus1[32]; - uint32_t cpb_size_value_minus1[32]; - uint32_t cpb_size_du_value_minus1[32]; - uint32_t bit_rate_du_value_minus1[32]; - uint32_t cbr_flag; -} StdVideoH265SubLayerHrdParameters; - -typedef struct StdVideoH265HrdFlags { - uint32_t nal_hrd_parameters_present_flag : 1; - uint32_t vcl_hrd_parameters_present_flag : 1; - uint32_t sub_pic_hrd_params_present_flag : 1; - uint32_t sub_pic_cpb_params_in_pic_timing_sei_flag : 1; - uint32_t fixed_pic_rate_general_flag : 8; - uint32_t fixed_pic_rate_within_cvs_flag : 8; - uint32_t low_delay_hrd_flag : 8; -} StdVideoH265HrdFlags; - -typedef struct StdVideoH265HrdParameters { - StdVideoH265HrdFlags flags; - uint8_t tick_divisor_minus2; - uint8_t du_cpb_removal_delay_increment_length_minus1; - uint8_t dpb_output_delay_du_length_minus1; - uint8_t bit_rate_scale; - uint8_t cpb_size_scale; - uint8_t cpb_size_du_scale; - uint8_t initial_cpb_removal_delay_length_minus1; - uint8_t au_cpb_removal_delay_length_minus1; - uint8_t dpb_output_delay_length_minus1; - uint8_t cpb_cnt_minus1[7]; - uint16_t elemental_duration_in_tc_minus1[7]; - uint16_t reserved[3]; - const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersNal; - const StdVideoH265SubLayerHrdParameters* pSubLayerHrdParametersVcl; -} StdVideoH265HrdParameters; - -typedef struct StdVideoH265VpsFlags { - uint32_t vps_temporal_id_nesting_flag : 1; - uint32_t vps_sub_layer_ordering_info_present_flag : 1; - uint32_t vps_timing_info_present_flag : 1; - uint32_t vps_poc_proportional_to_timing_flag : 1; -} StdVideoH265VpsFlags; - -typedef struct StdVideoH265ProfileTierLevelFlags { - uint32_t general_tier_flag : 1; - uint32_t general_progressive_source_flag : 1; - uint32_t general_interlaced_source_flag : 1; - uint32_t general_non_packed_constraint_flag : 1; - uint32_t general_frame_only_constraint_flag : 1; -} StdVideoH265ProfileTierLevelFlags; - -typedef struct StdVideoH265ProfileTierLevel { - StdVideoH265ProfileTierLevelFlags flags; - StdVideoH265ProfileIdc general_profile_idc; - StdVideoH265LevelIdc general_level_idc; -} StdVideoH265ProfileTierLevel; - -typedef struct StdVideoH265VideoParameterSet { - StdVideoH265VpsFlags flags; - uint8_t vps_video_parameter_set_id; - uint8_t vps_max_sub_layers_minus1; - uint8_t reserved1; - uint8_t reserved2; - uint32_t vps_num_units_in_tick; - uint32_t vps_time_scale; - uint32_t vps_num_ticks_poc_diff_one_minus1; - uint32_t reserved3; - const StdVideoH265DecPicBufMgr* pDecPicBufMgr; - const StdVideoH265HrdParameters* pHrdParameters; - const StdVideoH265ProfileTierLevel* pProfileTierLevel; -} StdVideoH265VideoParameterSet; - -typedef struct StdVideoH265ScalingLists { - uint8_t ScalingList4x4[6][16]; - uint8_t ScalingList8x8[6][64]; - uint8_t ScalingList16x16[6][64]; - uint8_t ScalingList32x32[2][64]; - uint8_t ScalingListDCCoef16x16[6]; - uint8_t ScalingListDCCoef32x32[2]; -} StdVideoH265ScalingLists; - -typedef struct StdVideoH265SpsVuiFlags { - uint32_t aspect_ratio_info_present_flag : 1; - uint32_t overscan_info_present_flag : 1; - uint32_t overscan_appropriate_flag : 1; - uint32_t video_signal_type_present_flag : 1; - uint32_t video_full_range_flag : 1; - uint32_t colour_description_present_flag : 1; - uint32_t chroma_loc_info_present_flag : 1; - uint32_t neutral_chroma_indication_flag : 1; - uint32_t field_seq_flag : 1; - uint32_t frame_field_info_present_flag : 1; - uint32_t default_display_window_flag : 1; - uint32_t vui_timing_info_present_flag : 1; - uint32_t vui_poc_proportional_to_timing_flag : 1; - uint32_t vui_hrd_parameters_present_flag : 1; - uint32_t bitstream_restriction_flag : 1; - uint32_t tiles_fixed_structure_flag : 1; - uint32_t motion_vectors_over_pic_boundaries_flag : 1; - uint32_t restricted_ref_pic_lists_flag : 1; -} StdVideoH265SpsVuiFlags; - -typedef struct StdVideoH265SequenceParameterSetVui { - StdVideoH265SpsVuiFlags flags; - StdVideoH265AspectRatioIdc aspect_ratio_idc; - uint16_t sar_width; - uint16_t sar_height; - uint8_t video_format; - uint8_t colour_primaries; - uint8_t transfer_characteristics; - uint8_t matrix_coeffs; - uint8_t chroma_sample_loc_type_top_field; - uint8_t chroma_sample_loc_type_bottom_field; - uint8_t reserved1; - uint8_t reserved2; - uint16_t def_disp_win_left_offset; - uint16_t def_disp_win_right_offset; - uint16_t def_disp_win_top_offset; - uint16_t def_disp_win_bottom_offset; - uint32_t vui_num_units_in_tick; - uint32_t vui_time_scale; - uint32_t vui_num_ticks_poc_diff_one_minus1; - uint16_t min_spatial_segmentation_idc; - uint16_t reserved3; - uint8_t max_bytes_per_pic_denom; - uint8_t max_bits_per_min_cu_denom; - uint8_t log2_max_mv_length_horizontal; - uint8_t log2_max_mv_length_vertical; - const StdVideoH265HrdParameters* pHrdParameters; -} StdVideoH265SequenceParameterSetVui; - -typedef struct StdVideoH265PredictorPaletteEntries { - uint16_t PredictorPaletteEntries[3][128]; -} StdVideoH265PredictorPaletteEntries; - -typedef struct StdVideoH265SpsFlags { - uint32_t sps_temporal_id_nesting_flag : 1; - uint32_t separate_colour_plane_flag : 1; - uint32_t conformance_window_flag : 1; - uint32_t sps_sub_layer_ordering_info_present_flag : 1; - uint32_t scaling_list_enabled_flag : 1; - uint32_t sps_scaling_list_data_present_flag : 1; - uint32_t amp_enabled_flag : 1; - uint32_t sample_adaptive_offset_enabled_flag : 1; - uint32_t pcm_enabled_flag : 1; - uint32_t pcm_loop_filter_disabled_flag : 1; - uint32_t long_term_ref_pics_present_flag : 1; - uint32_t sps_temporal_mvp_enabled_flag : 1; - uint32_t strong_intra_smoothing_enabled_flag : 1; - uint32_t vui_parameters_present_flag : 1; - uint32_t sps_extension_present_flag : 1; - uint32_t sps_range_extension_flag : 1; - uint32_t transform_skip_rotation_enabled_flag : 1; - uint32_t transform_skip_context_enabled_flag : 1; - uint32_t implicit_rdpcm_enabled_flag : 1; - uint32_t explicit_rdpcm_enabled_flag : 1; - uint32_t extended_precision_processing_flag : 1; - uint32_t intra_smoothing_disabled_flag : 1; - uint32_t high_precision_offsets_enabled_flag : 1; - uint32_t persistent_rice_adaptation_enabled_flag : 1; - uint32_t cabac_bypass_alignment_enabled_flag : 1; - uint32_t sps_scc_extension_flag : 1; - uint32_t sps_curr_pic_ref_enabled_flag : 1; - uint32_t palette_mode_enabled_flag : 1; - uint32_t sps_palette_predictor_initializers_present_flag : 1; - uint32_t intra_boundary_filtering_disabled_flag : 1; -} StdVideoH265SpsFlags; - -typedef struct StdVideoH265ShortTermRefPicSetFlags { - uint32_t inter_ref_pic_set_prediction_flag : 1; - uint32_t delta_rps_sign : 1; -} StdVideoH265ShortTermRefPicSetFlags; - -typedef struct StdVideoH265ShortTermRefPicSet { - StdVideoH265ShortTermRefPicSetFlags flags; - uint32_t delta_idx_minus1; - uint16_t use_delta_flag; - uint16_t abs_delta_rps_minus1; - uint16_t used_by_curr_pic_flag; - uint16_t used_by_curr_pic_s0_flag; - uint16_t used_by_curr_pic_s1_flag; - uint16_t reserved1; - uint8_t reserved2; - uint8_t reserved3; - uint8_t num_negative_pics; - uint8_t num_positive_pics; - uint16_t delta_poc_s0_minus1[16]; - uint16_t delta_poc_s1_minus1[16]; -} StdVideoH265ShortTermRefPicSet; - -typedef struct StdVideoH265LongTermRefPicsSps { - uint32_t used_by_curr_pic_lt_sps_flag; - uint32_t lt_ref_pic_poc_lsb_sps[32]; -} StdVideoH265LongTermRefPicsSps; - -typedef struct StdVideoH265SequenceParameterSet { - StdVideoH265SpsFlags flags; - StdVideoH265ChromaFormatIdc chroma_format_idc; - uint32_t pic_width_in_luma_samples; - uint32_t pic_height_in_luma_samples; - uint8_t sps_video_parameter_set_id; - uint8_t sps_max_sub_layers_minus1; - uint8_t sps_seq_parameter_set_id; - uint8_t bit_depth_luma_minus8; - uint8_t bit_depth_chroma_minus8; - uint8_t log2_max_pic_order_cnt_lsb_minus4; - uint8_t log2_min_luma_coding_block_size_minus3; - uint8_t log2_diff_max_min_luma_coding_block_size; - uint8_t log2_min_luma_transform_block_size_minus2; - uint8_t log2_diff_max_min_luma_transform_block_size; - uint8_t max_transform_hierarchy_depth_inter; - uint8_t max_transform_hierarchy_depth_intra; - uint8_t num_short_term_ref_pic_sets; - uint8_t num_long_term_ref_pics_sps; - uint8_t pcm_sample_bit_depth_luma_minus1; - uint8_t pcm_sample_bit_depth_chroma_minus1; - uint8_t log2_min_pcm_luma_coding_block_size_minus3; - uint8_t log2_diff_max_min_pcm_luma_coding_block_size; - uint8_t reserved1; - uint8_t reserved2; - uint8_t palette_max_size; - uint8_t delta_palette_max_predictor_size; - uint8_t motion_vector_resolution_control_idc; - uint8_t sps_num_palette_predictor_initializers_minus1; - uint32_t conf_win_left_offset; - uint32_t conf_win_right_offset; - uint32_t conf_win_top_offset; - uint32_t conf_win_bottom_offset; - const StdVideoH265ProfileTierLevel* pProfileTierLevel; - const StdVideoH265DecPicBufMgr* pDecPicBufMgr; - const StdVideoH265ScalingLists* pScalingLists; - const StdVideoH265ShortTermRefPicSet* pShortTermRefPicSet; - const StdVideoH265LongTermRefPicsSps* pLongTermRefPicsSps; - const StdVideoH265SequenceParameterSetVui* pSequenceParameterSetVui; - const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; -} StdVideoH265SequenceParameterSet; - -typedef struct StdVideoH265PpsFlags { - uint32_t dependent_slice_segments_enabled_flag : 1; - uint32_t output_flag_present_flag : 1; - uint32_t sign_data_hiding_enabled_flag : 1; - uint32_t cabac_init_present_flag : 1; - uint32_t constrained_intra_pred_flag : 1; - uint32_t transform_skip_enabled_flag : 1; - uint32_t cu_qp_delta_enabled_flag : 1; - uint32_t pps_slice_chroma_qp_offsets_present_flag : 1; - uint32_t weighted_pred_flag : 1; - uint32_t weighted_bipred_flag : 1; - uint32_t transquant_bypass_enabled_flag : 1; - uint32_t tiles_enabled_flag : 1; - uint32_t entropy_coding_sync_enabled_flag : 1; - uint32_t uniform_spacing_flag : 1; - uint32_t loop_filter_across_tiles_enabled_flag : 1; - uint32_t pps_loop_filter_across_slices_enabled_flag : 1; - uint32_t deblocking_filter_control_present_flag : 1; - uint32_t deblocking_filter_override_enabled_flag : 1; - uint32_t pps_deblocking_filter_disabled_flag : 1; - uint32_t pps_scaling_list_data_present_flag : 1; - uint32_t lists_modification_present_flag : 1; - uint32_t slice_segment_header_extension_present_flag : 1; - uint32_t pps_extension_present_flag : 1; - uint32_t cross_component_prediction_enabled_flag : 1; - uint32_t chroma_qp_offset_list_enabled_flag : 1; - uint32_t pps_curr_pic_ref_enabled_flag : 1; - uint32_t residual_adaptive_colour_transform_enabled_flag : 1; - uint32_t pps_slice_act_qp_offsets_present_flag : 1; - uint32_t pps_palette_predictor_initializers_present_flag : 1; - uint32_t monochrome_palette_flag : 1; - uint32_t pps_range_extension_flag : 1; -} StdVideoH265PpsFlags; - -typedef struct StdVideoH265PictureParameterSet { - StdVideoH265PpsFlags flags; - uint8_t pps_pic_parameter_set_id; - uint8_t pps_seq_parameter_set_id; - uint8_t sps_video_parameter_set_id; - uint8_t num_extra_slice_header_bits; - uint8_t num_ref_idx_l0_default_active_minus1; - uint8_t num_ref_idx_l1_default_active_minus1; - int8_t init_qp_minus26; - uint8_t diff_cu_qp_delta_depth; - int8_t pps_cb_qp_offset; - int8_t pps_cr_qp_offset; - int8_t pps_beta_offset_div2; - int8_t pps_tc_offset_div2; - uint8_t log2_parallel_merge_level_minus2; - uint8_t log2_max_transform_skip_block_size_minus2; - uint8_t diff_cu_chroma_qp_offset_depth; - uint8_t chroma_qp_offset_list_len_minus1; - int8_t cb_qp_offset_list[6]; - int8_t cr_qp_offset_list[6]; - uint8_t log2_sao_offset_scale_luma; - uint8_t log2_sao_offset_scale_chroma; - int8_t pps_act_y_qp_offset_plus5; - int8_t pps_act_cb_qp_offset_plus5; - int8_t pps_act_cr_qp_offset_plus3; - uint8_t pps_num_palette_predictor_initializers; - uint8_t luma_bit_depth_entry_minus8; - uint8_t chroma_bit_depth_entry_minus8; - uint8_t num_tile_columns_minus1; - uint8_t num_tile_rows_minus1; - uint8_t reserved1; - uint8_t reserved2; - uint16_t column_width_minus1[19]; - uint16_t row_height_minus1[21]; - uint32_t reserved3; - const StdVideoH265ScalingLists* pScalingLists; - const StdVideoH265PredictorPaletteEntries* pPredictorPaletteEntries; -} StdVideoH265PictureParameterSet; - - - -} -# 9601 "/usr/include/vulkan/vulkan_core.h" 2 3 4 -# 1 "/usr/include/vk_video/vulkan_video_codec_h265std_decode.h" 1 3 4 -# 17 "/usr/include/vk_video/vulkan_video_codec_h265std_decode.h" 3 4 -extern "C" { -# 31 "/usr/include/vk_video/vulkan_video_codec_h265std_decode.h" 3 4 -typedef struct StdVideoDecodeH265PictureInfoFlags { - uint32_t IrapPicFlag : 1; - uint32_t IdrPicFlag : 1; - uint32_t IsReference : 1; - uint32_t short_term_ref_pic_set_sps_flag : 1; -} StdVideoDecodeH265PictureInfoFlags; - -typedef struct StdVideoDecodeH265PictureInfo { - StdVideoDecodeH265PictureInfoFlags flags; - uint8_t sps_video_parameter_set_id; - uint8_t pps_seq_parameter_set_id; - uint8_t pps_pic_parameter_set_id; - uint8_t NumDeltaPocsOfRefRpsIdx; - int32_t PicOrderCntVal; - uint16_t NumBitsForSTRefPicSetInSlice; - uint16_t reserved; - uint8_t RefPicSetStCurrBefore[8]; - uint8_t RefPicSetStCurrAfter[8]; - uint8_t RefPicSetLtCurr[8]; -} StdVideoDecodeH265PictureInfo; - -typedef struct StdVideoDecodeH265ReferenceInfoFlags { - uint32_t used_for_long_term_reference : 1; - uint32_t unused_for_reference : 1; -} StdVideoDecodeH265ReferenceInfoFlags; - -typedef struct StdVideoDecodeH265ReferenceInfo { - StdVideoDecodeH265ReferenceInfoFlags flags; - int32_t PicOrderCntVal; -} StdVideoDecodeH265ReferenceInfo; - - - -} -# 9602 "/usr/include/vulkan/vulkan_core.h" 2 3 4 - - -typedef struct VkVideoDecodeH265ProfileInfoKHR { - VkStructureType sType; - const void* pNext; - StdVideoH265ProfileIdc stdProfileIdc; -} VkVideoDecodeH265ProfileInfoKHR; - -typedef struct VkVideoDecodeH265CapabilitiesKHR { - VkStructureType sType; - void* pNext; - StdVideoH265LevelIdc maxLevelIdc; -} VkVideoDecodeH265CapabilitiesKHR; - -typedef struct VkVideoDecodeH265SessionParametersAddInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t stdVPSCount; - const StdVideoH265VideoParameterSet* pStdVPSs; - uint32_t stdSPSCount; - const StdVideoH265SequenceParameterSet* pStdSPSs; - uint32_t stdPPSCount; - const StdVideoH265PictureParameterSet* pStdPPSs; -} VkVideoDecodeH265SessionParametersAddInfoKHR; - -typedef struct VkVideoDecodeH265SessionParametersCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t maxStdVPSCount; - uint32_t maxStdSPSCount; - uint32_t maxStdPPSCount; - const VkVideoDecodeH265SessionParametersAddInfoKHR* pParametersAddInfo; -} VkVideoDecodeH265SessionParametersCreateInfoKHR; - -typedef struct VkVideoDecodeH265PictureInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeH265PictureInfo* pStdPictureInfo; - uint32_t sliceSegmentCount; - const uint32_t* pSliceSegmentOffsets; -} VkVideoDecodeH265PictureInfoKHR; - -typedef struct VkVideoDecodeH265DpbSlotInfoKHR { - VkStructureType sType; - const void* pNext; - const StdVideoDecodeH265ReferenceInfo* pStdReferenceInfo; -} VkVideoDecodeH265DpbSlotInfoKHR; -# 9658 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkQueueGlobalPriorityKHR { - VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR = 128, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR = 256, - VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR = 512, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR = 1024, - VK_QUEUE_GLOBAL_PRIORITY_LOW_EXT = VK_QUEUE_GLOBAL_PRIORITY_LOW_KHR, - VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_EXT = VK_QUEUE_GLOBAL_PRIORITY_MEDIUM_KHR, - VK_QUEUE_GLOBAL_PRIORITY_HIGH_EXT = VK_QUEUE_GLOBAL_PRIORITY_HIGH_KHR, - VK_QUEUE_GLOBAL_PRIORITY_REALTIME_EXT = VK_QUEUE_GLOBAL_PRIORITY_REALTIME_KHR, - VK_QUEUE_GLOBAL_PRIORITY_MAX_ENUM_KHR = 0x7FFFFFFF -} VkQueueGlobalPriorityKHR; -typedef struct VkDeviceQueueGlobalPriorityCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkQueueGlobalPriorityKHR globalPriority; -} VkDeviceQueueGlobalPriorityCreateInfoKHR; - -typedef struct VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 globalPriorityQuery; -} VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR; - -typedef struct VkQueueFamilyGlobalPriorityPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t priorityCount; - VkQueueGlobalPriorityKHR priorities[16U]; -} VkQueueFamilyGlobalPriorityPropertiesKHR; -# 9696 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkDriverId VkDriverIdKHR; - -typedef VkConformanceVersion VkConformanceVersionKHR; - -typedef VkPhysicalDeviceDriverProperties VkPhysicalDeviceDriverPropertiesKHR; - - - - - - - -typedef VkShaderFloatControlsIndependence VkShaderFloatControlsIndependenceKHR; - -typedef VkPhysicalDeviceFloatControlsProperties VkPhysicalDeviceFloatControlsPropertiesKHR; - - - - - - - -typedef VkResolveModeFlagBits VkResolveModeFlagBitsKHR; - -typedef VkResolveModeFlags VkResolveModeFlagsKHR; - -typedef VkSubpassDescriptionDepthStencilResolve VkSubpassDescriptionDepthStencilResolveKHR; - -typedef VkPhysicalDeviceDepthStencilResolveProperties VkPhysicalDeviceDepthStencilResolvePropertiesKHR; -# 9738 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkSemaphoreType VkSemaphoreTypeKHR; - -typedef VkSemaphoreWaitFlagBits VkSemaphoreWaitFlagBitsKHR; - -typedef VkSemaphoreWaitFlags VkSemaphoreWaitFlagsKHR; - -typedef VkPhysicalDeviceTimelineSemaphoreFeatures VkPhysicalDeviceTimelineSemaphoreFeaturesKHR; - -typedef VkPhysicalDeviceTimelineSemaphoreProperties VkPhysicalDeviceTimelineSemaphorePropertiesKHR; - -typedef VkSemaphoreTypeCreateInfo VkSemaphoreTypeCreateInfoKHR; - -typedef VkTimelineSemaphoreSubmitInfo VkTimelineSemaphoreSubmitInfoKHR; - -typedef VkSemaphoreWaitInfo VkSemaphoreWaitInfoKHR; - -typedef VkSemaphoreSignalInfo VkSemaphoreSignalInfoKHR; - -typedef VkResult ( *PFN_vkGetSemaphoreCounterValueKHR)(VkDevice device, VkSemaphore semaphore, uint64_t* pValue); -typedef VkResult ( *PFN_vkWaitSemaphoresKHR)(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout); -typedef VkResult ( *PFN_vkSignalSemaphoreKHR)(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo); -# 9781 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceVulkanMemoryModelFeatures VkPhysicalDeviceVulkanMemoryModelFeaturesKHR; - - - - - - - -typedef VkPhysicalDeviceShaderTerminateInvocationFeatures VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR; -# 9798 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkFragmentShadingRateCombinerOpKHR { - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_KEEP_KHR = 0, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_REPLACE_KHR = 1, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MIN_KHR = 2, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_KHR = 3, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MUL_KHR = 4, - VK_FRAGMENT_SHADING_RATE_COMBINER_OP_MAX_ENUM_KHR = 0x7FFFFFFF -} VkFragmentShadingRateCombinerOpKHR; -typedef struct VkFragmentShadingRateAttachmentInfoKHR { - VkStructureType sType; - const void* pNext; - const VkAttachmentReference2* pFragmentShadingRateAttachment; - VkExtent2D shadingRateAttachmentTexelSize; -} VkFragmentShadingRateAttachmentInfoKHR; - -typedef struct VkPipelineFragmentShadingRateStateCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkExtent2D fragmentSize; - VkFragmentShadingRateCombinerOpKHR combinerOps[2]; -} VkPipelineFragmentShadingRateStateCreateInfoKHR; - -typedef struct VkPhysicalDeviceFragmentShadingRateFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 pipelineFragmentShadingRate; - VkBool32 primitiveFragmentShadingRate; - VkBool32 attachmentFragmentShadingRate; -} VkPhysicalDeviceFragmentShadingRateFeaturesKHR; - -typedef struct VkPhysicalDeviceFragmentShadingRatePropertiesKHR { - VkStructureType sType; - void* pNext; - VkExtent2D minFragmentShadingRateAttachmentTexelSize; - VkExtent2D maxFragmentShadingRateAttachmentTexelSize; - uint32_t maxFragmentShadingRateAttachmentTexelSizeAspectRatio; - VkBool32 primitiveFragmentShadingRateWithMultipleViewports; - VkBool32 layeredShadingRateAttachments; - VkBool32 fragmentShadingRateNonTrivialCombinerOps; - VkExtent2D maxFragmentSize; - uint32_t maxFragmentSizeAspectRatio; - uint32_t maxFragmentShadingRateCoverageSamples; - VkSampleCountFlagBits maxFragmentShadingRateRasterizationSamples; - VkBool32 fragmentShadingRateWithShaderDepthStencilWrites; - VkBool32 fragmentShadingRateWithSampleMask; - VkBool32 fragmentShadingRateWithShaderSampleMask; - VkBool32 fragmentShadingRateWithConservativeRasterization; - VkBool32 fragmentShadingRateWithFragmentShaderInterlock; - VkBool32 fragmentShadingRateWithCustomSampleLocations; - VkBool32 fragmentShadingRateStrictMultiplyCombiner; -} VkPhysicalDeviceFragmentShadingRatePropertiesKHR; - -typedef struct VkPhysicalDeviceFragmentShadingRateKHR { - VkStructureType sType; - void* pNext; - VkSampleCountFlags sampleCounts; - VkExtent2D fragmentSize; -} VkPhysicalDeviceFragmentShadingRateKHR; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); -typedef void ( *PFN_vkCmdSetFragmentShadingRateKHR)(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); -# 9883 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkSurfaceProtectedCapabilitiesKHR { - VkStructureType sType; - const void* pNext; - VkBool32 supportsProtected; -} VkSurfaceProtectedCapabilitiesKHR; - - - - - - - -typedef VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR; - -typedef VkAttachmentReferenceStencilLayout VkAttachmentReferenceStencilLayoutKHR; - -typedef VkAttachmentDescriptionStencilLayout VkAttachmentDescriptionStencilLayoutKHR; - - - - - - - -typedef struct VkPhysicalDevicePresentWaitFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 presentWait; -} VkPhysicalDevicePresentWaitFeaturesKHR; - -typedef VkResult ( *PFN_vkWaitForPresentKHR)(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout); -# 9928 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceUniformBufferStandardLayoutFeatures VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR; - - - - - - - -typedef VkPhysicalDeviceBufferDeviceAddressFeatures VkPhysicalDeviceBufferDeviceAddressFeaturesKHR; - -typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoKHR; - -typedef VkBufferOpaqueCaptureAddressCreateInfo VkBufferOpaqueCaptureAddressCreateInfoKHR; - -typedef VkMemoryOpaqueCaptureAddressAllocateInfo VkMemoryOpaqueCaptureAddressAllocateInfoKHR; - -typedef VkDeviceMemoryOpaqueCaptureAddressInfo VkDeviceMemoryOpaqueCaptureAddressInfoKHR; - -typedef VkDeviceAddress ( *PFN_vkGetBufferDeviceAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t ( *PFN_vkGetBufferOpaqueCaptureAddressKHR)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -typedef uint64_t ( *PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR)(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); -# 9967 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkDeferredOperationKHR_T *VkDeferredOperationKHR; - - -typedef VkResult ( *PFN_vkCreateDeferredOperationKHR)(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation); -typedef void ( *PFN_vkDestroyDeferredOperationKHR)(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator); -typedef uint32_t ( *PFN_vkGetDeferredOperationMaxConcurrencyKHR)(VkDevice device, VkDeferredOperationKHR operation); -typedef VkResult ( *PFN_vkGetDeferredOperationResultKHR)(VkDevice device, VkDeferredOperationKHR operation); -typedef VkResult ( *PFN_vkDeferredOperationJoinKHR)(VkDevice device, VkDeferredOperationKHR operation); -# 10006 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkPipelineExecutableStatisticFormatKHR { - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_BOOL32_KHR = 0, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_INT64_KHR = 1, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_UINT64_KHR = 2, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_FLOAT64_KHR = 3, - VK_PIPELINE_EXECUTABLE_STATISTIC_FORMAT_MAX_ENUM_KHR = 0x7FFFFFFF -} VkPipelineExecutableStatisticFormatKHR; -typedef struct VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 pipelineExecutableInfo; -} VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR; - -typedef struct VkPipelineInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipeline pipeline; -} VkPipelineInfoKHR; - -typedef struct VkPipelineExecutablePropertiesKHR { - VkStructureType sType; - void* pNext; - VkShaderStageFlags stages; - char name[256U]; - char description[256U]; - uint32_t subgroupSize; -} VkPipelineExecutablePropertiesKHR; - -typedef struct VkPipelineExecutableInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipeline pipeline; - uint32_t executableIndex; -} VkPipelineExecutableInfoKHR; - -typedef union VkPipelineExecutableStatisticValueKHR { - VkBool32 b32; - int64_t i64; - uint64_t u64; - double f64; -} VkPipelineExecutableStatisticValueKHR; - -typedef struct VkPipelineExecutableStatisticKHR { - VkStructureType sType; - void* pNext; - char name[256U]; - char description[256U]; - VkPipelineExecutableStatisticFormatKHR format; - VkPipelineExecutableStatisticValueKHR value; -} VkPipelineExecutableStatisticKHR; - -typedef struct VkPipelineExecutableInternalRepresentationKHR { - VkStructureType sType; - void* pNext; - char name[256U]; - char description[256U]; - VkBool32 isText; - size_t dataSize; - void* pData; -} VkPipelineExecutableInternalRepresentationKHR; - -typedef VkResult ( *PFN_vkGetPipelineExecutablePropertiesKHR)(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties); -typedef VkResult ( *PFN_vkGetPipelineExecutableStatisticsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics); -typedef VkResult ( *PFN_vkGetPipelineExecutableInternalRepresentationsKHR)(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); -# 10096 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkFlags VkMemoryUnmapFlagsKHR; -typedef struct VkMemoryMapInfoKHR { - VkStructureType sType; - const void* pNext; - VkMemoryMapFlags flags; - VkDeviceMemory memory; - VkDeviceSize offset; - VkDeviceSize size; -} VkMemoryMapInfoKHR; - -typedef struct VkMemoryUnmapInfoKHR { - VkStructureType sType; - const void* pNext; - VkMemoryUnmapFlagsKHR flags; - VkDeviceMemory memory; -} VkMemoryUnmapInfoKHR; - -typedef VkResult ( *PFN_vkMapMemory2KHR)(VkDevice device, const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData); -typedef VkResult ( *PFN_vkUnmapMemory2KHR)(VkDevice device, const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); -# 10132 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceShaderIntegerDotProductFeatures VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR; - -typedef VkPhysicalDeviceShaderIntegerDotProductProperties VkPhysicalDeviceShaderIntegerDotProductPropertiesKHR; - - - - - - - -typedef struct VkPipelineLibraryCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t libraryCount; - const VkPipeline* pLibraries; -} VkPipelineLibraryCreateInfoKHR; -# 10161 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPresentIdKHR { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const uint64_t* pPresentIds; -} VkPresentIdKHR; - -typedef struct VkPhysicalDevicePresentIdFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 presentId; -} VkPhysicalDevicePresentIdFeaturesKHR; - - - - - - - -typedef VkPipelineStageFlags2 VkPipelineStageFlags2KHR; - -typedef VkPipelineStageFlagBits2 VkPipelineStageFlagBits2KHR; - -typedef VkAccessFlags2 VkAccessFlags2KHR; - -typedef VkAccessFlagBits2 VkAccessFlagBits2KHR; - -typedef VkSubmitFlagBits VkSubmitFlagBitsKHR; - -typedef VkSubmitFlags VkSubmitFlagsKHR; - -typedef VkMemoryBarrier2 VkMemoryBarrier2KHR; - -typedef VkBufferMemoryBarrier2 VkBufferMemoryBarrier2KHR; - -typedef VkImageMemoryBarrier2 VkImageMemoryBarrier2KHR; - -typedef VkDependencyInfo VkDependencyInfoKHR; - -typedef VkSubmitInfo2 VkSubmitInfo2KHR; - -typedef VkSemaphoreSubmitInfo VkSemaphoreSubmitInfoKHR; - -typedef VkCommandBufferSubmitInfo VkCommandBufferSubmitInfoKHR; - -typedef VkPhysicalDeviceSynchronization2Features VkPhysicalDeviceSynchronization2FeaturesKHR; - -typedef struct VkQueueFamilyCheckpointProperties2NV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlags2 checkpointExecutionStageMask; -} VkQueueFamilyCheckpointProperties2NV; - -typedef struct VkCheckpointData2NV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlags2 stage; - void* pCheckpointMarker; -} VkCheckpointData2NV; - -typedef void ( *PFN_vkCmdSetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo); -typedef void ( *PFN_vkCmdResetEvent2KHR)(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask); -typedef void ( *PFN_vkCmdWaitEvents2KHR)(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos); -typedef void ( *PFN_vkCmdPipelineBarrier2KHR)(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo); -typedef void ( *PFN_vkCmdWriteTimestamp2KHR)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query); -typedef VkResult ( *PFN_vkQueueSubmit2KHR)(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence); -typedef void ( *PFN_vkCmdWriteBufferMarker2AMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); -typedef void ( *PFN_vkGetQueueCheckpointData2NV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData); -# 10281 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShaderBarycentric; -} VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR; - -typedef struct VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 triStripVertexOrderIndependentOfProvokingVertex; -} VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR; - - - - - - - -typedef struct VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 shaderSubgroupUniformControlFlow; -} VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR; - - - - - - - -typedef VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR; - - - - - - - -typedef struct VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 workgroupMemoryExplicitLayout; - VkBool32 workgroupMemoryExplicitLayoutScalarBlockLayout; - VkBool32 workgroupMemoryExplicitLayout8BitAccess; - VkBool32 workgroupMemoryExplicitLayout16BitAccess; -} VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR; - - - - - - - -typedef VkCopyBufferInfo2 VkCopyBufferInfo2KHR; - -typedef VkCopyImageInfo2 VkCopyImageInfo2KHR; - -typedef VkCopyBufferToImageInfo2 VkCopyBufferToImageInfo2KHR; - -typedef VkCopyImageToBufferInfo2 VkCopyImageToBufferInfo2KHR; - -typedef VkBlitImageInfo2 VkBlitImageInfo2KHR; - -typedef VkResolveImageInfo2 VkResolveImageInfo2KHR; - -typedef VkBufferCopy2 VkBufferCopy2KHR; - -typedef VkImageCopy2 VkImageCopy2KHR; - -typedef VkImageBlit2 VkImageBlit2KHR; - -typedef VkBufferImageCopy2 VkBufferImageCopy2KHR; - -typedef VkImageResolve2 VkImageResolve2KHR; - -typedef void ( *PFN_vkCmdCopyBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo); -typedef void ( *PFN_vkCmdCopyImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo); -typedef void ( *PFN_vkCmdCopyBufferToImage2KHR)(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); -typedef void ( *PFN_vkCmdCopyImageToBuffer2KHR)(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); -typedef void ( *PFN_vkCmdBlitImage2KHR)(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo); -typedef void ( *PFN_vkCmdResolveImage2KHR)(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo); -# 10394 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkFormatFeatureFlags2 VkFormatFeatureFlags2KHR; - -typedef VkFormatFeatureFlagBits2 VkFormatFeatureFlagBits2KHR; - -typedef VkFormatProperties3 VkFormatProperties3KHR; - - - - - - - -typedef struct VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingMaintenance1; - VkBool32 rayTracingPipelineTraceRaysIndirect2; -} VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR; - -typedef struct VkTraceRaysIndirectCommand2KHR { - VkDeviceAddress raygenShaderRecordAddress; - VkDeviceSize raygenShaderRecordSize; - VkDeviceAddress missShaderBindingTableAddress; - VkDeviceSize missShaderBindingTableSize; - VkDeviceSize missShaderBindingTableStride; - VkDeviceAddress hitShaderBindingTableAddress; - VkDeviceSize hitShaderBindingTableSize; - VkDeviceSize hitShaderBindingTableStride; - VkDeviceAddress callableShaderBindingTableAddress; - VkDeviceSize callableShaderBindingTableSize; - VkDeviceSize callableShaderBindingTableStride; - uint32_t width; - uint32_t height; - uint32_t depth; -} VkTraceRaysIndirectCommand2KHR; - -typedef void ( *PFN_vkCmdTraceRaysIndirect2KHR)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress); -# 10449 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceMaintenance4Features VkPhysicalDeviceMaintenance4FeaturesKHR; - -typedef VkPhysicalDeviceMaintenance4Properties VkPhysicalDeviceMaintenance4PropertiesKHR; - -typedef VkDeviceBufferMemoryRequirements VkDeviceBufferMemoryRequirementsKHR; - -typedef VkDeviceImageMemoryRequirements VkDeviceImageMemoryRequirementsKHR; - -typedef void ( *PFN_vkGetDeviceBufferMemoryRequirementsKHR)(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkGetDeviceImageMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkGetDeviceImageSparseMemoryRequirementsKHR)(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); -# 10484 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkFlags64 VkPipelineCreateFlags2KHR; - - -typedef VkFlags64 VkPipelineCreateFlagBits2KHR; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISABLE_OPTIMIZATION_BIT_KHR = 0x00000001ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_ALLOW_DERIVATIVES_BIT_KHR = 0x00000002ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DERIVATIVE_BIT_KHR = 0x00000004ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_VIEW_INDEX_FROM_DEVICE_INDEX_BIT_KHR = 0x00000008ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DISPATCH_BASE_BIT_KHR = 0x00000010ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DEFER_COMPILE_BIT_NV = 0x00000020ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_CAPTURE_STATISTICS_BIT_KHR = 0x00000040ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_CAPTURE_INTERNAL_REPRESENTATIONS_BIT_KHR = 0x00000080ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_FAIL_ON_PIPELINE_COMPILE_REQUIRED_BIT_KHR = 0x00000100ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_EARLY_RETURN_ON_FAILURE_BIT_KHR = 0x00000200ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_LINK_TIME_OPTIMIZATION_BIT_EXT = 0x00000400ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RETAIN_LINK_TIME_OPTIMIZATION_INFO_BIT_EXT = 0x00800000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_LIBRARY_BIT_KHR = 0x00000800ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_TRIANGLES_BIT_KHR = 0x00001000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_SKIP_AABBS_BIT_KHR = 0x00002000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_ANY_HIT_SHADERS_BIT_KHR = 0x00004000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_CLOSEST_HIT_SHADERS_BIT_KHR = 0x00008000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_MISS_SHADERS_BIT_KHR = 0x00010000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_NO_NULL_INTERSECTION_SHADERS_BIT_KHR = 0x00020000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_SHADER_GROUP_HANDLE_CAPTURE_REPLAY_BIT_KHR = 0x00080000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_INDIRECT_BINDABLE_BIT_NV = 0x00040000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_ALLOW_MOTION_BIT_NV = 0x00100000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_KHR = 0x00200000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00400000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_OPACITY_MICROMAP_BIT_EXT = 0x01000000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_COLOR_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x02000000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DEPTH_STENCIL_ATTACHMENT_FEEDBACK_LOOP_BIT_EXT = 0x04000000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_NO_PROTECTED_ACCESS_BIT_EXT = 0x08000000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_PROTECTED_ACCESS_ONLY_BIT_EXT = 0x40000000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_RAY_TRACING_DISPLACEMENT_MICROMAP_BIT_NV = 0x10000000ULL; -static const VkPipelineCreateFlagBits2KHR VK_PIPELINE_CREATE_2_DESCRIPTOR_BUFFER_BIT_EXT = 0x20000000ULL; - -typedef VkFlags64 VkBufferUsageFlags2KHR; - - -typedef VkFlags64 VkBufferUsageFlagBits2KHR; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFER_SRC_BIT_KHR = 0x00000001ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFER_DST_BIT_KHR = 0x00000002ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_UNIFORM_TEXEL_BUFFER_BIT_KHR = 0x00000004ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_STORAGE_TEXEL_BUFFER_BIT_KHR = 0x00000008ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_UNIFORM_BUFFER_BIT_KHR = 0x00000010ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_STORAGE_BUFFER_BIT_KHR = 0x00000020ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_INDEX_BUFFER_BIT_KHR = 0x00000040ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VERTEX_BUFFER_BIT_KHR = 0x00000080ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_INDIRECT_BUFFER_BIT_KHR = 0x00000100ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_EXECUTION_GRAPH_SCRATCH_BIT_AMDX = 0x02000000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_CONDITIONAL_RENDERING_BIT_EXT = 0x00000200ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SHADER_BINDING_TABLE_BIT_KHR = 0x00000400ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_RAY_TRACING_BIT_NV = 0x00000400ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_BUFFER_BIT_EXT = 0x00000800ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_TRANSFORM_FEEDBACK_COUNTER_BUFFER_BIT_EXT = 0x00001000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_SRC_BIT_KHR = 0x00002000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_VIDEO_DECODE_DST_BIT_KHR = 0x00004000ULL; - - - - - - -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SHADER_DEVICE_ADDRESS_BIT_KHR = 0x00020000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_BUILD_INPUT_READ_ONLY_BIT_KHR = 0x00080000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_ACCELERATION_STRUCTURE_STORAGE_BIT_KHR = 0x00100000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_SAMPLER_DESCRIPTOR_BUFFER_BIT_EXT = 0x00200000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_RESOURCE_DESCRIPTOR_BUFFER_BIT_EXT = 0x00400000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_PUSH_DESCRIPTORS_DESCRIPTOR_BUFFER_BIT_EXT = 0x04000000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_BUILD_INPUT_READ_ONLY_BIT_EXT = 0x00800000ULL; -static const VkBufferUsageFlagBits2KHR VK_BUFFER_USAGE_2_MICROMAP_STORAGE_BIT_EXT = 0x01000000ULL; - -typedef struct VkPhysicalDeviceMaintenance5FeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 maintenance5; -} VkPhysicalDeviceMaintenance5FeaturesKHR; - -typedef struct VkPhysicalDeviceMaintenance5PropertiesKHR { - VkStructureType sType; - void* pNext; - VkBool32 earlyFragmentMultisampleCoverageAfterSampleCounting; - VkBool32 earlyFragmentSampleMaskTestBeforeSampleCounting; - VkBool32 depthStencilSwizzleOneSupport; - VkBool32 polygonModePointSize; - VkBool32 nonStrictSinglePixelWideLinesUseParallelogram; - VkBool32 nonStrictWideLinesUseParallelogram; -} VkPhysicalDeviceMaintenance5PropertiesKHR; - -typedef struct VkRenderingAreaInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t viewMask; - uint32_t colorAttachmentCount; - const VkFormat* pColorAttachmentFormats; - VkFormat depthAttachmentFormat; - VkFormat stencilAttachmentFormat; -} VkRenderingAreaInfoKHR; - -typedef struct VkImageSubresource2KHR { - VkStructureType sType; - void* pNext; - VkImageSubresource imageSubresource; -} VkImageSubresource2KHR; - -typedef struct VkDeviceImageSubresourceInfoKHR { - VkStructureType sType; - const void* pNext; - const VkImageCreateInfo* pCreateInfo; - const VkImageSubresource2KHR* pSubresource; -} VkDeviceImageSubresourceInfoKHR; - -typedef struct VkSubresourceLayout2KHR { - VkStructureType sType; - void* pNext; - VkSubresourceLayout subresourceLayout; -} VkSubresourceLayout2KHR; - -typedef struct VkPipelineCreateFlags2CreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags2KHR flags; -} VkPipelineCreateFlags2CreateInfoKHR; - -typedef struct VkBufferUsageFlags2CreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkBufferUsageFlags2KHR usage; -} VkBufferUsageFlags2CreateInfoKHR; - -typedef void ( *PFN_vkCmdBindIndexBuffer2KHR)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType); -typedef void ( *PFN_vkGetRenderingAreaGranularityKHR)(VkDevice device, const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity); -typedef void ( *PFN_vkGetDeviceImageSubresourceLayoutKHR)(VkDevice device, const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2KHR* pLayout); -typedef void ( *PFN_vkGetImageSubresourceLayout2KHR)(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout); -# 10649 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingPositionFetch; -} VkPhysicalDeviceRayTracingPositionFetchFeaturesKHR; -# 10662 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkComponentTypeKHR { - VK_COMPONENT_TYPE_FLOAT16_KHR = 0, - VK_COMPONENT_TYPE_FLOAT32_KHR = 1, - VK_COMPONENT_TYPE_FLOAT64_KHR = 2, - VK_COMPONENT_TYPE_SINT8_KHR = 3, - VK_COMPONENT_TYPE_SINT16_KHR = 4, - VK_COMPONENT_TYPE_SINT32_KHR = 5, - VK_COMPONENT_TYPE_SINT64_KHR = 6, - VK_COMPONENT_TYPE_UINT8_KHR = 7, - VK_COMPONENT_TYPE_UINT16_KHR = 8, - VK_COMPONENT_TYPE_UINT32_KHR = 9, - VK_COMPONENT_TYPE_UINT64_KHR = 10, - VK_COMPONENT_TYPE_FLOAT16_NV = VK_COMPONENT_TYPE_FLOAT16_KHR, - VK_COMPONENT_TYPE_FLOAT32_NV = VK_COMPONENT_TYPE_FLOAT32_KHR, - VK_COMPONENT_TYPE_FLOAT64_NV = VK_COMPONENT_TYPE_FLOAT64_KHR, - VK_COMPONENT_TYPE_SINT8_NV = VK_COMPONENT_TYPE_SINT8_KHR, - VK_COMPONENT_TYPE_SINT16_NV = VK_COMPONENT_TYPE_SINT16_KHR, - VK_COMPONENT_TYPE_SINT32_NV = VK_COMPONENT_TYPE_SINT32_KHR, - VK_COMPONENT_TYPE_SINT64_NV = VK_COMPONENT_TYPE_SINT64_KHR, - VK_COMPONENT_TYPE_UINT8_NV = VK_COMPONENT_TYPE_UINT8_KHR, - VK_COMPONENT_TYPE_UINT16_NV = VK_COMPONENT_TYPE_UINT16_KHR, - VK_COMPONENT_TYPE_UINT32_NV = VK_COMPONENT_TYPE_UINT32_KHR, - VK_COMPONENT_TYPE_UINT64_NV = VK_COMPONENT_TYPE_UINT64_KHR, - VK_COMPONENT_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkComponentTypeKHR; - -typedef enum VkScopeKHR { - VK_SCOPE_DEVICE_KHR = 1, - VK_SCOPE_WORKGROUP_KHR = 2, - VK_SCOPE_SUBGROUP_KHR = 3, - VK_SCOPE_QUEUE_FAMILY_KHR = 5, - VK_SCOPE_DEVICE_NV = VK_SCOPE_DEVICE_KHR, - VK_SCOPE_WORKGROUP_NV = VK_SCOPE_WORKGROUP_KHR, - VK_SCOPE_SUBGROUP_NV = VK_SCOPE_SUBGROUP_KHR, - VK_SCOPE_QUEUE_FAMILY_NV = VK_SCOPE_QUEUE_FAMILY_KHR, - VK_SCOPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkScopeKHR; -typedef struct VkCooperativeMatrixPropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - VkComponentTypeKHR AType; - VkComponentTypeKHR BType; - VkComponentTypeKHR CType; - VkComponentTypeKHR ResultType; - VkBool32 saturatingAccumulation; - VkScopeKHR scope; -} VkCooperativeMatrixPropertiesKHR; - -typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 cooperativeMatrix; - VkBool32 cooperativeMatrixRobustBufferAccess; -} VkPhysicalDeviceCooperativeMatrixFeaturesKHR; - -typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesKHR { - VkStructureType sType; - void* pNext; - VkShaderStageFlags cooperativeMatrixSupportedStages; -} VkPhysicalDeviceCooperativeMatrixPropertiesKHR; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties); -# 10738 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkDebugReportCallbackEXT_T *VkDebugReportCallbackEXT; - - - -typedef enum VkDebugReportObjectTypeEXT { - VK_DEBUG_REPORT_OBJECT_TYPE_UNKNOWN_EXT = 0, - VK_DEBUG_REPORT_OBJECT_TYPE_INSTANCE_EXT = 1, - VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT = 2, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_EXT = 3, - VK_DEBUG_REPORT_OBJECT_TYPE_QUEUE_EXT = 4, - VK_DEBUG_REPORT_OBJECT_TYPE_SEMAPHORE_EXT = 5, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_BUFFER_EXT = 6, - VK_DEBUG_REPORT_OBJECT_TYPE_FENCE_EXT = 7, - VK_DEBUG_REPORT_OBJECT_TYPE_DEVICE_MEMORY_EXT = 8, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_EXT = 9, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_EXT = 10, - VK_DEBUG_REPORT_OBJECT_TYPE_EVENT_EXT = 11, - VK_DEBUG_REPORT_OBJECT_TYPE_QUERY_POOL_EXT = 12, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_VIEW_EXT = 13, - VK_DEBUG_REPORT_OBJECT_TYPE_IMAGE_VIEW_EXT = 14, - VK_DEBUG_REPORT_OBJECT_TYPE_SHADER_MODULE_EXT = 15, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_CACHE_EXT = 16, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_LAYOUT_EXT = 17, - VK_DEBUG_REPORT_OBJECT_TYPE_RENDER_PASS_EXT = 18, - VK_DEBUG_REPORT_OBJECT_TYPE_PIPELINE_EXT = 19, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT_EXT = 20, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_EXT = 21, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_POOL_EXT = 22, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_SET_EXT = 23, - VK_DEBUG_REPORT_OBJECT_TYPE_FRAMEBUFFER_EXT = 24, - VK_DEBUG_REPORT_OBJECT_TYPE_COMMAND_POOL_EXT = 25, - VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT = 26, - VK_DEBUG_REPORT_OBJECT_TYPE_SWAPCHAIN_KHR_EXT = 27, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT = 28, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_KHR_EXT = 29, - VK_DEBUG_REPORT_OBJECT_TYPE_DISPLAY_MODE_KHR_EXT = 30, - VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT = 33, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT = 1000156000, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT = 1000085000, - VK_DEBUG_REPORT_OBJECT_TYPE_CU_MODULE_NVX_EXT = 1000029000, - VK_DEBUG_REPORT_OBJECT_TYPE_CU_FUNCTION_NVX_EXT = 1000029001, - VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR_EXT = 1000150000, - VK_DEBUG_REPORT_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV_EXT = 1000165000, - VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_MODULE_NV = 1000307000, - VK_DEBUG_REPORT_OBJECT_TYPE_CUDA_FUNCTION_NV = 1000307001, - VK_DEBUG_REPORT_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA_EXT = 1000366000, - VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_VALIDATION_CACHE_EXT_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_KHR_EXT = VK_DEBUG_REPORT_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION_EXT, - VK_DEBUG_REPORT_OBJECT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportObjectTypeEXT; - -typedef enum VkDebugReportFlagBitsEXT { - VK_DEBUG_REPORT_INFORMATION_BIT_EXT = 0x00000001, - VK_DEBUG_REPORT_WARNING_BIT_EXT = 0x00000002, - VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT = 0x00000004, - VK_DEBUG_REPORT_ERROR_BIT_EXT = 0x00000008, - VK_DEBUG_REPORT_DEBUG_BIT_EXT = 0x00000010, - VK_DEBUG_REPORT_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugReportFlagBitsEXT; -typedef VkFlags VkDebugReportFlagsEXT; -typedef VkBool32 ( *PFN_vkDebugReportCallbackEXT)( - VkDebugReportFlagsEXT flags, - VkDebugReportObjectTypeEXT objectType, - uint64_t object, - size_t location, - int32_t messageCode, - const char* pLayerPrefix, - const char* pMessage, - void* pUserData); - -typedef struct VkDebugReportCallbackCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportFlagsEXT flags; - PFN_vkDebugReportCallbackEXT pfnCallback; - void* pUserData; -} VkDebugReportCallbackCreateInfoEXT; - -typedef VkResult ( *PFN_vkCreateDebugReportCallbackEXT)(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback); -typedef void ( *PFN_vkDestroyDebugReportCallbackEXT)(VkInstance instance, VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkDebugReportMessageEXT)(VkInstance instance, VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage); -# 10869 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkRasterizationOrderAMD { - VK_RASTERIZATION_ORDER_STRICT_AMD = 0, - VK_RASTERIZATION_ORDER_RELAXED_AMD = 1, - VK_RASTERIZATION_ORDER_MAX_ENUM_AMD = 0x7FFFFFFF -} VkRasterizationOrderAMD; -typedef struct VkPipelineRasterizationStateRasterizationOrderAMD { - VkStructureType sType; - const void* pNext; - VkRasterizationOrderAMD rasterizationOrder; -} VkPipelineRasterizationStateRasterizationOrderAMD; -# 10898 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkDebugMarkerObjectNameInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - const char* pObjectName; -} VkDebugMarkerObjectNameInfoEXT; - -typedef struct VkDebugMarkerObjectTagInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugReportObjectTypeEXT objectType; - uint64_t object; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkDebugMarkerObjectTagInfoEXT; - -typedef struct VkDebugMarkerMarkerInfoEXT { - VkStructureType sType; - const void* pNext; - const char* pMarkerName; - float color[4]; -} VkDebugMarkerMarkerInfoEXT; - -typedef VkResult ( *PFN_vkDebugMarkerSetObjectTagEXT)(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo); -typedef VkResult ( *PFN_vkDebugMarkerSetObjectNameEXT)(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo); -typedef void ( *PFN_vkCmdDebugMarkerBeginEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); -typedef void ( *PFN_vkCmdDebugMarkerEndEXT)(VkCommandBuffer commandBuffer); -typedef void ( *PFN_vkCmdDebugMarkerInsertEXT)(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); -# 10961 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkDedicatedAllocationImageCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationImageCreateInfoNV; - -typedef struct VkDedicatedAllocationBufferCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 dedicatedAllocation; -} VkDedicatedAllocationBufferCreateInfoNV; - -typedef struct VkDedicatedAllocationMemoryAllocateInfoNV { - VkStructureType sType; - const void* pNext; - VkImage image; - VkBuffer buffer; -} VkDedicatedAllocationMemoryAllocateInfoNV; - - - - - - - -typedef VkFlags VkPipelineRasterizationStateStreamCreateFlagsEXT; -typedef struct VkPhysicalDeviceTransformFeedbackFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 transformFeedback; - VkBool32 geometryStreams; -} VkPhysicalDeviceTransformFeedbackFeaturesEXT; - -typedef struct VkPhysicalDeviceTransformFeedbackPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxTransformFeedbackStreams; - uint32_t maxTransformFeedbackBuffers; - VkDeviceSize maxTransformFeedbackBufferSize; - uint32_t maxTransformFeedbackStreamDataSize; - uint32_t maxTransformFeedbackBufferDataSize; - uint32_t maxTransformFeedbackBufferDataStride; - VkBool32 transformFeedbackQueries; - VkBool32 transformFeedbackStreamsLinesTriangles; - VkBool32 transformFeedbackRasterizationStreamSelect; - VkBool32 transformFeedbackDraw; -} VkPhysicalDeviceTransformFeedbackPropertiesEXT; - -typedef struct VkPipelineRasterizationStateStreamCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationStateStreamCreateFlagsEXT flags; - uint32_t rasterizationStream; -} VkPipelineRasterizationStateStreamCreateInfoEXT; - -typedef void ( *PFN_vkCmdBindTransformFeedbackBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes); -typedef void ( *PFN_vkCmdBeginTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); -typedef void ( *PFN_vkCmdEndTransformFeedbackEXT)(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets); -typedef void ( *PFN_vkCmdBeginQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index); -typedef void ( *PFN_vkCmdEndQueryIndexedEXT)(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index); -typedef void ( *PFN_vkCmdDrawIndirectByteCountEXT)(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride); -# 11072 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkCuModuleNVX_T *VkCuModuleNVX; -typedef struct VkCuFunctionNVX_T *VkCuFunctionNVX; - - -typedef struct VkCuModuleCreateInfoNVX { - VkStructureType sType; - const void* pNext; - size_t dataSize; - const void* pData; -} VkCuModuleCreateInfoNVX; - -typedef struct VkCuFunctionCreateInfoNVX { - VkStructureType sType; - const void* pNext; - VkCuModuleNVX module; - const char* pName; -} VkCuFunctionCreateInfoNVX; - -typedef struct VkCuLaunchInfoNVX { - VkStructureType sType; - const void* pNext; - VkCuFunctionNVX function; - uint32_t gridDimX; - uint32_t gridDimY; - uint32_t gridDimZ; - uint32_t blockDimX; - uint32_t blockDimY; - uint32_t blockDimZ; - uint32_t sharedMemBytes; - size_t paramCount; - const void* const * pParams; - size_t extraCount; - const void* const * pExtras; -} VkCuLaunchInfoNVX; - -typedef VkResult ( *PFN_vkCreateCuModuleNVX)(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule); -typedef VkResult ( *PFN_vkCreateCuFunctionNVX)(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction); -typedef void ( *PFN_vkDestroyCuModuleNVX)(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkDestroyCuFunctionNVX)(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkCmdCuLaunchKernelNVX)(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo); -# 11146 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkImageViewHandleInfoNVX { - VkStructureType sType; - const void* pNext; - VkImageView imageView; - VkDescriptorType descriptorType; - VkSampler sampler; -} VkImageViewHandleInfoNVX; - -typedef struct VkImageViewAddressPropertiesNVX { - VkStructureType sType; - void* pNext; - VkDeviceAddress deviceAddress; - VkDeviceSize size; -} VkImageViewAddressPropertiesNVX; - -typedef uint32_t ( *PFN_vkGetImageViewHandleNVX)(VkDevice device, const VkImageViewHandleInfoNVX* pInfo); -typedef VkResult ( *PFN_vkGetImageViewAddressNVX)(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties); -# 11180 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef void ( *PFN_vkCmdDrawIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -typedef void ( *PFN_vkCmdDrawIndexedIndirectCountAMD)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -# 11226 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkTextureLODGatherFormatPropertiesAMD { - VkStructureType sType; - void* pNext; - VkBool32 supportsTextureGatherLODBiasAMD; -} VkTextureLODGatherFormatPropertiesAMD; -# 11239 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkShaderInfoTypeAMD { - VK_SHADER_INFO_TYPE_STATISTICS_AMD = 0, - VK_SHADER_INFO_TYPE_BINARY_AMD = 1, - VK_SHADER_INFO_TYPE_DISASSEMBLY_AMD = 2, - VK_SHADER_INFO_TYPE_MAX_ENUM_AMD = 0x7FFFFFFF -} VkShaderInfoTypeAMD; -typedef struct VkShaderResourceUsageAMD { - uint32_t numUsedVgprs; - uint32_t numUsedSgprs; - uint32_t ldsSizePerLocalWorkGroup; - size_t ldsUsageSizeInBytes; - size_t scratchMemUsageInBytes; -} VkShaderResourceUsageAMD; - -typedef struct VkShaderStatisticsInfoAMD { - VkShaderStageFlags shaderStageMask; - VkShaderResourceUsageAMD resourceUsage; - uint32_t numPhysicalVgprs; - uint32_t numPhysicalSgprs; - uint32_t numAvailableVgprs; - uint32_t numAvailableSgprs; - uint32_t computeWorkGroupSize[3]; -} VkShaderStatisticsInfoAMD; - -typedef VkResult ( *PFN_vkGetShaderInfoAMD)(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo); -# 11286 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceCornerSampledImageFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cornerSampledImage; -} VkPhysicalDeviceCornerSampledImageFeaturesNV; -# 11305 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkExternalMemoryHandleTypeFlagBitsNV { - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_IMAGE_KMT_BIT_NV = 0x00000008, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkExternalMemoryHandleTypeFlagBitsNV; -typedef VkFlags VkExternalMemoryHandleTypeFlagsNV; - -typedef enum VkExternalMemoryFeatureFlagBitsNV { - VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_NV = 0x00000001, - VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_NV = 0x00000002, - VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_NV = 0x00000004, - VK_EXTERNAL_MEMORY_FEATURE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkExternalMemoryFeatureFlagBitsNV; -typedef VkFlags VkExternalMemoryFeatureFlagsNV; -typedef struct VkExternalImageFormatPropertiesNV { - VkImageFormatProperties imageFormatProperties; - VkExternalMemoryFeatureFlagsNV externalMemoryFeatures; - VkExternalMemoryHandleTypeFlagsNV exportFromImportedHandleTypes; - VkExternalMemoryHandleTypeFlagsNV compatibleHandleTypes; -} VkExternalImageFormatPropertiesNV; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV)(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); -# 11347 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkExternalMemoryImageCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleTypes; -} VkExternalMemoryImageCreateInfoNV; - -typedef struct VkExportMemoryAllocateInfoNV { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagsNV handleTypes; -} VkExportMemoryAllocateInfoNV; -# 11366 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkValidationCheckEXT { - VK_VALIDATION_CHECK_ALL_EXT = 0, - VK_VALIDATION_CHECK_SHADERS_EXT = 1, - VK_VALIDATION_CHECK_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationCheckEXT; -typedef struct VkValidationFlagsEXT { - VkStructureType sType; - const void* pNext; - uint32_t disabledValidationCheckCount; - const VkValidationCheckEXT* pDisabledValidationChecks; -} VkValidationFlagsEXT; -# 11396 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceTextureCompressionASTCHDRFeatures VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT; - - - - - - - -typedef struct VkImageViewASTCDecodeModeEXT { - VkStructureType sType; - const void* pNext; - VkFormat decodeMode; -} VkImageViewASTCDecodeModeEXT; - -typedef struct VkPhysicalDeviceASTCDecodeFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 decodeModeSharedExponent; -} VkPhysicalDeviceASTCDecodeFeaturesEXT; -# 11423 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkPipelineRobustnessBufferBehaviorEXT { - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DEVICE_DEFAULT_EXT = 0, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_DISABLED_EXT = 1, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_EXT = 2, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_ROBUST_BUFFER_ACCESS_2_EXT = 3, - VK_PIPELINE_ROBUSTNESS_BUFFER_BEHAVIOR_MAX_ENUM_EXT = 0x7FFFFFFF -} VkPipelineRobustnessBufferBehaviorEXT; - -typedef enum VkPipelineRobustnessImageBehaviorEXT { - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DEVICE_DEFAULT_EXT = 0, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_DISABLED_EXT = 1, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_EXT = 2, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_ROBUST_IMAGE_ACCESS_2_EXT = 3, - VK_PIPELINE_ROBUSTNESS_IMAGE_BEHAVIOR_MAX_ENUM_EXT = 0x7FFFFFFF -} VkPipelineRobustnessImageBehaviorEXT; -typedef struct VkPhysicalDevicePipelineRobustnessFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pipelineRobustness; -} VkPhysicalDevicePipelineRobustnessFeaturesEXT; - -typedef struct VkPhysicalDevicePipelineRobustnessPropertiesEXT { - VkStructureType sType; - void* pNext; - VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessStorageBuffers; - VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessUniformBuffers; - VkPipelineRobustnessBufferBehaviorEXT defaultRobustnessVertexInputs; - VkPipelineRobustnessImageBehaviorEXT defaultRobustnessImages; -} VkPhysicalDevicePipelineRobustnessPropertiesEXT; - -typedef struct VkPipelineRobustnessCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRobustnessBufferBehaviorEXT storageBuffers; - VkPipelineRobustnessBufferBehaviorEXT uniformBuffers; - VkPipelineRobustnessBufferBehaviorEXT vertexInputs; - VkPipelineRobustnessImageBehaviorEXT images; -} VkPipelineRobustnessCreateInfoEXT; -# 11469 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkConditionalRenderingFlagBitsEXT { - VK_CONDITIONAL_RENDERING_INVERTED_BIT_EXT = 0x00000001, - VK_CONDITIONAL_RENDERING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkConditionalRenderingFlagBitsEXT; -typedef VkFlags VkConditionalRenderingFlagsEXT; -typedef struct VkConditionalRenderingBeginInfoEXT { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; - VkDeviceSize offset; - VkConditionalRenderingFlagsEXT flags; -} VkConditionalRenderingBeginInfoEXT; - -typedef struct VkPhysicalDeviceConditionalRenderingFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 conditionalRendering; - VkBool32 inheritedConditionalRendering; -} VkPhysicalDeviceConditionalRenderingFeaturesEXT; - -typedef struct VkCommandBufferInheritanceConditionalRenderingInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 conditionalRenderingEnable; -} VkCommandBufferInheritanceConditionalRenderingInfoEXT; - -typedef void ( *PFN_vkCmdBeginConditionalRenderingEXT)(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); -typedef void ( *PFN_vkCmdEndConditionalRenderingEXT)(VkCommandBuffer commandBuffer); -# 11512 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkViewportWScalingNV { - float xcoeff; - float ycoeff; -} VkViewportWScalingNV; - -typedef struct VkPipelineViewportWScalingStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 viewportWScalingEnable; - uint32_t viewportCount; - const VkViewportWScalingNV* pViewportWScalings; -} VkPipelineViewportWScalingStateCreateInfoNV; - -typedef void ( *PFN_vkCmdSetViewportWScalingNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings); -# 11540 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkResult ( *PFN_vkReleaseDisplayEXT)(VkPhysicalDevice physicalDevice, VkDisplayKHR display); -# 11554 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkSurfaceCounterFlagBitsEXT { - VK_SURFACE_COUNTER_VBLANK_BIT_EXT = 0x00000001, - VK_SURFACE_COUNTER_VBLANK_EXT = VK_SURFACE_COUNTER_VBLANK_BIT_EXT, - VK_SURFACE_COUNTER_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkSurfaceCounterFlagBitsEXT; -typedef VkFlags VkSurfaceCounterFlagsEXT; -typedef struct VkSurfaceCapabilities2EXT { - VkStructureType sType; - void* pNext; - uint32_t minImageCount; - uint32_t maxImageCount; - VkExtent2D currentExtent; - VkExtent2D minImageExtent; - VkExtent2D maxImageExtent; - uint32_t maxImageArrayLayers; - VkSurfaceTransformFlagsKHR supportedTransforms; - VkSurfaceTransformFlagBitsKHR currentTransform; - VkCompositeAlphaFlagsKHR supportedCompositeAlpha; - VkImageUsageFlags supportedUsageFlags; - VkSurfaceCounterFlagsEXT supportedSurfaceCounters; -} VkSurfaceCapabilities2EXT; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT)(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities); -# 11591 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkDisplayPowerStateEXT { - VK_DISPLAY_POWER_STATE_OFF_EXT = 0, - VK_DISPLAY_POWER_STATE_SUSPEND_EXT = 1, - VK_DISPLAY_POWER_STATE_ON_EXT = 2, - VK_DISPLAY_POWER_STATE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDisplayPowerStateEXT; - -typedef enum VkDeviceEventTypeEXT { - VK_DEVICE_EVENT_TYPE_DISPLAY_HOTPLUG_EXT = 0, - VK_DEVICE_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceEventTypeEXT; - -typedef enum VkDisplayEventTypeEXT { - VK_DISPLAY_EVENT_TYPE_FIRST_PIXEL_OUT_EXT = 0, - VK_DISPLAY_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDisplayEventTypeEXT; -typedef struct VkDisplayPowerInfoEXT { - VkStructureType sType; - const void* pNext; - VkDisplayPowerStateEXT powerState; -} VkDisplayPowerInfoEXT; - -typedef struct VkDeviceEventInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceEventTypeEXT deviceEvent; -} VkDeviceEventInfoEXT; - -typedef struct VkDisplayEventInfoEXT { - VkStructureType sType; - const void* pNext; - VkDisplayEventTypeEXT displayEvent; -} VkDisplayEventInfoEXT; - -typedef struct VkSwapchainCounterCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkSurfaceCounterFlagsEXT surfaceCounters; -} VkSwapchainCounterCreateInfoEXT; - -typedef VkResult ( *PFN_vkDisplayPowerControlEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo); -typedef VkResult ( *PFN_vkRegisterDeviceEventEXT)(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef VkResult ( *PFN_vkRegisterDisplayEventEXT)(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); -typedef VkResult ( *PFN_vkGetSwapchainCounterEXT)(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue); -# 11667 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkRefreshCycleDurationGOOGLE { - uint64_t refreshDuration; -} VkRefreshCycleDurationGOOGLE; - -typedef struct VkPastPresentationTimingGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; - uint64_t actualPresentTime; - uint64_t earliestPresentTime; - uint64_t presentMargin; -} VkPastPresentationTimingGOOGLE; - -typedef struct VkPresentTimeGOOGLE { - uint32_t presentID; - uint64_t desiredPresentTime; -} VkPresentTimeGOOGLE; - -typedef struct VkPresentTimesInfoGOOGLE { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentTimeGOOGLE* pTimes; -} VkPresentTimesInfoGOOGLE; - -typedef VkResult ( *PFN_vkGetRefreshCycleDurationGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); -typedef VkResult ( *PFN_vkGetPastPresentationTimingGOOGLE)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings); -# 11732 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX { - VkStructureType sType; - void* pNext; - VkBool32 perViewPositionAllComponents; -} VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX; -# 11745 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkViewportCoordinateSwizzleNV { - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_X_NV = 0, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_X_NV = 1, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Y_NV = 2, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Y_NV = 3, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_Z_NV = 4, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_Z_NV = 5, - VK_VIEWPORT_COORDINATE_SWIZZLE_POSITIVE_W_NV = 6, - VK_VIEWPORT_COORDINATE_SWIZZLE_NEGATIVE_W_NV = 7, - VK_VIEWPORT_COORDINATE_SWIZZLE_MAX_ENUM_NV = 0x7FFFFFFF -} VkViewportCoordinateSwizzleNV; -typedef VkFlags VkPipelineViewportSwizzleStateCreateFlagsNV; -typedef struct VkViewportSwizzleNV { - VkViewportCoordinateSwizzleNV x; - VkViewportCoordinateSwizzleNV y; - VkViewportCoordinateSwizzleNV z; - VkViewportCoordinateSwizzleNV w; -} VkViewportSwizzleNV; - -typedef struct VkPipelineViewportSwizzleStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineViewportSwizzleStateCreateFlagsNV flags; - uint32_t viewportCount; - const VkViewportSwizzleNV* pViewportSwizzles; -} VkPipelineViewportSwizzleStateCreateInfoNV; -# 11779 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkDiscardRectangleModeEXT { - VK_DISCARD_RECTANGLE_MODE_INCLUSIVE_EXT = 0, - VK_DISCARD_RECTANGLE_MODE_EXCLUSIVE_EXT = 1, - VK_DISCARD_RECTANGLE_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDiscardRectangleModeEXT; -typedef VkFlags VkPipelineDiscardRectangleStateCreateFlagsEXT; -typedef struct VkPhysicalDeviceDiscardRectanglePropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxDiscardRectangles; -} VkPhysicalDeviceDiscardRectanglePropertiesEXT; - -typedef struct VkPipelineDiscardRectangleStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineDiscardRectangleStateCreateFlagsEXT flags; - VkDiscardRectangleModeEXT discardRectangleMode; - uint32_t discardRectangleCount; - const VkRect2D* pDiscardRectangles; -} VkPipelineDiscardRectangleStateCreateInfoEXT; - -typedef void ( *PFN_vkCmdSetDiscardRectangleEXT)(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles); -typedef void ( *PFN_vkCmdSetDiscardRectangleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable); -typedef void ( *PFN_vkCmdSetDiscardRectangleModeEXT)(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode); -# 11826 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkConservativeRasterizationModeEXT { - VK_CONSERVATIVE_RASTERIZATION_MODE_DISABLED_EXT = 0, - VK_CONSERVATIVE_RASTERIZATION_MODE_OVERESTIMATE_EXT = 1, - VK_CONSERVATIVE_RASTERIZATION_MODE_UNDERESTIMATE_EXT = 2, - VK_CONSERVATIVE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkConservativeRasterizationModeEXT; -typedef VkFlags VkPipelineRasterizationConservativeStateCreateFlagsEXT; -typedef struct VkPhysicalDeviceConservativeRasterizationPropertiesEXT { - VkStructureType sType; - void* pNext; - float primitiveOverestimationSize; - float maxExtraPrimitiveOverestimationSize; - float extraPrimitiveOverestimationSizeGranularity; - VkBool32 primitiveUnderestimation; - VkBool32 conservativePointAndLineRasterization; - VkBool32 degenerateTrianglesRasterized; - VkBool32 degenerateLinesRasterized; - VkBool32 fullyCoveredFragmentShaderInputVariable; - VkBool32 conservativeRasterizationPostDepthCoverage; -} VkPhysicalDeviceConservativeRasterizationPropertiesEXT; - -typedef struct VkPipelineRasterizationConservativeStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationConservativeStateCreateFlagsEXT flags; - VkConservativeRasterizationModeEXT conservativeRasterizationMode; - float extraPrimitiveOverestimationSize; -} VkPipelineRasterizationConservativeStateCreateInfoEXT; - - - - - - - -typedef VkFlags VkPipelineRasterizationDepthClipStateCreateFlagsEXT; -typedef struct VkPhysicalDeviceDepthClipEnableFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 depthClipEnable; -} VkPhysicalDeviceDepthClipEnableFeaturesEXT; - -typedef struct VkPipelineRasterizationDepthClipStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPipelineRasterizationDepthClipStateCreateFlagsEXT flags; - VkBool32 depthClipEnable; -} VkPipelineRasterizationDepthClipStateCreateInfoEXT; -# 11887 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkXYColorEXT { - float x; - float y; -} VkXYColorEXT; - -typedef struct VkHdrMetadataEXT { - VkStructureType sType; - const void* pNext; - VkXYColorEXT displayPrimaryRed; - VkXYColorEXT displayPrimaryGreen; - VkXYColorEXT displayPrimaryBlue; - VkXYColorEXT whitePoint; - float maxLuminance; - float minLuminance; - float maxContentLightLevel; - float maxFrameAverageLightLevel; -} VkHdrMetadataEXT; - -typedef void ( *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata); -# 11931 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkDebugUtilsMessengerEXT_T *VkDebugUtilsMessengerEXT; - - -typedef VkFlags VkDebugUtilsMessengerCallbackDataFlagsEXT; - -typedef enum VkDebugUtilsMessageSeverityFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT = 0x00000010, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT = 0x00000100, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT = 0x00001000, - VK_DEBUG_UTILS_MESSAGE_SEVERITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugUtilsMessageSeverityFlagBitsEXT; - -typedef enum VkDebugUtilsMessageTypeFlagBitsEXT { - VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT = 0x00000001, - VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT = 0x00000002, - VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT = 0x00000004, - VK_DEBUG_UTILS_MESSAGE_TYPE_DEVICE_ADDRESS_BINDING_BIT_EXT = 0x00000008, - VK_DEBUG_UTILS_MESSAGE_TYPE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDebugUtilsMessageTypeFlagBitsEXT; -typedef VkFlags VkDebugUtilsMessageTypeFlagsEXT; -typedef VkFlags VkDebugUtilsMessageSeverityFlagsEXT; -typedef VkFlags VkDebugUtilsMessengerCreateFlagsEXT; -typedef struct VkDebugUtilsLabelEXT { - VkStructureType sType; - const void* pNext; - const char* pLabelName; - float color[4]; -} VkDebugUtilsLabelEXT; - -typedef struct VkDebugUtilsObjectNameInfoEXT { - VkStructureType sType; - const void* pNext; - VkObjectType objectType; - uint64_t objectHandle; - const char* pObjectName; -} VkDebugUtilsObjectNameInfoEXT; - -typedef struct VkDebugUtilsMessengerCallbackDataEXT { - VkStructureType sType; - const void* pNext; - VkDebugUtilsMessengerCallbackDataFlagsEXT flags; - const char* pMessageIdName; - int32_t messageIdNumber; - const char* pMessage; - uint32_t queueLabelCount; - const VkDebugUtilsLabelEXT* pQueueLabels; - uint32_t cmdBufLabelCount; - const VkDebugUtilsLabelEXT* pCmdBufLabels; - uint32_t objectCount; - const VkDebugUtilsObjectNameInfoEXT* pObjects; -} VkDebugUtilsMessengerCallbackDataEXT; - -typedef VkBool32 ( *PFN_vkDebugUtilsMessengerCallbackEXT)( - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void* pUserData); - -typedef struct VkDebugUtilsMessengerCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDebugUtilsMessengerCreateFlagsEXT flags; - VkDebugUtilsMessageSeverityFlagsEXT messageSeverity; - VkDebugUtilsMessageTypeFlagsEXT messageType; - PFN_vkDebugUtilsMessengerCallbackEXT pfnUserCallback; - void* pUserData; -} VkDebugUtilsMessengerCreateInfoEXT; - -typedef struct VkDebugUtilsObjectTagInfoEXT { - VkStructureType sType; - const void* pNext; - VkObjectType objectType; - uint64_t objectHandle; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkDebugUtilsObjectTagInfoEXT; - -typedef VkResult ( *PFN_vkSetDebugUtilsObjectNameEXT)(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo); -typedef VkResult ( *PFN_vkSetDebugUtilsObjectTagEXT)(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo); -typedef void ( *PFN_vkQueueBeginDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void ( *PFN_vkQueueEndDebugUtilsLabelEXT)(VkQueue queue); -typedef void ( *PFN_vkQueueInsertDebugUtilsLabelEXT)(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void ( *PFN_vkCmdBeginDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef void ( *PFN_vkCmdEndDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer); -typedef void ( *PFN_vkCmdInsertDebugUtilsLabelEXT)(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo); -typedef VkResult ( *PFN_vkCreateDebugUtilsMessengerEXT)(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger); -typedef void ( *PFN_vkDestroyDebugUtilsMessengerEXT)(VkInstance instance, VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkSubmitDebugUtilsMessageEXT)(VkInstance instance, VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); -# 12076 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkSamplerReductionMode VkSamplerReductionModeEXT; - -typedef VkSamplerReductionModeCreateInfo VkSamplerReductionModeCreateInfoEXT; - -typedef VkPhysicalDeviceSamplerFilterMinmaxProperties VkPhysicalDeviceSamplerFilterMinmaxPropertiesEXT; -# 12106 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceInlineUniformBlockFeatures VkPhysicalDeviceInlineUniformBlockFeaturesEXT; - -typedef VkPhysicalDeviceInlineUniformBlockProperties VkPhysicalDeviceInlineUniformBlockPropertiesEXT; - -typedef VkWriteDescriptorSetInlineUniformBlock VkWriteDescriptorSetInlineUniformBlockEXT; - -typedef VkDescriptorPoolInlineUniformBlockCreateInfo VkDescriptorPoolInlineUniformBlockCreateInfoEXT; -# 12126 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkSampleLocationEXT { - float x; - float y; -} VkSampleLocationEXT; - -typedef struct VkSampleLocationsInfoEXT { - VkStructureType sType; - const void* pNext; - VkSampleCountFlagBits sampleLocationsPerPixel; - VkExtent2D sampleLocationGridSize; - uint32_t sampleLocationsCount; - const VkSampleLocationEXT* pSampleLocations; -} VkSampleLocationsInfoEXT; - -typedef struct VkAttachmentSampleLocationsEXT { - uint32_t attachmentIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkAttachmentSampleLocationsEXT; - -typedef struct VkSubpassSampleLocationsEXT { - uint32_t subpassIndex; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkSubpassSampleLocationsEXT; - -typedef struct VkRenderPassSampleLocationsBeginInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t attachmentInitialSampleLocationsCount; - const VkAttachmentSampleLocationsEXT* pAttachmentInitialSampleLocations; - uint32_t postSubpassSampleLocationsCount; - const VkSubpassSampleLocationsEXT* pPostSubpassSampleLocations; -} VkRenderPassSampleLocationsBeginInfoEXT; - -typedef struct VkPipelineSampleLocationsStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 sampleLocationsEnable; - VkSampleLocationsInfoEXT sampleLocationsInfo; -} VkPipelineSampleLocationsStateCreateInfoEXT; - -typedef struct VkPhysicalDeviceSampleLocationsPropertiesEXT { - VkStructureType sType; - void* pNext; - VkSampleCountFlags sampleLocationSampleCounts; - VkExtent2D maxSampleLocationGridSize; - float sampleLocationCoordinateRange[2]; - uint32_t sampleLocationSubPixelBits; - VkBool32 variableSampleLocations; -} VkPhysicalDeviceSampleLocationsPropertiesEXT; - -typedef struct VkMultisamplePropertiesEXT { - VkStructureType sType; - void* pNext; - VkExtent2D maxSampleLocationGridSize; -} VkMultisamplePropertiesEXT; - -typedef void ( *PFN_vkCmdSetSampleLocationsEXT)(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo); -typedef void ( *PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT)(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties); -# 12202 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkBlendOverlapEXT { - VK_BLEND_OVERLAP_UNCORRELATED_EXT = 0, - VK_BLEND_OVERLAP_DISJOINT_EXT = 1, - VK_BLEND_OVERLAP_CONJOINT_EXT = 2, - VK_BLEND_OVERLAP_MAX_ENUM_EXT = 0x7FFFFFFF -} VkBlendOverlapEXT; -typedef struct VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 advancedBlendCoherentOperations; -} VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT; - -typedef struct VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t advancedBlendMaxColorAttachments; - VkBool32 advancedBlendIndependentBlend; - VkBool32 advancedBlendNonPremultipliedSrcColor; - VkBool32 advancedBlendNonPremultipliedDstColor; - VkBool32 advancedBlendCorrelatedOverlap; - VkBool32 advancedBlendAllOperations; -} VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT; - -typedef struct VkPipelineColorBlendAdvancedStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 srcPremultiplied; - VkBool32 dstPremultiplied; - VkBlendOverlapEXT blendOverlap; -} VkPipelineColorBlendAdvancedStateCreateInfoEXT; - - - - - - - -typedef VkFlags VkPipelineCoverageToColorStateCreateFlagsNV; -typedef struct VkPipelineCoverageToColorStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageToColorStateCreateFlagsNV flags; - VkBool32 coverageToColorEnable; - uint32_t coverageToColorLocation; -} VkPipelineCoverageToColorStateCreateInfoNV; -# 12255 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkCoverageModulationModeNV { - VK_COVERAGE_MODULATION_MODE_NONE_NV = 0, - VK_COVERAGE_MODULATION_MODE_RGB_NV = 1, - VK_COVERAGE_MODULATION_MODE_ALPHA_NV = 2, - VK_COVERAGE_MODULATION_MODE_RGBA_NV = 3, - VK_COVERAGE_MODULATION_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoverageModulationModeNV; -typedef VkFlags VkPipelineCoverageModulationStateCreateFlagsNV; -typedef struct VkPipelineCoverageModulationStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageModulationStateCreateFlagsNV flags; - VkCoverageModulationModeNV coverageModulationMode; - VkBool32 coverageModulationTableEnable; - uint32_t coverageModulationTableCount; - const float* pCoverageModulationTable; -} VkPipelineCoverageModulationStateCreateInfoNV; -# 12285 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceShaderSMBuiltinsPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t shaderSMCount; - uint32_t shaderWarpsPerSM; -} VkPhysicalDeviceShaderSMBuiltinsPropertiesNV; - -typedef struct VkPhysicalDeviceShaderSMBuiltinsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 shaderSMBuiltins; -} VkPhysicalDeviceShaderSMBuiltinsFeaturesNV; -# 12310 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkDrmFormatModifierPropertiesEXT { - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - VkFormatFeatureFlags drmFormatModifierTilingFeatures; -} VkDrmFormatModifierPropertiesEXT; - -typedef struct VkDrmFormatModifierPropertiesListEXT { - VkStructureType sType; - void* pNext; - uint32_t drmFormatModifierCount; - VkDrmFormatModifierPropertiesEXT* pDrmFormatModifierProperties; -} VkDrmFormatModifierPropertiesListEXT; - -typedef struct VkPhysicalDeviceImageDrmFormatModifierInfoEXT { - VkStructureType sType; - const void* pNext; - uint64_t drmFormatModifier; - VkSharingMode sharingMode; - uint32_t queueFamilyIndexCount; - const uint32_t* pQueueFamilyIndices; -} VkPhysicalDeviceImageDrmFormatModifierInfoEXT; - -typedef struct VkImageDrmFormatModifierListCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t drmFormatModifierCount; - const uint64_t* pDrmFormatModifiers; -} VkImageDrmFormatModifierListCreateInfoEXT; - -typedef struct VkImageDrmFormatModifierExplicitCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - const VkSubresourceLayout* pPlaneLayouts; -} VkImageDrmFormatModifierExplicitCreateInfoEXT; - -typedef struct VkImageDrmFormatModifierPropertiesEXT { - VkStructureType sType; - void* pNext; - uint64_t drmFormatModifier; -} VkImageDrmFormatModifierPropertiesEXT; - -typedef struct VkDrmFormatModifierProperties2EXT { - uint64_t drmFormatModifier; - uint32_t drmFormatModifierPlaneCount; - VkFormatFeatureFlags2 drmFormatModifierTilingFeatures; -} VkDrmFormatModifierProperties2EXT; - -typedef struct VkDrmFormatModifierPropertiesList2EXT { - VkStructureType sType; - void* pNext; - uint32_t drmFormatModifierCount; - VkDrmFormatModifierProperties2EXT* pDrmFormatModifierProperties; -} VkDrmFormatModifierPropertiesList2EXT; - -typedef VkResult ( *PFN_vkGetImageDrmFormatModifierPropertiesEXT)(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties); -# 12378 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkValidationCacheEXT_T *VkValidationCacheEXT; - - - -typedef enum VkValidationCacheHeaderVersionEXT { - VK_VALIDATION_CACHE_HEADER_VERSION_ONE_EXT = 1, - VK_VALIDATION_CACHE_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationCacheHeaderVersionEXT; -typedef VkFlags VkValidationCacheCreateFlagsEXT; -typedef struct VkValidationCacheCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkValidationCacheCreateFlagsEXT flags; - size_t initialDataSize; - const void* pInitialData; -} VkValidationCacheCreateInfoEXT; - -typedef struct VkShaderModuleValidationCacheCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkValidationCacheEXT validationCache; -} VkShaderModuleValidationCacheCreateInfoEXT; - -typedef VkResult ( *PFN_vkCreateValidationCacheEXT)(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache); -typedef void ( *PFN_vkDestroyValidationCacheEXT)(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkMergeValidationCachesEXT)(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches); -typedef VkResult ( *PFN_vkGetValidationCacheDataEXT)(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData); -# 12436 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkDescriptorBindingFlagBits VkDescriptorBindingFlagBitsEXT; - -typedef VkDescriptorBindingFlags VkDescriptorBindingFlagsEXT; - -typedef VkDescriptorSetLayoutBindingFlagsCreateInfo VkDescriptorSetLayoutBindingFlagsCreateInfoEXT; - -typedef VkPhysicalDeviceDescriptorIndexingFeatures VkPhysicalDeviceDescriptorIndexingFeaturesEXT; - -typedef VkPhysicalDeviceDescriptorIndexingProperties VkPhysicalDeviceDescriptorIndexingPropertiesEXT; - -typedef VkDescriptorSetVariableDescriptorCountAllocateInfo VkDescriptorSetVariableDescriptorCountAllocateInfoEXT; - -typedef VkDescriptorSetVariableDescriptorCountLayoutSupport VkDescriptorSetVariableDescriptorCountLayoutSupportEXT; -# 12463 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkShadingRatePaletteEntryNV { - VK_SHADING_RATE_PALETTE_ENTRY_NO_INVOCATIONS_NV = 0, - VK_SHADING_RATE_PALETTE_ENTRY_16_INVOCATIONS_PER_PIXEL_NV = 1, - VK_SHADING_RATE_PALETTE_ENTRY_8_INVOCATIONS_PER_PIXEL_NV = 2, - VK_SHADING_RATE_PALETTE_ENTRY_4_INVOCATIONS_PER_PIXEL_NV = 3, - VK_SHADING_RATE_PALETTE_ENTRY_2_INVOCATIONS_PER_PIXEL_NV = 4, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_PIXEL_NV = 5, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X1_PIXELS_NV = 6, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_1X2_PIXELS_NV = 7, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X2_PIXELS_NV = 8, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X2_PIXELS_NV = 9, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_2X4_PIXELS_NV = 10, - VK_SHADING_RATE_PALETTE_ENTRY_1_INVOCATION_PER_4X4_PIXELS_NV = 11, - VK_SHADING_RATE_PALETTE_ENTRY_MAX_ENUM_NV = 0x7FFFFFFF -} VkShadingRatePaletteEntryNV; - -typedef enum VkCoarseSampleOrderTypeNV { - VK_COARSE_SAMPLE_ORDER_TYPE_DEFAULT_NV = 0, - VK_COARSE_SAMPLE_ORDER_TYPE_CUSTOM_NV = 1, - VK_COARSE_SAMPLE_ORDER_TYPE_PIXEL_MAJOR_NV = 2, - VK_COARSE_SAMPLE_ORDER_TYPE_SAMPLE_MAJOR_NV = 3, - VK_COARSE_SAMPLE_ORDER_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoarseSampleOrderTypeNV; -typedef struct VkShadingRatePaletteNV { - uint32_t shadingRatePaletteEntryCount; - const VkShadingRatePaletteEntryNV* pShadingRatePaletteEntries; -} VkShadingRatePaletteNV; - -typedef struct VkPipelineViewportShadingRateImageStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 shadingRateImageEnable; - uint32_t viewportCount; - const VkShadingRatePaletteNV* pShadingRatePalettes; -} VkPipelineViewportShadingRateImageStateCreateInfoNV; - -typedef struct VkPhysicalDeviceShadingRateImageFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 shadingRateImage; - VkBool32 shadingRateCoarseSampleOrder; -} VkPhysicalDeviceShadingRateImageFeaturesNV; - -typedef struct VkPhysicalDeviceShadingRateImagePropertiesNV { - VkStructureType sType; - void* pNext; - VkExtent2D shadingRateTexelSize; - uint32_t shadingRatePaletteSize; - uint32_t shadingRateMaxCoarseSamples; -} VkPhysicalDeviceShadingRateImagePropertiesNV; - -typedef struct VkCoarseSampleLocationNV { - uint32_t pixelX; - uint32_t pixelY; - uint32_t sample; -} VkCoarseSampleLocationNV; - -typedef struct VkCoarseSampleOrderCustomNV { - VkShadingRatePaletteEntryNV shadingRate; - uint32_t sampleCount; - uint32_t sampleLocationCount; - const VkCoarseSampleLocationNV* pSampleLocations; -} VkCoarseSampleOrderCustomNV; - -typedef struct VkPipelineViewportCoarseSampleOrderStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkCoarseSampleOrderTypeNV sampleOrderType; - uint32_t customSampleOrderCount; - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders; -} VkPipelineViewportCoarseSampleOrderStateCreateInfoNV; - -typedef void ( *PFN_vkCmdBindShadingRateImageNV)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); -typedef void ( *PFN_vkCmdSetViewportShadingRatePaletteNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes); -typedef void ( *PFN_vkCmdSetCoarseSampleOrderNV)(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); -# 12561 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkAccelerationStructureNV_T *VkAccelerationStructureNV; - - - - - -typedef enum VkRayTracingShaderGroupTypeKHR { - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR = 0, - VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR = 1, - VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR = 2, - VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_GENERAL_KHR, - VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_TRIANGLES_HIT_GROUP_KHR, - VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_NV = VK_RAY_TRACING_SHADER_GROUP_TYPE_PROCEDURAL_HIT_GROUP_KHR, - VK_RAY_TRACING_SHADER_GROUP_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkRayTracingShaderGroupTypeKHR; -typedef VkRayTracingShaderGroupTypeKHR VkRayTracingShaderGroupTypeNV; - - -typedef enum VkGeometryTypeKHR { - VK_GEOMETRY_TYPE_TRIANGLES_KHR = 0, - VK_GEOMETRY_TYPE_AABBS_KHR = 1, - VK_GEOMETRY_TYPE_INSTANCES_KHR = 2, - VK_GEOMETRY_TYPE_TRIANGLES_NV = VK_GEOMETRY_TYPE_TRIANGLES_KHR, - VK_GEOMETRY_TYPE_AABBS_NV = VK_GEOMETRY_TYPE_AABBS_KHR, - VK_GEOMETRY_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkGeometryTypeKHR; -typedef VkGeometryTypeKHR VkGeometryTypeNV; - - -typedef enum VkAccelerationStructureTypeKHR { - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR = 0, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR = 1, - VK_ACCELERATION_STRUCTURE_TYPE_GENERIC_KHR = 2, - VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_TOP_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_NV = VK_ACCELERATION_STRUCTURE_TYPE_BOTTOM_LEVEL_KHR, - VK_ACCELERATION_STRUCTURE_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureTypeKHR; -typedef VkAccelerationStructureTypeKHR VkAccelerationStructureTypeNV; - - -typedef enum VkCopyAccelerationStructureModeKHR { - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR = 0, - VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR = 1, - VK_COPY_ACCELERATION_STRUCTURE_MODE_SERIALIZE_KHR = 2, - VK_COPY_ACCELERATION_STRUCTURE_MODE_DESERIALIZE_KHR = 3, - VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_CLONE_KHR, - VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_NV = VK_COPY_ACCELERATION_STRUCTURE_MODE_COMPACT_KHR, - VK_COPY_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkCopyAccelerationStructureModeKHR; -typedef VkCopyAccelerationStructureModeKHR VkCopyAccelerationStructureModeNV; - - -typedef enum VkAccelerationStructureMemoryRequirementsTypeNV { - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_OBJECT_NV = 0, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_BUILD_SCRATCH_NV = 1, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_UPDATE_SCRATCH_NV = 2, - VK_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkAccelerationStructureMemoryRequirementsTypeNV; - -typedef enum VkGeometryFlagBitsKHR { - VK_GEOMETRY_OPAQUE_BIT_KHR = 0x00000001, - VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR = 0x00000002, - VK_GEOMETRY_OPAQUE_BIT_NV = VK_GEOMETRY_OPAQUE_BIT_KHR, - VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_NV = VK_GEOMETRY_NO_DUPLICATE_ANY_HIT_INVOCATION_BIT_KHR, - VK_GEOMETRY_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkGeometryFlagBitsKHR; -typedef VkFlags VkGeometryFlagsKHR; -typedef VkGeometryFlagsKHR VkGeometryFlagsNV; - -typedef VkGeometryFlagBitsKHR VkGeometryFlagBitsNV; - - -typedef enum VkGeometryInstanceFlagBitsKHR { - VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR = 0x00000001, - VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR = 0x00000002, - VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR = 0x00000004, - VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR = 0x00000008, - VK_GEOMETRY_INSTANCE_FORCE_OPACITY_MICROMAP_2_STATE_EXT = 0x00000010, - VK_GEOMETRY_INSTANCE_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000020, - VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR = VK_GEOMETRY_INSTANCE_TRIANGLE_FLIP_FACING_BIT_KHR, - VK_GEOMETRY_INSTANCE_TRIANGLE_CULL_DISABLE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FACING_CULL_DISABLE_BIT_KHR, - VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_NV = VK_GEOMETRY_INSTANCE_TRIANGLE_FRONT_COUNTERCLOCKWISE_BIT_KHR, - VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_OPAQUE_BIT_KHR, - VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_NV = VK_GEOMETRY_INSTANCE_FORCE_NO_OPAQUE_BIT_KHR, - VK_GEOMETRY_INSTANCE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkGeometryInstanceFlagBitsKHR; -typedef VkFlags VkGeometryInstanceFlagsKHR; -typedef VkGeometryInstanceFlagsKHR VkGeometryInstanceFlagsNV; - -typedef VkGeometryInstanceFlagBitsKHR VkGeometryInstanceFlagBitsNV; - - -typedef enum VkBuildAccelerationStructureFlagBitsKHR { - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR = 0x00000001, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR = 0x00000002, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR = 0x00000004, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR = 0x00000008, - VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR = 0x00000010, - VK_BUILD_ACCELERATION_STRUCTURE_MOTION_BIT_NV = 0x00000020, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_UPDATE_EXT = 0x00000040, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DISABLE_OPACITY_MICROMAPS_EXT = 0x00000080, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_OPACITY_MICROMAP_DATA_UPDATE_EXT = 0x00000100, - - - - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_DATA_ACCESS_KHR = 0x00000800, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_UPDATE_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_ALLOW_COMPACTION_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_TRACE_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_PREFER_FAST_BUILD_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_NV = VK_BUILD_ACCELERATION_STRUCTURE_LOW_MEMORY_BIT_KHR, - VK_BUILD_ACCELERATION_STRUCTURE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkBuildAccelerationStructureFlagBitsKHR; -typedef VkFlags VkBuildAccelerationStructureFlagsKHR; -typedef VkBuildAccelerationStructureFlagsKHR VkBuildAccelerationStructureFlagsNV; - -typedef VkBuildAccelerationStructureFlagBitsKHR VkBuildAccelerationStructureFlagBitsNV; - -typedef struct VkRayTracingShaderGroupCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkRayTracingShaderGroupTypeKHR type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; -} VkRayTracingShaderGroupCreateInfoNV; - -typedef struct VkRayTracingPipelineCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - uint32_t groupCount; - const VkRayTracingShaderGroupCreateInfoNV* pGroups; - uint32_t maxRecursionDepth; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkRayTracingPipelineCreateInfoNV; - -typedef struct VkGeometryTrianglesNV { - VkStructureType sType; - const void* pNext; - VkBuffer vertexData; - VkDeviceSize vertexOffset; - uint32_t vertexCount; - VkDeviceSize vertexStride; - VkFormat vertexFormat; - VkBuffer indexData; - VkDeviceSize indexOffset; - uint32_t indexCount; - VkIndexType indexType; - VkBuffer transformData; - VkDeviceSize transformOffset; -} VkGeometryTrianglesNV; - -typedef struct VkGeometryAABBNV { - VkStructureType sType; - const void* pNext; - VkBuffer aabbData; - uint32_t numAABBs; - uint32_t stride; - VkDeviceSize offset; -} VkGeometryAABBNV; - -typedef struct VkGeometryDataNV { - VkGeometryTrianglesNV triangles; - VkGeometryAABBNV aabbs; -} VkGeometryDataNV; - -typedef struct VkGeometryNV { - VkStructureType sType; - const void* pNext; - VkGeometryTypeKHR geometryType; - VkGeometryDataNV geometry; - VkGeometryFlagsKHR flags; -} VkGeometryNV; - -typedef struct VkAccelerationStructureInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureTypeNV type; - VkBuildAccelerationStructureFlagsNV flags; - uint32_t instanceCount; - uint32_t geometryCount; - const VkGeometryNV* pGeometries; -} VkAccelerationStructureInfoNV; - -typedef struct VkAccelerationStructureCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceSize compactedSize; - VkAccelerationStructureInfoNV info; -} VkAccelerationStructureCreateInfoNV; - -typedef struct VkBindAccelerationStructureMemoryInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureNV accelerationStructure; - VkDeviceMemory memory; - VkDeviceSize memoryOffset; - uint32_t deviceIndexCount; - const uint32_t* pDeviceIndices; -} VkBindAccelerationStructureMemoryInfoNV; - -typedef struct VkWriteDescriptorSetAccelerationStructureNV { - VkStructureType sType; - const void* pNext; - uint32_t accelerationStructureCount; - const VkAccelerationStructureNV* pAccelerationStructures; -} VkWriteDescriptorSetAccelerationStructureNV; - -typedef struct VkAccelerationStructureMemoryRequirementsInfoNV { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureMemoryRequirementsTypeNV type; - VkAccelerationStructureNV accelerationStructure; -} VkAccelerationStructureMemoryRequirementsInfoNV; - -typedef struct VkPhysicalDeviceRayTracingPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t shaderGroupHandleSize; - uint32_t maxRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint64_t maxGeometryCount; - uint64_t maxInstanceCount; - uint64_t maxTriangleCount; - uint32_t maxDescriptorSetAccelerationStructures; -} VkPhysicalDeviceRayTracingPropertiesNV; - -typedef struct VkTransformMatrixKHR { - float matrix[3][4]; -} VkTransformMatrixKHR; - -typedef VkTransformMatrixKHR VkTransformMatrixNV; - -typedef struct VkAabbPositionsKHR { - float minX; - float minY; - float minZ; - float maxX; - float maxY; - float maxZ; -} VkAabbPositionsKHR; - -typedef VkAabbPositionsKHR VkAabbPositionsNV; - -typedef struct VkAccelerationStructureInstanceKHR { - VkTransformMatrixKHR transform; - uint32_t instanceCustomIndex:24; - uint32_t mask:8; - uint32_t instanceShaderBindingTableRecordOffset:24; - VkGeometryInstanceFlagsKHR flags:8; - uint64_t accelerationStructureReference; -} VkAccelerationStructureInstanceKHR; - -typedef VkAccelerationStructureInstanceKHR VkAccelerationStructureInstanceNV; - -typedef VkResult ( *PFN_vkCreateAccelerationStructureNV)(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure); -typedef void ( *PFN_vkDestroyAccelerationStructureNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkGetAccelerationStructureMemoryRequirementsNV)(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements); -typedef VkResult ( *PFN_vkBindAccelerationStructureMemoryNV)(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); -typedef void ( *PFN_vkCmdBuildAccelerationStructureNV)(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset); -typedef void ( *PFN_vkCmdCopyAccelerationStructureNV)(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode); -typedef void ( *PFN_vkCmdTraceRaysNV)(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth); -typedef VkResult ( *PFN_vkCreateRayTracingPipelinesNV)(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult ( *PFN_vkGetRayTracingShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef VkResult ( *PFN_vkGetRayTracingShaderGroupHandlesNV)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef VkResult ( *PFN_vkGetAccelerationStructureHandleNV)(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData); -typedef void ( *PFN_vkCmdWriteAccelerationStructuresPropertiesNV)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef VkResult ( *PFN_vkCompileDeferredNV)(VkDevice device, VkPipeline pipeline, uint32_t shader); -# 12942 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 representativeFragmentTest; -} VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV; - -typedef struct VkPipelineRepresentativeFragmentTestStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 representativeFragmentTestEnable; -} VkPipelineRepresentativeFragmentTestStateCreateInfoNV; - - - - - - - -typedef struct VkPhysicalDeviceImageViewImageFormatInfoEXT { - VkStructureType sType; - void* pNext; - VkImageViewType imageViewType; -} VkPhysicalDeviceImageViewImageFormatInfoEXT; - -typedef struct VkFilterCubicImageViewImageFormatPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 filterCubic; - VkBool32 filterCubicMinmax; -} VkFilterCubicImageViewImageFormatPropertiesEXT; -# 12985 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkQueueGlobalPriorityKHR VkQueueGlobalPriorityEXT; - -typedef VkDeviceQueueGlobalPriorityCreateInfoKHR VkDeviceQueueGlobalPriorityCreateInfoEXT; - - - - - - - -typedef struct VkImportMemoryHostPointerInfoEXT { - VkStructureType sType; - const void* pNext; - VkExternalMemoryHandleTypeFlagBits handleType; - void* pHostPointer; -} VkImportMemoryHostPointerInfoEXT; - -typedef struct VkMemoryHostPointerPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t memoryTypeBits; -} VkMemoryHostPointerPropertiesEXT; - -typedef struct VkPhysicalDeviceExternalMemoryHostPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize minImportedHostPointerAlignment; -} VkPhysicalDeviceExternalMemoryHostPropertiesEXT; - -typedef VkResult ( *PFN_vkGetMemoryHostPointerPropertiesEXT)(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); -# 13029 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef void ( *PFN_vkCmdWriteBufferMarkerAMD)(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker); -# 13046 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkPipelineCompilerControlFlagBitsAMD { - VK_PIPELINE_COMPILER_CONTROL_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF -} VkPipelineCompilerControlFlagBitsAMD; -typedef VkFlags VkPipelineCompilerControlFlagsAMD; -typedef struct VkPipelineCompilerControlCreateInfoAMD { - VkStructureType sType; - const void* pNext; - VkPipelineCompilerControlFlagsAMD compilerControlFlags; -} VkPipelineCompilerControlCreateInfoAMD; -# 13063 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkTimeDomainEXT { - VK_TIME_DOMAIN_DEVICE_EXT = 0, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_EXT = 1, - VK_TIME_DOMAIN_CLOCK_MONOTONIC_RAW_EXT = 2, - VK_TIME_DOMAIN_QUERY_PERFORMANCE_COUNTER_EXT = 3, - VK_TIME_DOMAIN_MAX_ENUM_EXT = 0x7FFFFFFF -} VkTimeDomainEXT; -typedef struct VkCalibratedTimestampInfoEXT { - VkStructureType sType; - const void* pNext; - VkTimeDomainEXT timeDomain; -} VkCalibratedTimestampInfoEXT; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT)(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains); -typedef VkResult ( *PFN_vkGetCalibratedTimestampsEXT)(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation); -# 13098 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceShaderCorePropertiesAMD { - VkStructureType sType; - void* pNext; - uint32_t shaderEngineCount; - uint32_t shaderArraysPerEngineCount; - uint32_t computeUnitsPerShaderArray; - uint32_t simdPerComputeUnit; - uint32_t wavefrontsPerSimd; - uint32_t wavefrontSize; - uint32_t sgprsPerSimd; - uint32_t minSgprAllocation; - uint32_t maxSgprAllocation; - uint32_t sgprAllocationGranularity; - uint32_t vgprsPerSimd; - uint32_t minVgprAllocation; - uint32_t maxVgprAllocation; - uint32_t vgprAllocationGranularity; -} VkPhysicalDeviceShaderCorePropertiesAMD; -# 13124 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkMemoryOverallocationBehaviorAMD { - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DEFAULT_AMD = 0, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_ALLOWED_AMD = 1, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_DISALLOWED_AMD = 2, - VK_MEMORY_OVERALLOCATION_BEHAVIOR_MAX_ENUM_AMD = 0x7FFFFFFF -} VkMemoryOverallocationBehaviorAMD; -typedef struct VkDeviceMemoryOverallocationCreateInfoAMD { - VkStructureType sType; - const void* pNext; - VkMemoryOverallocationBehaviorAMD overallocationBehavior; -} VkDeviceMemoryOverallocationCreateInfoAMD; - - - - - - - -typedef struct VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxVertexAttribDivisor; -} VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT; - -typedef struct VkVertexInputBindingDivisorDescriptionEXT { - uint32_t binding; - uint32_t divisor; -} VkVertexInputBindingDivisorDescriptionEXT; - -typedef struct VkPipelineVertexInputDivisorStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t vertexBindingDivisorCount; - const VkVertexInputBindingDivisorDescriptionEXT* pVertexBindingDivisors; -} VkPipelineVertexInputDivisorStateCreateInfoEXT; - -typedef struct VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 vertexAttributeInstanceRateDivisor; - VkBool32 vertexAttributeInstanceRateZeroDivisor; -} VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT; - - - - - - - -typedef VkPipelineCreationFeedbackFlagBits VkPipelineCreationFeedbackFlagBitsEXT; - -typedef VkPipelineCreationFeedbackFlags VkPipelineCreationFeedbackFlagsEXT; - -typedef VkPipelineCreationFeedbackCreateInfo VkPipelineCreationFeedbackCreateInfoEXT; - -typedef VkPipelineCreationFeedback VkPipelineCreationFeedbackEXT; -# 13193 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceComputeShaderDerivativesFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 computeDerivativeGroupQuads; - VkBool32 computeDerivativeGroupLinear; -} VkPhysicalDeviceComputeShaderDerivativesFeaturesNV; - - - - - - - -typedef struct VkPhysicalDeviceMeshShaderFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 taskShader; - VkBool32 meshShader; -} VkPhysicalDeviceMeshShaderFeaturesNV; - -typedef struct VkPhysicalDeviceMeshShaderPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxDrawMeshTasksCount; - uint32_t maxTaskWorkGroupInvocations; - uint32_t maxTaskWorkGroupSize[3]; - uint32_t maxTaskTotalMemorySize; - uint32_t maxTaskOutputCount; - uint32_t maxMeshWorkGroupInvocations; - uint32_t maxMeshWorkGroupSize[3]; - uint32_t maxMeshTotalMemorySize; - uint32_t maxMeshOutputVertices; - uint32_t maxMeshOutputPrimitives; - uint32_t maxMeshMultiviewViewCount; - uint32_t meshOutputPerVertexGranularity; - uint32_t meshOutputPerPrimitiveGranularity; -} VkPhysicalDeviceMeshShaderPropertiesNV; - -typedef struct VkDrawMeshTasksIndirectCommandNV { - uint32_t taskCount; - uint32_t firstTask; -} VkDrawMeshTasksIndirectCommandNV; - -typedef void ( *PFN_vkCmdDrawMeshTasksNV)(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask); -typedef void ( *PFN_vkCmdDrawMeshTasksIndirectNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void ( *PFN_vkCmdDrawMeshTasksIndirectCountNV)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -# 13268 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV; - - - - - - - -typedef struct VkPhysicalDeviceShaderImageFootprintFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 imageFootprint; -} VkPhysicalDeviceShaderImageFootprintFeaturesNV; - - - - - - - -typedef struct VkPipelineViewportExclusiveScissorStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t exclusiveScissorCount; - const VkRect2D* pExclusiveScissors; -} VkPipelineViewportExclusiveScissorStateCreateInfoNV; - -typedef struct VkPhysicalDeviceExclusiveScissorFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 exclusiveScissor; -} VkPhysicalDeviceExclusiveScissorFeaturesNV; - -typedef void ( *PFN_vkCmdSetExclusiveScissorEnableNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables); -typedef void ( *PFN_vkCmdSetExclusiveScissorNV)(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors); -# 13323 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkQueueFamilyCheckpointPropertiesNV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlags checkpointExecutionStageMask; -} VkQueueFamilyCheckpointPropertiesNV; - -typedef struct VkCheckpointDataNV { - VkStructureType sType; - void* pNext; - VkPipelineStageFlagBits stage; - void* pCheckpointMarker; -} VkCheckpointDataNV; - -typedef void ( *PFN_vkCmdSetCheckpointNV)(VkCommandBuffer commandBuffer, const void* pCheckpointMarker); -typedef void ( *PFN_vkGetQueueCheckpointDataNV)(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData); -# 13355 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL { - VkStructureType sType; - void* pNext; - VkBool32 shaderIntegerFunctions2; -} VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL; - - - - - -typedef struct VkPerformanceConfigurationINTEL_T *VkPerformanceConfigurationINTEL; - - - -typedef enum VkPerformanceConfigurationTypeINTEL { - VK_PERFORMANCE_CONFIGURATION_TYPE_COMMAND_QUEUE_METRICS_DISCOVERY_ACTIVATED_INTEL = 0, - VK_PERFORMANCE_CONFIGURATION_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceConfigurationTypeINTEL; - -typedef enum VkQueryPoolSamplingModeINTEL { - VK_QUERY_POOL_SAMPLING_MODE_MANUAL_INTEL = 0, - VK_QUERY_POOL_SAMPLING_MODE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkQueryPoolSamplingModeINTEL; - -typedef enum VkPerformanceOverrideTypeINTEL { - VK_PERFORMANCE_OVERRIDE_TYPE_NULL_HARDWARE_INTEL = 0, - VK_PERFORMANCE_OVERRIDE_TYPE_FLUSH_GPU_CACHES_INTEL = 1, - VK_PERFORMANCE_OVERRIDE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceOverrideTypeINTEL; - -typedef enum VkPerformanceParameterTypeINTEL { - VK_PERFORMANCE_PARAMETER_TYPE_HW_COUNTERS_SUPPORTED_INTEL = 0, - VK_PERFORMANCE_PARAMETER_TYPE_STREAM_MARKER_VALID_BITS_INTEL = 1, - VK_PERFORMANCE_PARAMETER_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceParameterTypeINTEL; - -typedef enum VkPerformanceValueTypeINTEL { - VK_PERFORMANCE_VALUE_TYPE_UINT32_INTEL = 0, - VK_PERFORMANCE_VALUE_TYPE_UINT64_INTEL = 1, - VK_PERFORMANCE_VALUE_TYPE_FLOAT_INTEL = 2, - VK_PERFORMANCE_VALUE_TYPE_BOOL_INTEL = 3, - VK_PERFORMANCE_VALUE_TYPE_STRING_INTEL = 4, - VK_PERFORMANCE_VALUE_TYPE_MAX_ENUM_INTEL = 0x7FFFFFFF -} VkPerformanceValueTypeINTEL; -typedef union VkPerformanceValueDataINTEL { - uint32_t value32; - uint64_t value64; - float valueFloat; - VkBool32 valueBool; - const char* valueString; -} VkPerformanceValueDataINTEL; - -typedef struct VkPerformanceValueINTEL { - VkPerformanceValueTypeINTEL type; - VkPerformanceValueDataINTEL data; -} VkPerformanceValueINTEL; - -typedef struct VkInitializePerformanceApiInfoINTEL { - VkStructureType sType; - const void* pNext; - void* pUserData; -} VkInitializePerformanceApiInfoINTEL; - -typedef struct VkQueryPoolPerformanceQueryCreateInfoINTEL { - VkStructureType sType; - const void* pNext; - VkQueryPoolSamplingModeINTEL performanceCountersSampling; -} VkQueryPoolPerformanceQueryCreateInfoINTEL; - -typedef VkQueryPoolPerformanceQueryCreateInfoINTEL VkQueryPoolCreateInfoINTEL; - -typedef struct VkPerformanceMarkerInfoINTEL { - VkStructureType sType; - const void* pNext; - uint64_t marker; -} VkPerformanceMarkerInfoINTEL; - -typedef struct VkPerformanceStreamMarkerInfoINTEL { - VkStructureType sType; - const void* pNext; - uint32_t marker; -} VkPerformanceStreamMarkerInfoINTEL; - -typedef struct VkPerformanceOverrideInfoINTEL { - VkStructureType sType; - const void* pNext; - VkPerformanceOverrideTypeINTEL type; - VkBool32 enable; - uint64_t parameter; -} VkPerformanceOverrideInfoINTEL; - -typedef struct VkPerformanceConfigurationAcquireInfoINTEL { - VkStructureType sType; - const void* pNext; - VkPerformanceConfigurationTypeINTEL type; -} VkPerformanceConfigurationAcquireInfoINTEL; - -typedef VkResult ( *PFN_vkInitializePerformanceApiINTEL)(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); -typedef void ( *PFN_vkUninitializePerformanceApiINTEL)(VkDevice device); -typedef VkResult ( *PFN_vkCmdSetPerformanceMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo); -typedef VkResult ( *PFN_vkCmdSetPerformanceStreamMarkerINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); -typedef VkResult ( *PFN_vkCmdSetPerformanceOverrideINTEL)(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo); -typedef VkResult ( *PFN_vkAcquirePerformanceConfigurationINTEL)(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration); -typedef VkResult ( *PFN_vkReleasePerformanceConfigurationINTEL)(VkDevice device, VkPerformanceConfigurationINTEL configuration); -typedef VkResult ( *PFN_vkQueueSetPerformanceConfigurationINTEL)(VkQueue queue, VkPerformanceConfigurationINTEL configuration); -typedef VkResult ( *PFN_vkGetPerformanceParameterINTEL)(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue); -# 13506 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDevicePCIBusInfoPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t pciDomain; - uint32_t pciBus; - uint32_t pciDevice; - uint32_t pciFunction; -} VkPhysicalDevicePCIBusInfoPropertiesEXT; - - - - - - - -typedef struct VkDisplayNativeHdrSurfaceCapabilitiesAMD { - VkStructureType sType; - void* pNext; - VkBool32 localDimmingSupport; -} VkDisplayNativeHdrSurfaceCapabilitiesAMD; - -typedef struct VkSwapchainDisplayNativeHdrCreateInfoAMD { - VkStructureType sType; - const void* pNext; - VkBool32 localDimmingEnable; -} VkSwapchainDisplayNativeHdrCreateInfoAMD; - -typedef void ( *PFN_vkSetLocalDimmingAMD)(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable); -# 13547 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceFragmentDensityMapFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentDensityMap; - VkBool32 fragmentDensityMapDynamic; - VkBool32 fragmentDensityMapNonSubsampledImages; -} VkPhysicalDeviceFragmentDensityMapFeaturesEXT; - -typedef struct VkPhysicalDeviceFragmentDensityMapPropertiesEXT { - VkStructureType sType; - void* pNext; - VkExtent2D minFragmentDensityTexelSize; - VkExtent2D maxFragmentDensityTexelSize; - VkBool32 fragmentDensityInvocations; -} VkPhysicalDeviceFragmentDensityMapPropertiesEXT; - -typedef struct VkRenderPassFragmentDensityMapCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkAttachmentReference fragmentDensityMapAttachment; -} VkRenderPassFragmentDensityMapCreateInfoEXT; - - - - - - - -typedef VkPhysicalDeviceScalarBlockLayoutFeatures VkPhysicalDeviceScalarBlockLayoutFeaturesEXT; -# 13597 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceSubgroupSizeControlFeatures VkPhysicalDeviceSubgroupSizeControlFeaturesEXT; - -typedef VkPhysicalDeviceSubgroupSizeControlProperties VkPhysicalDeviceSubgroupSizeControlPropertiesEXT; - -typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkPipelineShaderStageRequiredSubgroupSizeCreateInfoEXT; -# 13610 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkShaderCorePropertiesFlagBitsAMD { - VK_SHADER_CORE_PROPERTIES_FLAG_BITS_MAX_ENUM_AMD = 0x7FFFFFFF -} VkShaderCorePropertiesFlagBitsAMD; -typedef VkFlags VkShaderCorePropertiesFlagsAMD; -typedef struct VkPhysicalDeviceShaderCoreProperties2AMD { - VkStructureType sType; - void* pNext; - VkShaderCorePropertiesFlagsAMD shaderCoreFeatures; - uint32_t activeComputeUnitCount; -} VkPhysicalDeviceShaderCoreProperties2AMD; - - - - - - - -typedef struct VkPhysicalDeviceCoherentMemoryFeaturesAMD { - VkStructureType sType; - void* pNext; - VkBool32 deviceCoherentMemory; -} VkPhysicalDeviceCoherentMemoryFeaturesAMD; - - - - - - - -typedef struct VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderImageInt64Atomics; - VkBool32 sparseImageInt64Atomics; -} VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT; - - - - - - - -typedef struct VkPhysicalDeviceMemoryBudgetPropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize heapBudget[16U]; - VkDeviceSize heapUsage[16U]; -} VkPhysicalDeviceMemoryBudgetPropertiesEXT; - - - - - - - -typedef struct VkPhysicalDeviceMemoryPriorityFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 memoryPriority; -} VkPhysicalDeviceMemoryPriorityFeaturesEXT; - -typedef struct VkMemoryPriorityAllocateInfoEXT { - VkStructureType sType; - const void* pNext; - float priority; -} VkMemoryPriorityAllocateInfoEXT; - - - - - - - -typedef struct VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 dedicatedAllocationImageAliasing; -} VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV; - - - - - - - -typedef struct VkPhysicalDeviceBufferDeviceAddressFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 bufferDeviceAddress; - VkBool32 bufferDeviceAddressCaptureReplay; - VkBool32 bufferDeviceAddressMultiDevice; -} VkPhysicalDeviceBufferDeviceAddressFeaturesEXT; - -typedef VkPhysicalDeviceBufferDeviceAddressFeaturesEXT VkPhysicalDeviceBufferAddressFeaturesEXT; - -typedef VkBufferDeviceAddressInfo VkBufferDeviceAddressInfoEXT; - -typedef struct VkBufferDeviceAddressCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceAddress deviceAddress; -} VkBufferDeviceAddressCreateInfoEXT; - -typedef VkDeviceAddress ( *PFN_vkGetBufferDeviceAddressEXT)(VkDevice device, const VkBufferDeviceAddressInfo* pInfo); -# 13726 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkToolPurposeFlagBits VkToolPurposeFlagBitsEXT; - -typedef VkToolPurposeFlags VkToolPurposeFlagsEXT; - -typedef VkPhysicalDeviceToolProperties VkPhysicalDeviceToolPropertiesEXT; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceToolPropertiesEXT)(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolProperties* pToolProperties); -# 13746 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkImageStencilUsageCreateInfo VkImageStencilUsageCreateInfoEXT; -# 13755 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkValidationFeatureEnableEXT { - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_EXT = 0, - VK_VALIDATION_FEATURE_ENABLE_GPU_ASSISTED_RESERVE_BINDING_SLOT_EXT = 1, - VK_VALIDATION_FEATURE_ENABLE_BEST_PRACTICES_EXT = 2, - VK_VALIDATION_FEATURE_ENABLE_DEBUG_PRINTF_EXT = 3, - VK_VALIDATION_FEATURE_ENABLE_SYNCHRONIZATION_VALIDATION_EXT = 4, - VK_VALIDATION_FEATURE_ENABLE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationFeatureEnableEXT; - -typedef enum VkValidationFeatureDisableEXT { - VK_VALIDATION_FEATURE_DISABLE_ALL_EXT = 0, - VK_VALIDATION_FEATURE_DISABLE_SHADERS_EXT = 1, - VK_VALIDATION_FEATURE_DISABLE_THREAD_SAFETY_EXT = 2, - VK_VALIDATION_FEATURE_DISABLE_API_PARAMETERS_EXT = 3, - VK_VALIDATION_FEATURE_DISABLE_OBJECT_LIFETIMES_EXT = 4, - VK_VALIDATION_FEATURE_DISABLE_CORE_CHECKS_EXT = 5, - VK_VALIDATION_FEATURE_DISABLE_UNIQUE_HANDLES_EXT = 6, - VK_VALIDATION_FEATURE_DISABLE_SHADER_VALIDATION_CACHE_EXT = 7, - VK_VALIDATION_FEATURE_DISABLE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkValidationFeatureDisableEXT; -typedef struct VkValidationFeaturesEXT { - VkStructureType sType; - const void* pNext; - uint32_t enabledValidationFeatureCount; - const VkValidationFeatureEnableEXT* pEnabledValidationFeatures; - uint32_t disabledValidationFeatureCount; - const VkValidationFeatureDisableEXT* pDisabledValidationFeatures; -} VkValidationFeaturesEXT; - - - - - - - -typedef VkComponentTypeKHR VkComponentTypeNV; - -typedef VkScopeKHR VkScopeNV; - -typedef struct VkCooperativeMatrixPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t MSize; - uint32_t NSize; - uint32_t KSize; - VkComponentTypeNV AType; - VkComponentTypeNV BType; - VkComponentTypeNV CType; - VkComponentTypeNV DType; - VkScopeNV scope; -} VkCooperativeMatrixPropertiesNV; - -typedef struct VkPhysicalDeviceCooperativeMatrixFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cooperativeMatrix; - VkBool32 cooperativeMatrixRobustBufferAccess; -} VkPhysicalDeviceCooperativeMatrixFeaturesNV; - -typedef struct VkPhysicalDeviceCooperativeMatrixPropertiesNV { - VkStructureType sType; - void* pNext; - VkShaderStageFlags cooperativeMatrixSupportedStages; -} VkPhysicalDeviceCooperativeMatrixPropertiesNV; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV)(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties); -# 13835 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkCoverageReductionModeNV { - VK_COVERAGE_REDUCTION_MODE_MERGE_NV = 0, - VK_COVERAGE_REDUCTION_MODE_TRUNCATE_NV = 1, - VK_COVERAGE_REDUCTION_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkCoverageReductionModeNV; -typedef VkFlags VkPipelineCoverageReductionStateCreateFlagsNV; -typedef struct VkPhysicalDeviceCoverageReductionModeFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 coverageReductionMode; -} VkPhysicalDeviceCoverageReductionModeFeaturesNV; - -typedef struct VkPipelineCoverageReductionStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineCoverageReductionStateCreateFlagsNV flags; - VkCoverageReductionModeNV coverageReductionMode; -} VkPipelineCoverageReductionStateCreateInfoNV; - -typedef struct VkFramebufferMixedSamplesCombinationNV { - VkStructureType sType; - void* pNext; - VkCoverageReductionModeNV coverageReductionMode; - VkSampleCountFlagBits rasterizationSamples; - VkSampleCountFlags depthStencilSamples; - VkSampleCountFlags colorSamples; -} VkFramebufferMixedSamplesCombinationNV; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV)(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations); -# 13877 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShaderSampleInterlock; - VkBool32 fragmentShaderPixelInterlock; - VkBool32 fragmentShaderShadingRateInterlock; -} VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT; - - - - - - - -typedef struct VkPhysicalDeviceYcbcrImageArraysFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 ycbcrImageArrays; -} VkPhysicalDeviceYcbcrImageArraysFeaturesEXT; -# 13904 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkProvokingVertexModeEXT { - VK_PROVOKING_VERTEX_MODE_FIRST_VERTEX_EXT = 0, - VK_PROVOKING_VERTEX_MODE_LAST_VERTEX_EXT = 1, - VK_PROVOKING_VERTEX_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkProvokingVertexModeEXT; -typedef struct VkPhysicalDeviceProvokingVertexFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 provokingVertexLast; - VkBool32 transformFeedbackPreservesProvokingVertex; -} VkPhysicalDeviceProvokingVertexFeaturesEXT; - -typedef struct VkPhysicalDeviceProvokingVertexPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 provokingVertexModePerPipeline; - VkBool32 transformFeedbackPreservesTriangleFanProvokingVertex; -} VkPhysicalDeviceProvokingVertexPropertiesEXT; - -typedef struct VkPipelineRasterizationProvokingVertexStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkProvokingVertexModeEXT provokingVertexMode; -} VkPipelineRasterizationProvokingVertexStateCreateInfoEXT; - - - - - - - -typedef VkFlags VkHeadlessSurfaceCreateFlagsEXT; -typedef struct VkHeadlessSurfaceCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkHeadlessSurfaceCreateFlagsEXT flags; -} VkHeadlessSurfaceCreateInfoEXT; - -typedef VkResult ( *PFN_vkCreateHeadlessSurfaceEXT)(VkInstance instance, const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); -# 13958 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkLineRasterizationModeEXT { - VK_LINE_RASTERIZATION_MODE_DEFAULT_EXT = 0, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_EXT = 1, - VK_LINE_RASTERIZATION_MODE_BRESENHAM_EXT = 2, - VK_LINE_RASTERIZATION_MODE_RECTANGULAR_SMOOTH_EXT = 3, - VK_LINE_RASTERIZATION_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkLineRasterizationModeEXT; -typedef struct VkPhysicalDeviceLineRasterizationFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 rectangularLines; - VkBool32 bresenhamLines; - VkBool32 smoothLines; - VkBool32 stippledRectangularLines; - VkBool32 stippledBresenhamLines; - VkBool32 stippledSmoothLines; -} VkPhysicalDeviceLineRasterizationFeaturesEXT; - -typedef struct VkPhysicalDeviceLineRasterizationPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t lineSubPixelPrecisionBits; -} VkPhysicalDeviceLineRasterizationPropertiesEXT; - -typedef struct VkPipelineRasterizationLineStateCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkLineRasterizationModeEXT lineRasterizationMode; - VkBool32 stippledLineEnable; - uint32_t lineStippleFactor; - uint16_t lineStipplePattern; -} VkPipelineRasterizationLineStateCreateInfoEXT; - -typedef void ( *PFN_vkCmdSetLineStippleEXT)(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern); -# 14005 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceShaderAtomicFloatFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderBufferFloat32Atomics; - VkBool32 shaderBufferFloat32AtomicAdd; - VkBool32 shaderBufferFloat64Atomics; - VkBool32 shaderBufferFloat64AtomicAdd; - VkBool32 shaderSharedFloat32Atomics; - VkBool32 shaderSharedFloat32AtomicAdd; - VkBool32 shaderSharedFloat64Atomics; - VkBool32 shaderSharedFloat64AtomicAdd; - VkBool32 shaderImageFloat32Atomics; - VkBool32 shaderImageFloat32AtomicAdd; - VkBool32 sparseImageFloat32Atomics; - VkBool32 sparseImageFloat32AtomicAdd; -} VkPhysicalDeviceShaderAtomicFloatFeaturesEXT; - - - - - - - -typedef VkPhysicalDeviceHostQueryResetFeatures VkPhysicalDeviceHostQueryResetFeaturesEXT; - -typedef void ( *PFN_vkResetQueryPoolEXT)(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); -# 14045 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceIndexTypeUint8FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 indexTypeUint8; -} VkPhysicalDeviceIndexTypeUint8FeaturesEXT; - - - - - - - -typedef struct VkPhysicalDeviceExtendedDynamicStateFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 extendedDynamicState; -} VkPhysicalDeviceExtendedDynamicStateFeaturesEXT; - -typedef void ( *PFN_vkCmdSetCullModeEXT)(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode); -typedef void ( *PFN_vkCmdSetFrontFaceEXT)(VkCommandBuffer commandBuffer, VkFrontFace frontFace); -typedef void ( *PFN_vkCmdSetPrimitiveTopologyEXT)(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology); -typedef void ( *PFN_vkCmdSetViewportWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports); -typedef void ( *PFN_vkCmdSetScissorWithCountEXT)(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors); -typedef void ( *PFN_vkCmdBindVertexBuffers2EXT)(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides); -typedef void ( *PFN_vkCmdSetDepthTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable); -typedef void ( *PFN_vkCmdSetDepthWriteEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable); -typedef void ( *PFN_vkCmdSetDepthCompareOpEXT)(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp); -typedef void ( *PFN_vkCmdSetDepthBoundsTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable); -typedef void ( *PFN_vkCmdSetStencilTestEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable); -typedef void ( *PFN_vkCmdSetStencilOpEXT)(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp); -# 14143 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkHostImageCopyFlagBitsEXT { - VK_HOST_IMAGE_COPY_MEMCPY_EXT = 0x00000001, - VK_HOST_IMAGE_COPY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkHostImageCopyFlagBitsEXT; -typedef VkFlags VkHostImageCopyFlagsEXT; -typedef struct VkPhysicalDeviceHostImageCopyFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 hostImageCopy; -} VkPhysicalDeviceHostImageCopyFeaturesEXT; - -typedef struct VkPhysicalDeviceHostImageCopyPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t copySrcLayoutCount; - VkImageLayout* pCopySrcLayouts; - uint32_t copyDstLayoutCount; - VkImageLayout* pCopyDstLayouts; - uint8_t optimalTilingLayoutUUID[16U]; - VkBool32 identicalMemoryTypeRequirements; -} VkPhysicalDeviceHostImageCopyPropertiesEXT; - -typedef struct VkMemoryToImageCopyEXT { - VkStructureType sType; - const void* pNext; - const void* pHostPointer; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkMemoryToImageCopyEXT; - -typedef struct VkImageToMemoryCopyEXT { - VkStructureType sType; - const void* pNext; - void* pHostPointer; - uint32_t memoryRowLength; - uint32_t memoryImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkImageToMemoryCopyEXT; - -typedef struct VkCopyMemoryToImageInfoEXT { - VkStructureType sType; - const void* pNext; - VkHostImageCopyFlagsEXT flags; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkMemoryToImageCopyEXT* pRegions; -} VkCopyMemoryToImageInfoEXT; - -typedef struct VkCopyImageToMemoryInfoEXT { - VkStructureType sType; - const void* pNext; - VkHostImageCopyFlagsEXT flags; - VkImage srcImage; - VkImageLayout srcImageLayout; - uint32_t regionCount; - const VkImageToMemoryCopyEXT* pRegions; -} VkCopyImageToMemoryInfoEXT; - -typedef struct VkCopyImageToImageInfoEXT { - VkStructureType sType; - const void* pNext; - VkHostImageCopyFlagsEXT flags; - VkImage srcImage; - VkImageLayout srcImageLayout; - VkImage dstImage; - VkImageLayout dstImageLayout; - uint32_t regionCount; - const VkImageCopy2* pRegions; -} VkCopyImageToImageInfoEXT; - -typedef struct VkHostImageLayoutTransitionInfoEXT { - VkStructureType sType; - const void* pNext; - VkImage image; - VkImageLayout oldLayout; - VkImageLayout newLayout; - VkImageSubresourceRange subresourceRange; -} VkHostImageLayoutTransitionInfoEXT; - -typedef struct VkSubresourceHostMemcpySizeEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize size; -} VkSubresourceHostMemcpySizeEXT; - -typedef struct VkHostImageCopyDevicePerformanceQueryEXT { - VkStructureType sType; - void* pNext; - VkBool32 optimalDeviceAccess; - VkBool32 identicalMemoryLayout; -} VkHostImageCopyDevicePerformanceQueryEXT; - -typedef VkSubresourceLayout2KHR VkSubresourceLayout2EXT; - -typedef VkImageSubresource2KHR VkImageSubresource2EXT; - -typedef VkResult ( *PFN_vkCopyMemoryToImageEXT)(VkDevice device, const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo); -typedef VkResult ( *PFN_vkCopyImageToMemoryEXT)(VkDevice device, const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo); -typedef VkResult ( *PFN_vkCopyImageToImageEXT)(VkDevice device, const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo); -typedef VkResult ( *PFN_vkTransitionImageLayoutEXT)(VkDevice device, uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT* pTransitions); -typedef void ( *PFN_vkGetImageSubresourceLayout2EXT)(VkDevice device, VkImage image, const VkImageSubresource2KHR* pSubresource, VkSubresourceLayout2KHR* pLayout); -# 14281 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderBufferFloat16Atomics; - VkBool32 shaderBufferFloat16AtomicAdd; - VkBool32 shaderBufferFloat16AtomicMinMax; - VkBool32 shaderBufferFloat32AtomicMinMax; - VkBool32 shaderBufferFloat64AtomicMinMax; - VkBool32 shaderSharedFloat16Atomics; - VkBool32 shaderSharedFloat16AtomicAdd; - VkBool32 shaderSharedFloat16AtomicMinMax; - VkBool32 shaderSharedFloat32AtomicMinMax; - VkBool32 shaderSharedFloat64AtomicMinMax; - VkBool32 shaderImageFloat32AtomicMinMax; - VkBool32 sparseImageFloat32AtomicMinMax; -} VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT; -# 14305 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkPresentScalingFlagBitsEXT { - VK_PRESENT_SCALING_ONE_TO_ONE_BIT_EXT = 0x00000001, - VK_PRESENT_SCALING_ASPECT_RATIO_STRETCH_BIT_EXT = 0x00000002, - VK_PRESENT_SCALING_STRETCH_BIT_EXT = 0x00000004, - VK_PRESENT_SCALING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkPresentScalingFlagBitsEXT; -typedef VkFlags VkPresentScalingFlagsEXT; - -typedef enum VkPresentGravityFlagBitsEXT { - VK_PRESENT_GRAVITY_MIN_BIT_EXT = 0x00000001, - VK_PRESENT_GRAVITY_MAX_BIT_EXT = 0x00000002, - VK_PRESENT_GRAVITY_CENTERED_BIT_EXT = 0x00000004, - VK_PRESENT_GRAVITY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkPresentGravityFlagBitsEXT; -typedef VkFlags VkPresentGravityFlagsEXT; -typedef struct VkSurfacePresentModeEXT { - VkStructureType sType; - void* pNext; - VkPresentModeKHR presentMode; -} VkSurfacePresentModeEXT; - -typedef struct VkSurfacePresentScalingCapabilitiesEXT { - VkStructureType sType; - void* pNext; - VkPresentScalingFlagsEXT supportedPresentScaling; - VkPresentGravityFlagsEXT supportedPresentGravityX; - VkPresentGravityFlagsEXT supportedPresentGravityY; - VkExtent2D minScaledImageExtent; - VkExtent2D maxScaledImageExtent; -} VkSurfacePresentScalingCapabilitiesEXT; - -typedef struct VkSurfacePresentModeCompatibilityEXT { - VkStructureType sType; - void* pNext; - uint32_t presentModeCount; - VkPresentModeKHR* pPresentModes; -} VkSurfacePresentModeCompatibilityEXT; - - - - - - - -typedef struct VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 swapchainMaintenance1; -} VkPhysicalDeviceSwapchainMaintenance1FeaturesEXT; - -typedef struct VkSwapchainPresentFenceInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkFence* pFences; -} VkSwapchainPresentFenceInfoEXT; - -typedef struct VkSwapchainPresentModesCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t presentModeCount; - const VkPresentModeKHR* pPresentModes; -} VkSwapchainPresentModesCreateInfoEXT; - -typedef struct VkSwapchainPresentModeInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t swapchainCount; - const VkPresentModeKHR* pPresentModes; -} VkSwapchainPresentModeInfoEXT; - -typedef struct VkSwapchainPresentScalingCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkPresentScalingFlagsEXT scalingBehavior; - VkPresentGravityFlagsEXT presentGravityX; - VkPresentGravityFlagsEXT presentGravityY; -} VkSwapchainPresentScalingCreateInfoEXT; - -typedef struct VkReleaseSwapchainImagesInfoEXT { - VkStructureType sType; - const void* pNext; - VkSwapchainKHR swapchain; - uint32_t imageIndexCount; - const uint32_t* pImageIndices; -} VkReleaseSwapchainImagesInfoEXT; - -typedef VkResult ( *PFN_vkReleaseSwapchainImagesEXT)(VkDevice device, const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); -# 14405 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT; - - - - - -typedef struct VkIndirectCommandsLayoutNV_T *VkIndirectCommandsLayoutNV; - - - -typedef enum VkIndirectCommandsTokenTypeNV { - VK_INDIRECT_COMMANDS_TOKEN_TYPE_SHADER_GROUP_NV = 0, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_STATE_FLAGS_NV = 1, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_INDEX_BUFFER_NV = 2, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_VERTEX_BUFFER_NV = 3, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PUSH_CONSTANT_NV = 4, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_INDEXED_NV = 5, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_NV = 6, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_TASKS_NV = 7, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DRAW_MESH_TASKS_NV = 1000328000, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_PIPELINE_NV = 1000428003, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_DISPATCH_NV = 1000428004, - VK_INDIRECT_COMMANDS_TOKEN_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkIndirectCommandsTokenTypeNV; - -typedef enum VkIndirectStateFlagBitsNV { - VK_INDIRECT_STATE_FLAG_FRONTFACE_BIT_NV = 0x00000001, - VK_INDIRECT_STATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkIndirectStateFlagBitsNV; -typedef VkFlags VkIndirectStateFlagsNV; - -typedef enum VkIndirectCommandsLayoutUsageFlagBitsNV { - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_EXPLICIT_PREPROCESS_BIT_NV = 0x00000001, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_INDEXED_SEQUENCES_BIT_NV = 0x00000002, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_UNORDERED_SEQUENCES_BIT_NV = 0x00000004, - VK_INDIRECT_COMMANDS_LAYOUT_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkIndirectCommandsLayoutUsageFlagBitsNV; -typedef VkFlags VkIndirectCommandsLayoutUsageFlagsNV; -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t maxGraphicsShaderGroupCount; - uint32_t maxIndirectSequenceCount; - uint32_t maxIndirectCommandsTokenCount; - uint32_t maxIndirectCommandsStreamCount; - uint32_t maxIndirectCommandsTokenOffset; - uint32_t maxIndirectCommandsStreamStride; - uint32_t minSequencesCountBufferOffsetAlignment; - uint32_t minSequencesIndexBufferOffsetAlignment; - uint32_t minIndirectCommandsBufferOffsetAlignment; -} VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV; - -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 deviceGeneratedCommands; -} VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV; - -typedef struct VkGraphicsShaderGroupCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - const VkPipelineVertexInputStateCreateInfo* pVertexInputState; - const VkPipelineTessellationStateCreateInfo* pTessellationState; -} VkGraphicsShaderGroupCreateInfoNV; - -typedef struct VkGraphicsPipelineShaderGroupsCreateInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t groupCount; - const VkGraphicsShaderGroupCreateInfoNV* pGroups; - uint32_t pipelineCount; - const VkPipeline* pPipelines; -} VkGraphicsPipelineShaderGroupsCreateInfoNV; - -typedef struct VkBindShaderGroupIndirectCommandNV { - uint32_t groupIndex; -} VkBindShaderGroupIndirectCommandNV; - -typedef struct VkBindIndexBufferIndirectCommandNV { - VkDeviceAddress bufferAddress; - uint32_t size; - VkIndexType indexType; -} VkBindIndexBufferIndirectCommandNV; - -typedef struct VkBindVertexBufferIndirectCommandNV { - VkDeviceAddress bufferAddress; - uint32_t size; - uint32_t stride; -} VkBindVertexBufferIndirectCommandNV; - -typedef struct VkSetStateFlagsIndirectCommandNV { - uint32_t data; -} VkSetStateFlagsIndirectCommandNV; - -typedef struct VkIndirectCommandsStreamNV { - VkBuffer buffer; - VkDeviceSize offset; -} VkIndirectCommandsStreamNV; - -typedef struct VkIndirectCommandsLayoutTokenNV { - VkStructureType sType; - const void* pNext; - VkIndirectCommandsTokenTypeNV tokenType; - uint32_t stream; - uint32_t offset; - uint32_t vertexBindingUnit; - VkBool32 vertexDynamicStride; - VkPipelineLayout pushconstantPipelineLayout; - VkShaderStageFlags pushconstantShaderStageFlags; - uint32_t pushconstantOffset; - uint32_t pushconstantSize; - VkIndirectStateFlagsNV indirectStateFlags; - uint32_t indexTypeCount; - const VkIndexType* pIndexTypes; - const uint32_t* pIndexTypeValues; -} VkIndirectCommandsLayoutTokenNV; - -typedef struct VkIndirectCommandsLayoutCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkIndirectCommandsLayoutUsageFlagsNV flags; - VkPipelineBindPoint pipelineBindPoint; - uint32_t tokenCount; - const VkIndirectCommandsLayoutTokenNV* pTokens; - uint32_t streamCount; - const uint32_t* pStreamStrides; -} VkIndirectCommandsLayoutCreateInfoNV; - -typedef struct VkGeneratedCommandsInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline pipeline; - VkIndirectCommandsLayoutNV indirectCommandsLayout; - uint32_t streamCount; - const VkIndirectCommandsStreamNV* pStreams; - uint32_t sequencesCount; - VkBuffer preprocessBuffer; - VkDeviceSize preprocessOffset; - VkDeviceSize preprocessSize; - VkBuffer sequencesCountBuffer; - VkDeviceSize sequencesCountOffset; - VkBuffer sequencesIndexBuffer; - VkDeviceSize sequencesIndexOffset; -} VkGeneratedCommandsInfoNV; - -typedef struct VkGeneratedCommandsMemoryRequirementsInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline pipeline; - VkIndirectCommandsLayoutNV indirectCommandsLayout; - uint32_t maxSequencesCount; -} VkGeneratedCommandsMemoryRequirementsInfoNV; - -typedef void ( *PFN_vkGetGeneratedCommandsMemoryRequirementsNV)(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkCmdPreprocessGeneratedCommandsNV)(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -typedef void ( *PFN_vkCmdExecuteGeneratedCommandsNV)(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); -typedef void ( *PFN_vkCmdBindPipelineShaderGroupNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex); -typedef VkResult ( *PFN_vkCreateIndirectCommandsLayoutNV)(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); -typedef void ( *PFN_vkDestroyIndirectCommandsLayoutNV)(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator); -# 14607 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceInheritedViewportScissorFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 inheritedViewportScissor2D; -} VkPhysicalDeviceInheritedViewportScissorFeaturesNV; - -typedef struct VkCommandBufferInheritanceViewportScissorInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 viewportScissor2D; - uint32_t viewportDepthCount; - const VkViewport* pViewportDepths; -} VkCommandBufferInheritanceViewportScissorInfoNV; - - - - - - - -typedef struct VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 texelBufferAlignment; -} VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT; - -typedef VkPhysicalDeviceTexelBufferAlignmentProperties VkPhysicalDeviceTexelBufferAlignmentPropertiesEXT; - - - - - - - -typedef struct VkRenderPassTransformBeginInfoQCOM { - VkStructureType sType; - void* pNext; - VkSurfaceTransformFlagBitsKHR transform; -} VkRenderPassTransformBeginInfoQCOM; - -typedef struct VkCommandBufferInheritanceRenderPassTransformInfoQCOM { - VkStructureType sType; - void* pNext; - VkSurfaceTransformFlagBitsKHR transform; - VkRect2D renderArea; -} VkCommandBufferInheritanceRenderPassTransformInfoQCOM; -# 14661 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkDepthBiasRepresentationEXT { - VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORMAT_EXT = 0, - VK_DEPTH_BIAS_REPRESENTATION_LEAST_REPRESENTABLE_VALUE_FORCE_UNORM_EXT = 1, - VK_DEPTH_BIAS_REPRESENTATION_FLOAT_EXT = 2, - VK_DEPTH_BIAS_REPRESENTATION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDepthBiasRepresentationEXT; -typedef struct VkPhysicalDeviceDepthBiasControlFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 depthBiasControl; - VkBool32 leastRepresentableValueForceUnormRepresentation; - VkBool32 floatRepresentation; - VkBool32 depthBiasExact; -} VkPhysicalDeviceDepthBiasControlFeaturesEXT; - -typedef struct VkDepthBiasInfoEXT { - VkStructureType sType; - const void* pNext; - float depthBiasConstantFactor; - float depthBiasClamp; - float depthBiasSlopeFactor; -} VkDepthBiasInfoEXT; - -typedef struct VkDepthBiasRepresentationInfoEXT { - VkStructureType sType; - const void* pNext; - VkDepthBiasRepresentationEXT depthBiasRepresentation; - VkBool32 depthBiasExact; -} VkDepthBiasRepresentationInfoEXT; - -typedef void ( *PFN_vkCmdSetDepthBias2EXT)(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo); -# 14705 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkDeviceMemoryReportEventTypeEXT { - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATE_EXT = 0, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_FREE_EXT = 1, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_IMPORT_EXT = 2, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_UNIMPORT_EXT = 3, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_ALLOCATION_FAILED_EXT = 4, - VK_DEVICE_MEMORY_REPORT_EVENT_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceMemoryReportEventTypeEXT; -typedef VkFlags VkDeviceMemoryReportFlagsEXT; -typedef struct VkPhysicalDeviceDeviceMemoryReportFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 deviceMemoryReport; -} VkPhysicalDeviceDeviceMemoryReportFeaturesEXT; - -typedef struct VkDeviceMemoryReportCallbackDataEXT { - VkStructureType sType; - void* pNext; - VkDeviceMemoryReportFlagsEXT flags; - VkDeviceMemoryReportEventTypeEXT type; - uint64_t memoryObjectId; - VkDeviceSize size; - VkObjectType objectType; - uint64_t objectHandle; - uint32_t heapIndex; -} VkDeviceMemoryReportCallbackDataEXT; - -typedef void ( *PFN_vkDeviceMemoryReportCallbackEXT)( - const VkDeviceMemoryReportCallbackDataEXT* pCallbackData, - void* pUserData); - -typedef struct VkDeviceDeviceMemoryReportCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceMemoryReportFlagsEXT flags; - PFN_vkDeviceMemoryReportCallbackEXT pfnUserCallback; - void* pUserData; -} VkDeviceDeviceMemoryReportCreateInfoEXT; - - - - - - - -typedef VkResult ( *PFN_vkAcquireDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display); -typedef VkResult ( *PFN_vkGetDrmDisplayEXT)(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display); -# 14771 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceRobustness2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 robustBufferAccess2; - VkBool32 robustImageAccess2; - VkBool32 nullDescriptor; -} VkPhysicalDeviceRobustness2FeaturesEXT; - -typedef struct VkPhysicalDeviceRobustness2PropertiesEXT { - VkStructureType sType; - void* pNext; - VkDeviceSize robustStorageBufferAccessSizeAlignment; - VkDeviceSize robustUniformBufferAccessSizeAlignment; -} VkPhysicalDeviceRobustness2PropertiesEXT; - - - - - - - -typedef struct VkSamplerCustomBorderColorCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkClearColorValue customBorderColor; - VkFormat format; -} VkSamplerCustomBorderColorCreateInfoEXT; - -typedef struct VkPhysicalDeviceCustomBorderColorPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxCustomBorderColorSamplers; -} VkPhysicalDeviceCustomBorderColorPropertiesEXT; - -typedef struct VkPhysicalDeviceCustomBorderColorFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 customBorderColors; - VkBool32 customBorderColorWithoutFormat; -} VkPhysicalDeviceCustomBorderColorFeaturesEXT; -# 14824 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDevicePresentBarrierFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 presentBarrier; -} VkPhysicalDevicePresentBarrierFeaturesNV; - -typedef struct VkSurfaceCapabilitiesPresentBarrierNV { - VkStructureType sType; - void* pNext; - VkBool32 presentBarrierSupported; -} VkSurfaceCapabilitiesPresentBarrierNV; - -typedef struct VkSwapchainPresentBarrierCreateInfoNV { - VkStructureType sType; - void* pNext; - VkBool32 presentBarrierEnable; -} VkSwapchainPresentBarrierCreateInfoNV; - - - - - -typedef VkPrivateDataSlot VkPrivateDataSlotEXT; - - - -typedef VkPrivateDataSlotCreateFlags VkPrivateDataSlotCreateFlagsEXT; - -typedef VkPhysicalDevicePrivateDataFeatures VkPhysicalDevicePrivateDataFeaturesEXT; - -typedef VkDevicePrivateDataCreateInfo VkDevicePrivateDataCreateInfoEXT; - -typedef VkPrivateDataSlotCreateInfo VkPrivateDataSlotCreateInfoEXT; - -typedef VkResult ( *PFN_vkCreatePrivateDataSlotEXT)(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot); -typedef void ( *PFN_vkDestroyPrivateDataSlotEXT)(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkSetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data); -typedef void ( *PFN_vkGetPrivateDataEXT)(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData); -# 14895 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDevicePipelineCreationCacheControlFeatures VkPhysicalDevicePipelineCreationCacheControlFeaturesEXT; -# 14904 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkDeviceDiagnosticsConfigFlagBitsNV { - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_DEBUG_INFO_BIT_NV = 0x00000001, - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_RESOURCE_TRACKING_BIT_NV = 0x00000002, - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_AUTOMATIC_CHECKPOINTS_BIT_NV = 0x00000004, - VK_DEVICE_DIAGNOSTICS_CONFIG_ENABLE_SHADER_ERROR_REPORTING_BIT_NV = 0x00000008, - VK_DEVICE_DIAGNOSTICS_CONFIG_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkDeviceDiagnosticsConfigFlagBitsNV; -typedef VkFlags VkDeviceDiagnosticsConfigFlagsNV; -typedef struct VkPhysicalDeviceDiagnosticsConfigFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 diagnosticsConfig; -} VkPhysicalDeviceDiagnosticsConfigFeaturesNV; - -typedef struct VkDeviceDiagnosticsConfigCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceDiagnosticsConfigFlagsNV flags; -} VkDeviceDiagnosticsConfigCreateInfoNV; -# 14934 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkCudaModuleNV_T *VkCudaModuleNV; -typedef struct VkCudaFunctionNV_T *VkCudaFunctionNV; - - -typedef struct VkCudaModuleCreateInfoNV { - VkStructureType sType; - const void* pNext; - size_t dataSize; - const void* pData; -} VkCudaModuleCreateInfoNV; - -typedef struct VkCudaFunctionCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkCudaModuleNV module; - const char* pName; -} VkCudaFunctionCreateInfoNV; - -typedef struct VkCudaLaunchInfoNV { - VkStructureType sType; - const void* pNext; - VkCudaFunctionNV function; - uint32_t gridDimX; - uint32_t gridDimY; - uint32_t gridDimZ; - uint32_t blockDimX; - uint32_t blockDimY; - uint32_t blockDimZ; - uint32_t sharedMemBytes; - size_t paramCount; - const void* const * pParams; - size_t extraCount; - const void* const * pExtras; -} VkCudaLaunchInfoNV; - -typedef struct VkPhysicalDeviceCudaKernelLaunchFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 cudaKernelLaunchFeatures; -} VkPhysicalDeviceCudaKernelLaunchFeaturesNV; - -typedef struct VkPhysicalDeviceCudaKernelLaunchPropertiesNV { - VkStructureType sType; - void* pNext; - uint32_t computeCapabilityMinor; - uint32_t computeCapabilityMajor; -} VkPhysicalDeviceCudaKernelLaunchPropertiesNV; - -typedef VkResult ( *PFN_vkCreateCudaModuleNV)(VkDevice device, const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule); -typedef VkResult ( *PFN_vkGetCudaModuleCacheNV)(VkDevice device, VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData); -typedef VkResult ( *PFN_vkCreateCudaFunctionNV)(VkDevice device, const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction); -typedef void ( *PFN_vkDestroyCudaModuleNV)(VkDevice device, VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkDestroyCudaFunctionNV)(VkDevice device, VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkCmdCudaLaunchKernelNV)(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo); -# 15028 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkQueryLowLatencySupportNV { - VkStructureType sType; - const void* pNext; - void* pQueriedLowLatencyData; -} VkQueryLowLatencySupportNV; - - - - - -typedef struct VkAccelerationStructureKHR_T *VkAccelerationStructureKHR; - - -typedef struct VkPhysicalDeviceDescriptorBufferPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 combinedImageSamplerDescriptorSingleArray; - VkBool32 bufferlessPushDescriptors; - VkBool32 allowSamplerImageViewPostSubmitCreation; - VkDeviceSize descriptorBufferOffsetAlignment; - uint32_t maxDescriptorBufferBindings; - uint32_t maxResourceDescriptorBufferBindings; - uint32_t maxSamplerDescriptorBufferBindings; - uint32_t maxEmbeddedImmutableSamplerBindings; - uint32_t maxEmbeddedImmutableSamplers; - size_t bufferCaptureReplayDescriptorDataSize; - size_t imageCaptureReplayDescriptorDataSize; - size_t imageViewCaptureReplayDescriptorDataSize; - size_t samplerCaptureReplayDescriptorDataSize; - size_t accelerationStructureCaptureReplayDescriptorDataSize; - size_t samplerDescriptorSize; - size_t combinedImageSamplerDescriptorSize; - size_t sampledImageDescriptorSize; - size_t storageImageDescriptorSize; - size_t uniformTexelBufferDescriptorSize; - size_t robustUniformTexelBufferDescriptorSize; - size_t storageTexelBufferDescriptorSize; - size_t robustStorageTexelBufferDescriptorSize; - size_t uniformBufferDescriptorSize; - size_t robustUniformBufferDescriptorSize; - size_t storageBufferDescriptorSize; - size_t robustStorageBufferDescriptorSize; - size_t inputAttachmentDescriptorSize; - size_t accelerationStructureDescriptorSize; - VkDeviceSize maxSamplerDescriptorBufferRange; - VkDeviceSize maxResourceDescriptorBufferRange; - VkDeviceSize samplerDescriptorBufferAddressSpaceSize; - VkDeviceSize resourceDescriptorBufferAddressSpaceSize; - VkDeviceSize descriptorBufferAddressSpaceSize; -} VkPhysicalDeviceDescriptorBufferPropertiesEXT; - -typedef struct VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT { - VkStructureType sType; - void* pNext; - size_t combinedImageSamplerDensityMapDescriptorSize; -} VkPhysicalDeviceDescriptorBufferDensityMapPropertiesEXT; - -typedef struct VkPhysicalDeviceDescriptorBufferFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 descriptorBuffer; - VkBool32 descriptorBufferCaptureReplay; - VkBool32 descriptorBufferImageLayoutIgnored; - VkBool32 descriptorBufferPushDescriptors; -} VkPhysicalDeviceDescriptorBufferFeaturesEXT; - -typedef struct VkDescriptorAddressInfoEXT { - VkStructureType sType; - void* pNext; - VkDeviceAddress address; - VkDeviceSize range; - VkFormat format; -} VkDescriptorAddressInfoEXT; - -typedef struct VkDescriptorBufferBindingInfoEXT { - VkStructureType sType; - void* pNext; - VkDeviceAddress address; - VkBufferUsageFlags usage; -} VkDescriptorBufferBindingInfoEXT; - -typedef struct VkDescriptorBufferBindingPushDescriptorBufferHandleEXT { - VkStructureType sType; - void* pNext; - VkBuffer buffer; -} VkDescriptorBufferBindingPushDescriptorBufferHandleEXT; - -typedef union VkDescriptorDataEXT { - const VkSampler* pSampler; - const VkDescriptorImageInfo* pCombinedImageSampler; - const VkDescriptorImageInfo* pInputAttachmentImage; - const VkDescriptorImageInfo* pSampledImage; - const VkDescriptorImageInfo* pStorageImage; - const VkDescriptorAddressInfoEXT* pUniformTexelBuffer; - const VkDescriptorAddressInfoEXT* pStorageTexelBuffer; - const VkDescriptorAddressInfoEXT* pUniformBuffer; - const VkDescriptorAddressInfoEXT* pStorageBuffer; - VkDeviceAddress accelerationStructure; -} VkDescriptorDataEXT; - -typedef struct VkDescriptorGetInfoEXT { - VkStructureType sType; - const void* pNext; - VkDescriptorType type; - VkDescriptorDataEXT data; -} VkDescriptorGetInfoEXT; - -typedef struct VkBufferCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkBuffer buffer; -} VkBufferCaptureDescriptorDataInfoEXT; - -typedef struct VkImageCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkImage image; -} VkImageCaptureDescriptorDataInfoEXT; - -typedef struct VkImageViewCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkImageView imageView; -} VkImageViewCaptureDescriptorDataInfoEXT; - -typedef struct VkSamplerCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkSampler sampler; -} VkSamplerCaptureDescriptorDataInfoEXT; - -typedef struct VkOpaqueCaptureDescriptorDataCreateInfoEXT { - VkStructureType sType; - const void* pNext; - const void* opaqueCaptureDescriptorData; -} VkOpaqueCaptureDescriptorDataCreateInfoEXT; - -typedef struct VkAccelerationStructureCaptureDescriptorDataInfoEXT { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR accelerationStructure; - VkAccelerationStructureNV accelerationStructureNV; -} VkAccelerationStructureCaptureDescriptorDataInfoEXT; - -typedef void ( *PFN_vkGetDescriptorSetLayoutSizeEXT)(VkDevice device, VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes); -typedef void ( *PFN_vkGetDescriptorSetLayoutBindingOffsetEXT)(VkDevice device, VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset); -typedef void ( *PFN_vkGetDescriptorEXT)(VkDevice device, const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor); -typedef void ( *PFN_vkCmdBindDescriptorBuffersEXT)(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos); -typedef void ( *PFN_vkCmdSetDescriptorBufferOffsetsEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets); -typedef void ( *PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set); -typedef VkResult ( *PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData); -typedef VkResult ( *PFN_vkGetImageOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData); -typedef VkResult ( *PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData); -typedef VkResult ( *PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData); -typedef VkResult ( *PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT)(VkDevice device, const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData); -# 15254 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkGraphicsPipelineLibraryFlagBitsEXT { - VK_GRAPHICS_PIPELINE_LIBRARY_VERTEX_INPUT_INTERFACE_BIT_EXT = 0x00000001, - VK_GRAPHICS_PIPELINE_LIBRARY_PRE_RASTERIZATION_SHADERS_BIT_EXT = 0x00000002, - VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_SHADER_BIT_EXT = 0x00000004, - VK_GRAPHICS_PIPELINE_LIBRARY_FRAGMENT_OUTPUT_INTERFACE_BIT_EXT = 0x00000008, - VK_GRAPHICS_PIPELINE_LIBRARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkGraphicsPipelineLibraryFlagBitsEXT; -typedef VkFlags VkGraphicsPipelineLibraryFlagsEXT; -typedef struct VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 graphicsPipelineLibrary; -} VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT; - -typedef struct VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 graphicsPipelineLibraryFastLinking; - VkBool32 graphicsPipelineLibraryIndependentInterpolationDecoration; -} VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT; - -typedef struct VkGraphicsPipelineLibraryCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkGraphicsPipelineLibraryFlagsEXT flags; -} VkGraphicsPipelineLibraryCreateInfoEXT; - - - - - - - -typedef struct VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD { - VkStructureType sType; - void* pNext; - VkBool32 shaderEarlyAndLateFragmentTests; -} VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD; -# 15300 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkFragmentShadingRateTypeNV { - VK_FRAGMENT_SHADING_RATE_TYPE_FRAGMENT_SIZE_NV = 0, - VK_FRAGMENT_SHADING_RATE_TYPE_ENUMS_NV = 1, - VK_FRAGMENT_SHADING_RATE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkFragmentShadingRateTypeNV; - -typedef enum VkFragmentShadingRateNV { - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_PIXEL_NV = 0, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_1X2_PIXELS_NV = 1, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X1_PIXELS_NV = 4, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X2_PIXELS_NV = 5, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_2X4_PIXELS_NV = 6, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X2_PIXELS_NV = 9, - VK_FRAGMENT_SHADING_RATE_1_INVOCATION_PER_4X4_PIXELS_NV = 10, - VK_FRAGMENT_SHADING_RATE_2_INVOCATIONS_PER_PIXEL_NV = 11, - VK_FRAGMENT_SHADING_RATE_4_INVOCATIONS_PER_PIXEL_NV = 12, - VK_FRAGMENT_SHADING_RATE_8_INVOCATIONS_PER_PIXEL_NV = 13, - VK_FRAGMENT_SHADING_RATE_16_INVOCATIONS_PER_PIXEL_NV = 14, - VK_FRAGMENT_SHADING_RATE_NO_INVOCATIONS_NV = 15, - VK_FRAGMENT_SHADING_RATE_MAX_ENUM_NV = 0x7FFFFFFF -} VkFragmentShadingRateNV; -typedef struct VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 fragmentShadingRateEnums; - VkBool32 supersampleFragmentShadingRates; - VkBool32 noInvocationFragmentShadingRates; -} VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV; - -typedef struct VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV { - VkStructureType sType; - void* pNext; - VkSampleCountFlagBits maxFragmentShadingRateInvocationCount; -} VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV; - -typedef struct VkPipelineFragmentShadingRateEnumStateCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkFragmentShadingRateTypeNV shadingRateType; - VkFragmentShadingRateNV shadingRate; - VkFragmentShadingRateCombinerOpKHR combinerOps[2]; -} VkPipelineFragmentShadingRateEnumStateCreateInfoNV; - -typedef void ( *PFN_vkCmdSetFragmentShadingRateEnumNV)(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); -# 15358 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkAccelerationStructureMotionInstanceTypeNV { - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_STATIC_NV = 0, - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MATRIX_MOTION_NV = 1, - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_SRT_MOTION_NV = 2, - VK_ACCELERATION_STRUCTURE_MOTION_INSTANCE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkAccelerationStructureMotionInstanceTypeNV; -typedef VkFlags VkAccelerationStructureMotionInfoFlagsNV; -typedef VkFlags VkAccelerationStructureMotionInstanceFlagsNV; -typedef union VkDeviceOrHostAddressConstKHR { - VkDeviceAddress deviceAddress; - const void* hostAddress; -} VkDeviceOrHostAddressConstKHR; - -typedef struct VkAccelerationStructureGeometryMotionTrianglesDataNV { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR vertexData; -} VkAccelerationStructureGeometryMotionTrianglesDataNV; - -typedef struct VkAccelerationStructureMotionInfoNV { - VkStructureType sType; - const void* pNext; - uint32_t maxInstances; - VkAccelerationStructureMotionInfoFlagsNV flags; -} VkAccelerationStructureMotionInfoNV; - -typedef struct VkAccelerationStructureMatrixMotionInstanceNV { - VkTransformMatrixKHR transformT0; - VkTransformMatrixKHR transformT1; - uint32_t instanceCustomIndex:24; - uint32_t mask:8; - uint32_t instanceShaderBindingTableRecordOffset:24; - VkGeometryInstanceFlagsKHR flags:8; - uint64_t accelerationStructureReference; -} VkAccelerationStructureMatrixMotionInstanceNV; - -typedef struct VkSRTDataNV { - float sx; - float a; - float b; - float pvx; - float sy; - float c; - float pvy; - float sz; - float pvz; - float qx; - float qy; - float qz; - float qw; - float tx; - float ty; - float tz; -} VkSRTDataNV; - -typedef struct VkAccelerationStructureSRTMotionInstanceNV { - VkSRTDataNV transformT0; - VkSRTDataNV transformT1; - uint32_t instanceCustomIndex:24; - uint32_t mask:8; - uint32_t instanceShaderBindingTableRecordOffset:24; - VkGeometryInstanceFlagsKHR flags:8; - uint64_t accelerationStructureReference; -} VkAccelerationStructureSRTMotionInstanceNV; - -typedef union VkAccelerationStructureMotionInstanceDataNV { - VkAccelerationStructureInstanceKHR staticInstance; - VkAccelerationStructureMatrixMotionInstanceNV matrixMotionInstance; - VkAccelerationStructureSRTMotionInstanceNV srtMotionInstance; -} VkAccelerationStructureMotionInstanceDataNV; - -typedef struct VkAccelerationStructureMotionInstanceNV { - VkAccelerationStructureMotionInstanceTypeNV type; - VkAccelerationStructureMotionInstanceFlagsNV flags; - VkAccelerationStructureMotionInstanceDataNV data; -} VkAccelerationStructureMotionInstanceNV; - -typedef struct VkPhysicalDeviceRayTracingMotionBlurFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingMotionBlur; - VkBool32 rayTracingMotionBlurPipelineTraceRaysIndirect; -} VkPhysicalDeviceRayTracingMotionBlurFeaturesNV; - - - - - - - -typedef struct VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 ycbcr2plane444Formats; -} VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT; - - - - - - - -typedef struct VkPhysicalDeviceFragmentDensityMap2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 fragmentDensityMapDeferred; -} VkPhysicalDeviceFragmentDensityMap2FeaturesEXT; - -typedef struct VkPhysicalDeviceFragmentDensityMap2PropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 subsampledLoads; - VkBool32 subsampledCoarseReconstructionEarlyAccess; - uint32_t maxSubsampledArrayLayers; - uint32_t maxDescriptorSetSubsampledSamplers; -} VkPhysicalDeviceFragmentDensityMap2PropertiesEXT; - - - - - - - -typedef struct VkCopyCommandTransformInfoQCOM { - VkStructureType sType; - const void* pNext; - VkSurfaceTransformFlagBitsKHR transform; -} VkCopyCommandTransformInfoQCOM; - - - - - - - -typedef VkPhysicalDeviceImageRobustnessFeatures VkPhysicalDeviceImageRobustnessFeaturesEXT; -# 15502 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkImageCompressionFlagBitsEXT { - VK_IMAGE_COMPRESSION_DEFAULT_EXT = 0, - VK_IMAGE_COMPRESSION_FIXED_RATE_DEFAULT_EXT = 0x00000001, - VK_IMAGE_COMPRESSION_FIXED_RATE_EXPLICIT_EXT = 0x00000002, - VK_IMAGE_COMPRESSION_DISABLED_EXT = 0x00000004, - VK_IMAGE_COMPRESSION_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkImageCompressionFlagBitsEXT; -typedef VkFlags VkImageCompressionFlagsEXT; - -typedef enum VkImageCompressionFixedRateFlagBitsEXT { - VK_IMAGE_COMPRESSION_FIXED_RATE_NONE_EXT = 0, - VK_IMAGE_COMPRESSION_FIXED_RATE_1BPC_BIT_EXT = 0x00000001, - VK_IMAGE_COMPRESSION_FIXED_RATE_2BPC_BIT_EXT = 0x00000002, - VK_IMAGE_COMPRESSION_FIXED_RATE_3BPC_BIT_EXT = 0x00000004, - VK_IMAGE_COMPRESSION_FIXED_RATE_4BPC_BIT_EXT = 0x00000008, - VK_IMAGE_COMPRESSION_FIXED_RATE_5BPC_BIT_EXT = 0x00000010, - VK_IMAGE_COMPRESSION_FIXED_RATE_6BPC_BIT_EXT = 0x00000020, - VK_IMAGE_COMPRESSION_FIXED_RATE_7BPC_BIT_EXT = 0x00000040, - VK_IMAGE_COMPRESSION_FIXED_RATE_8BPC_BIT_EXT = 0x00000080, - VK_IMAGE_COMPRESSION_FIXED_RATE_9BPC_BIT_EXT = 0x00000100, - VK_IMAGE_COMPRESSION_FIXED_RATE_10BPC_BIT_EXT = 0x00000200, - VK_IMAGE_COMPRESSION_FIXED_RATE_11BPC_BIT_EXT = 0x00000400, - VK_IMAGE_COMPRESSION_FIXED_RATE_12BPC_BIT_EXT = 0x00000800, - VK_IMAGE_COMPRESSION_FIXED_RATE_13BPC_BIT_EXT = 0x00001000, - VK_IMAGE_COMPRESSION_FIXED_RATE_14BPC_BIT_EXT = 0x00002000, - VK_IMAGE_COMPRESSION_FIXED_RATE_15BPC_BIT_EXT = 0x00004000, - VK_IMAGE_COMPRESSION_FIXED_RATE_16BPC_BIT_EXT = 0x00008000, - VK_IMAGE_COMPRESSION_FIXED_RATE_17BPC_BIT_EXT = 0x00010000, - VK_IMAGE_COMPRESSION_FIXED_RATE_18BPC_BIT_EXT = 0x00020000, - VK_IMAGE_COMPRESSION_FIXED_RATE_19BPC_BIT_EXT = 0x00040000, - VK_IMAGE_COMPRESSION_FIXED_RATE_20BPC_BIT_EXT = 0x00080000, - VK_IMAGE_COMPRESSION_FIXED_RATE_21BPC_BIT_EXT = 0x00100000, - VK_IMAGE_COMPRESSION_FIXED_RATE_22BPC_BIT_EXT = 0x00200000, - VK_IMAGE_COMPRESSION_FIXED_RATE_23BPC_BIT_EXT = 0x00400000, - VK_IMAGE_COMPRESSION_FIXED_RATE_24BPC_BIT_EXT = 0x00800000, - VK_IMAGE_COMPRESSION_FIXED_RATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkImageCompressionFixedRateFlagBitsEXT; -typedef VkFlags VkImageCompressionFixedRateFlagsEXT; -typedef struct VkPhysicalDeviceImageCompressionControlFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 imageCompressionControl; -} VkPhysicalDeviceImageCompressionControlFeaturesEXT; - -typedef struct VkImageCompressionControlEXT { - VkStructureType sType; - const void* pNext; - VkImageCompressionFlagsEXT flags; - uint32_t compressionControlPlaneCount; - VkImageCompressionFixedRateFlagsEXT* pFixedRateFlags; -} VkImageCompressionControlEXT; - -typedef struct VkImageCompressionPropertiesEXT { - VkStructureType sType; - void* pNext; - VkImageCompressionFlagsEXT imageCompressionFlags; - VkImageCompressionFixedRateFlagsEXT imageCompressionFixedRateFlags; -} VkImageCompressionPropertiesEXT; - - - - - - - -typedef struct VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 attachmentFeedbackLoopLayout; -} VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT; - - - - - - - -typedef struct VkPhysicalDevice4444FormatsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 formatA4R4G4B4; - VkBool32 formatA4B4G4R4; -} VkPhysicalDevice4444FormatsFeaturesEXT; -# 15593 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkDeviceFaultAddressTypeEXT { - VK_DEVICE_FAULT_ADDRESS_TYPE_NONE_EXT = 0, - VK_DEVICE_FAULT_ADDRESS_TYPE_READ_INVALID_EXT = 1, - VK_DEVICE_FAULT_ADDRESS_TYPE_WRITE_INVALID_EXT = 2, - VK_DEVICE_FAULT_ADDRESS_TYPE_EXECUTE_INVALID_EXT = 3, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_UNKNOWN_EXT = 4, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_INVALID_EXT = 5, - VK_DEVICE_FAULT_ADDRESS_TYPE_INSTRUCTION_POINTER_FAULT_EXT = 6, - VK_DEVICE_FAULT_ADDRESS_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceFaultAddressTypeEXT; - -typedef enum VkDeviceFaultVendorBinaryHeaderVersionEXT { - VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_ONE_EXT = 1, - VK_DEVICE_FAULT_VENDOR_BINARY_HEADER_VERSION_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceFaultVendorBinaryHeaderVersionEXT; -typedef struct VkPhysicalDeviceFaultFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 deviceFault; - VkBool32 deviceFaultVendorBinary; -} VkPhysicalDeviceFaultFeaturesEXT; - -typedef struct VkDeviceFaultCountsEXT { - VkStructureType sType; - void* pNext; - uint32_t addressInfoCount; - uint32_t vendorInfoCount; - VkDeviceSize vendorBinarySize; -} VkDeviceFaultCountsEXT; - -typedef struct VkDeviceFaultAddressInfoEXT { - VkDeviceFaultAddressTypeEXT addressType; - VkDeviceAddress reportedAddress; - VkDeviceSize addressPrecision; -} VkDeviceFaultAddressInfoEXT; - -typedef struct VkDeviceFaultVendorInfoEXT { - char description[256U]; - uint64_t vendorFaultCode; - uint64_t vendorFaultData; -} VkDeviceFaultVendorInfoEXT; - -typedef struct VkDeviceFaultInfoEXT { - VkStructureType sType; - void* pNext; - char description[256U]; - VkDeviceFaultAddressInfoEXT* pAddressInfos; - VkDeviceFaultVendorInfoEXT* pVendorInfos; - void* pVendorBinaryData; -} VkDeviceFaultInfoEXT; - -typedef struct VkDeviceFaultVendorBinaryHeaderVersionOneEXT { - uint32_t headerSize; - VkDeviceFaultVendorBinaryHeaderVersionEXT headerVersion; - uint32_t vendorID; - uint32_t deviceID; - uint32_t driverVersion; - uint8_t pipelineCacheUUID[16U]; - uint32_t applicationNameOffset; - uint32_t applicationVersion; - uint32_t engineNameOffset; - uint32_t engineVersion; - uint32_t apiVersion; -} VkDeviceFaultVendorBinaryHeaderVersionOneEXT; - -typedef VkResult ( *PFN_vkGetDeviceFaultInfoEXT)(VkDevice device, VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo); -# 15672 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 rasterizationOrderColorAttachmentAccess; - VkBool32 rasterizationOrderDepthAttachmentAccess; - VkBool32 rasterizationOrderStencilAttachmentAccess; -} VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT; - -typedef VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM; - - - - - - - -typedef struct VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 formatRgba10x6WithoutYCbCrSampler; -} VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT; - - - - - - - -typedef struct VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 mutableDescriptorType; -} VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT; - -typedef VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE; - -typedef struct VkMutableDescriptorTypeListEXT { - uint32_t descriptorTypeCount; - const VkDescriptorType* pDescriptorTypes; -} VkMutableDescriptorTypeListEXT; - -typedef VkMutableDescriptorTypeListEXT VkMutableDescriptorTypeListVALVE; - -typedef struct VkMutableDescriptorTypeCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t mutableDescriptorTypeListCount; - const VkMutableDescriptorTypeListEXT* pMutableDescriptorTypeLists; -} VkMutableDescriptorTypeCreateInfoEXT; - -typedef VkMutableDescriptorTypeCreateInfoEXT VkMutableDescriptorTypeCreateInfoVALVE; - - - - - - - -typedef struct VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 vertexInputDynamicState; -} VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT; - -typedef struct VkVertexInputBindingDescription2EXT { - VkStructureType sType; - void* pNext; - uint32_t binding; - uint32_t stride; - VkVertexInputRate inputRate; - uint32_t divisor; -} VkVertexInputBindingDescription2EXT; - -typedef struct VkVertexInputAttributeDescription2EXT { - VkStructureType sType; - void* pNext; - uint32_t location; - uint32_t binding; - VkFormat format; - uint32_t offset; -} VkVertexInputAttributeDescription2EXT; - -typedef void ( *PFN_vkCmdSetVertexInputEXT)(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); -# 15770 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceDrmPropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 hasPrimary; - VkBool32 hasRender; - int64_t primaryMajor; - int64_t primaryMinor; - int64_t renderMajor; - int64_t renderMinor; -} VkPhysicalDeviceDrmPropertiesEXT; -# 15788 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkDeviceAddressBindingTypeEXT { - VK_DEVICE_ADDRESS_BINDING_TYPE_BIND_EXT = 0, - VK_DEVICE_ADDRESS_BINDING_TYPE_UNBIND_EXT = 1, - VK_DEVICE_ADDRESS_BINDING_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceAddressBindingTypeEXT; - -typedef enum VkDeviceAddressBindingFlagBitsEXT { - VK_DEVICE_ADDRESS_BINDING_INTERNAL_OBJECT_BIT_EXT = 0x00000001, - VK_DEVICE_ADDRESS_BINDING_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkDeviceAddressBindingFlagBitsEXT; -typedef VkFlags VkDeviceAddressBindingFlagsEXT; -typedef struct VkPhysicalDeviceAddressBindingReportFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 reportAddressBinding; -} VkPhysicalDeviceAddressBindingReportFeaturesEXT; - -typedef struct VkDeviceAddressBindingCallbackDataEXT { - VkStructureType sType; - void* pNext; - VkDeviceAddressBindingFlagsEXT flags; - VkDeviceAddress baseAddress; - VkDeviceSize size; - VkDeviceAddressBindingTypeEXT bindingType; -} VkDeviceAddressBindingCallbackDataEXT; - - - - - - - -typedef struct VkPhysicalDeviceDepthClipControlFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 depthClipControl; -} VkPhysicalDeviceDepthClipControlFeaturesEXT; - -typedef struct VkPipelineViewportDepthClipControlCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 negativeOneToOne; -} VkPipelineViewportDepthClipControlCreateInfoEXT; - - - - - - - -typedef struct VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 primitiveTopologyListRestart; - VkBool32 primitiveTopologyPatchListRestart; -} VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT; - - - - - - - -typedef struct VkSubpassShadingPipelineCreateInfoHUAWEI { - VkStructureType sType; - void* pNext; - VkRenderPass renderPass; - uint32_t subpass; -} VkSubpassShadingPipelineCreateInfoHUAWEI; - -typedef struct VkPhysicalDeviceSubpassShadingFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 subpassShading; -} VkPhysicalDeviceSubpassShadingFeaturesHUAWEI; - -typedef struct VkPhysicalDeviceSubpassShadingPropertiesHUAWEI { - VkStructureType sType; - void* pNext; - uint32_t maxSubpassShadingWorkgroupSizeAspectRatio; -} VkPhysicalDeviceSubpassShadingPropertiesHUAWEI; - -typedef VkResult ( *PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI)(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize); -typedef void ( *PFN_vkCmdSubpassShadingHUAWEI)(VkCommandBuffer commandBuffer); -# 15888 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceInvocationMaskFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 invocationMask; -} VkPhysicalDeviceInvocationMaskFeaturesHUAWEI; - -typedef void ( *PFN_vkCmdBindInvocationMaskHUAWEI)(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout); -# 15906 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef void* VkRemoteAddressNV; - - -typedef struct VkMemoryGetRemoteAddressInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceMemory memory; - VkExternalMemoryHandleTypeFlagBits handleType; -} VkMemoryGetRemoteAddressInfoNV; - -typedef struct VkPhysicalDeviceExternalMemoryRDMAFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 externalMemoryRDMA; -} VkPhysicalDeviceExternalMemoryRDMAFeaturesNV; - -typedef VkResult ( *PFN_vkGetMemoryRemoteAddressNV)(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress); -# 15936 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPipelineInfoKHR VkPipelineInfoEXT; - -typedef struct VkPipelinePropertiesIdentifierEXT { - VkStructureType sType; - void* pNext; - uint8_t pipelineIdentifier[16U]; -} VkPipelinePropertiesIdentifierEXT; - -typedef struct VkPhysicalDevicePipelinePropertiesFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pipelinePropertiesIdentifier; -} VkPhysicalDevicePipelinePropertiesFeaturesEXT; - -typedef VkResult ( *PFN_vkGetPipelinePropertiesEXT)(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties); -# 15965 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkFrameBoundaryFlagBitsEXT { - VK_FRAME_BOUNDARY_FRAME_END_BIT_EXT = 0x00000001, - VK_FRAME_BOUNDARY_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkFrameBoundaryFlagBitsEXT; -typedef VkFlags VkFrameBoundaryFlagsEXT; -typedef struct VkPhysicalDeviceFrameBoundaryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 frameBoundary; -} VkPhysicalDeviceFrameBoundaryFeaturesEXT; - -typedef struct VkFrameBoundaryEXT { - VkStructureType sType; - const void* pNext; - VkFrameBoundaryFlagsEXT flags; - uint64_t frameID; - uint32_t imageCount; - const VkImage* pImages; - uint32_t bufferCount; - const VkBuffer* pBuffers; - uint64_t tagName; - size_t tagSize; - const void* pTag; -} VkFrameBoundaryEXT; - - - - - - - -typedef struct VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 multisampledRenderToSingleSampled; -} VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT; - -typedef struct VkSubpassResolvePerformanceQueryEXT { - VkStructureType sType; - void* pNext; - VkBool32 optimal; -} VkSubpassResolvePerformanceQueryEXT; - -typedef struct VkMultisampledRenderToSingleSampledInfoEXT { - VkStructureType sType; - const void* pNext; - VkBool32 multisampledRenderToSingleSampledEnable; - VkSampleCountFlagBits rasterizationSamples; -} VkMultisampledRenderToSingleSampledInfoEXT; - - - - - - - -typedef struct VkPhysicalDeviceExtendedDynamicState2FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 extendedDynamicState2; - VkBool32 extendedDynamicState2LogicOp; - VkBool32 extendedDynamicState2PatchControlPoints; -} VkPhysicalDeviceExtendedDynamicState2FeaturesEXT; - -typedef void ( *PFN_vkCmdSetPatchControlPointsEXT)(VkCommandBuffer commandBuffer, uint32_t patchControlPoints); -typedef void ( *PFN_vkCmdSetRasterizerDiscardEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable); -typedef void ( *PFN_vkCmdSetDepthBiasEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable); -typedef void ( *PFN_vkCmdSetLogicOpEXT)(VkCommandBuffer commandBuffer, VkLogicOp logicOp); -typedef void ( *PFN_vkCmdSetPrimitiveRestartEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable); -# 16062 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceColorWriteEnableFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 colorWriteEnable; -} VkPhysicalDeviceColorWriteEnableFeaturesEXT; - -typedef struct VkPipelineColorWriteCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t attachmentCount; - const VkBool32* pColorWriteEnables; -} VkPipelineColorWriteCreateInfoEXT; - -typedef void ( *PFN_vkCmdSetColorWriteEnableEXT)(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables); -# 16089 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 primitivesGeneratedQuery; - VkBool32 primitivesGeneratedQueryWithRasterizerDiscard; - VkBool32 primitivesGeneratedQueryWithNonZeroStreams; -} VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT; -# 16104 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR VkPhysicalDeviceGlobalPriorityQueryFeaturesEXT; - -typedef VkQueueFamilyGlobalPriorityPropertiesKHR VkQueueFamilyGlobalPriorityPropertiesEXT; - - - - - - - -typedef struct VkPhysicalDeviceImageViewMinLodFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 minLod; -} VkPhysicalDeviceImageViewMinLodFeaturesEXT; - -typedef struct VkImageViewMinLodCreateInfoEXT { - VkStructureType sType; - const void* pNext; - float minLod; -} VkImageViewMinLodCreateInfoEXT; - - - - - - - -typedef struct VkPhysicalDeviceMultiDrawFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 multiDraw; -} VkPhysicalDeviceMultiDrawFeaturesEXT; - -typedef struct VkPhysicalDeviceMultiDrawPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxMultiDrawCount; -} VkPhysicalDeviceMultiDrawPropertiesEXT; - -typedef struct VkMultiDrawInfoEXT { - uint32_t firstVertex; - uint32_t vertexCount; -} VkMultiDrawInfoEXT; - -typedef struct VkMultiDrawIndexedInfoEXT { - uint32_t firstIndex; - uint32_t indexCount; - int32_t vertexOffset; -} VkMultiDrawIndexedInfoEXT; - -typedef void ( *PFN_vkCmdDrawMultiEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride); -typedef void ( *PFN_vkCmdDrawMultiIndexedEXT)(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset); -# 16182 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceImage2DViewOf3DFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 image2DViewOf3D; - VkBool32 sampler2DViewOf3D; -} VkPhysicalDeviceImage2DViewOf3DFeaturesEXT; - - - - - - - -typedef struct VkPhysicalDeviceShaderTileImageFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderTileImageColorReadAccess; - VkBool32 shaderTileImageDepthReadAccess; - VkBool32 shaderTileImageStencilReadAccess; -} VkPhysicalDeviceShaderTileImageFeaturesEXT; - -typedef struct VkPhysicalDeviceShaderTileImagePropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderTileImageCoherentReadAccelerated; - VkBool32 shaderTileImageReadSampleFromPixelRateInvocation; - VkBool32 shaderTileImageReadFromHelperInvocation; -} VkPhysicalDeviceShaderTileImagePropertiesEXT; - - - - - -typedef struct VkMicromapEXT_T *VkMicromapEXT; - - - -typedef enum VkMicromapTypeEXT { - VK_MICROMAP_TYPE_OPACITY_MICROMAP_EXT = 0, - - - - VK_MICROMAP_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkMicromapTypeEXT; - -typedef enum VkBuildMicromapModeEXT { - VK_BUILD_MICROMAP_MODE_BUILD_EXT = 0, - VK_BUILD_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkBuildMicromapModeEXT; - -typedef enum VkCopyMicromapModeEXT { - VK_COPY_MICROMAP_MODE_CLONE_EXT = 0, - VK_COPY_MICROMAP_MODE_SERIALIZE_EXT = 1, - VK_COPY_MICROMAP_MODE_DESERIALIZE_EXT = 2, - VK_COPY_MICROMAP_MODE_COMPACT_EXT = 3, - VK_COPY_MICROMAP_MODE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkCopyMicromapModeEXT; - -typedef enum VkOpacityMicromapFormatEXT { - VK_OPACITY_MICROMAP_FORMAT_2_STATE_EXT = 1, - VK_OPACITY_MICROMAP_FORMAT_4_STATE_EXT = 2, - VK_OPACITY_MICROMAP_FORMAT_MAX_ENUM_EXT = 0x7FFFFFFF -} VkOpacityMicromapFormatEXT; - -typedef enum VkOpacityMicromapSpecialIndexEXT { - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_TRANSPARENT_EXT = -1, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_OPAQUE_EXT = -2, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_TRANSPARENT_EXT = -3, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_FULLY_UNKNOWN_OPAQUE_EXT = -4, - VK_OPACITY_MICROMAP_SPECIAL_INDEX_MAX_ENUM_EXT = 0x7FFFFFFF -} VkOpacityMicromapSpecialIndexEXT; - -typedef enum VkAccelerationStructureCompatibilityKHR { - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_COMPATIBLE_KHR = 0, - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_INCOMPATIBLE_KHR = 1, - VK_ACCELERATION_STRUCTURE_COMPATIBILITY_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureCompatibilityKHR; - -typedef enum VkAccelerationStructureBuildTypeKHR { - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_KHR = 0, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_DEVICE_KHR = 1, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_HOST_OR_DEVICE_KHR = 2, - VK_ACCELERATION_STRUCTURE_BUILD_TYPE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureBuildTypeKHR; - -typedef enum VkBuildMicromapFlagBitsEXT { - VK_BUILD_MICROMAP_PREFER_FAST_TRACE_BIT_EXT = 0x00000001, - VK_BUILD_MICROMAP_PREFER_FAST_BUILD_BIT_EXT = 0x00000002, - VK_BUILD_MICROMAP_ALLOW_COMPACTION_BIT_EXT = 0x00000004, - VK_BUILD_MICROMAP_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkBuildMicromapFlagBitsEXT; -typedef VkFlags VkBuildMicromapFlagsEXT; - -typedef enum VkMicromapCreateFlagBitsEXT { - VK_MICROMAP_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_EXT = 0x00000001, - VK_MICROMAP_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkMicromapCreateFlagBitsEXT; -typedef VkFlags VkMicromapCreateFlagsEXT; -typedef struct VkMicromapUsageEXT { - uint32_t count; - uint32_t subdivisionLevel; - uint32_t format; -} VkMicromapUsageEXT; - -typedef union VkDeviceOrHostAddressKHR { - VkDeviceAddress deviceAddress; - void* hostAddress; -} VkDeviceOrHostAddressKHR; - -typedef struct VkMicromapBuildInfoEXT { - VkStructureType sType; - const void* pNext; - VkMicromapTypeEXT type; - VkBuildMicromapFlagsEXT flags; - VkBuildMicromapModeEXT mode; - VkMicromapEXT dstMicromap; - uint32_t usageCountsCount; - const VkMicromapUsageEXT* pUsageCounts; - const VkMicromapUsageEXT* const* ppUsageCounts; - VkDeviceOrHostAddressConstKHR data; - VkDeviceOrHostAddressKHR scratchData; - VkDeviceOrHostAddressConstKHR triangleArray; - VkDeviceSize triangleArrayStride; -} VkMicromapBuildInfoEXT; - -typedef struct VkMicromapCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkMicromapCreateFlagsEXT createFlags; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; - VkMicromapTypeEXT type; - VkDeviceAddress deviceAddress; -} VkMicromapCreateInfoEXT; - -typedef struct VkPhysicalDeviceOpacityMicromapFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 micromap; - VkBool32 micromapCaptureReplay; - VkBool32 micromapHostCommands; -} VkPhysicalDeviceOpacityMicromapFeaturesEXT; - -typedef struct VkPhysicalDeviceOpacityMicromapPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxOpacity2StateSubdivisionLevel; - uint32_t maxOpacity4StateSubdivisionLevel; -} VkPhysicalDeviceOpacityMicromapPropertiesEXT; - -typedef struct VkMicromapVersionInfoEXT { - VkStructureType sType; - const void* pNext; - const uint8_t* pVersionData; -} VkMicromapVersionInfoEXT; - -typedef struct VkCopyMicromapToMemoryInfoEXT { - VkStructureType sType; - const void* pNext; - VkMicromapEXT src; - VkDeviceOrHostAddressKHR dst; - VkCopyMicromapModeEXT mode; -} VkCopyMicromapToMemoryInfoEXT; - -typedef struct VkCopyMemoryToMicromapInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR src; - VkMicromapEXT dst; - VkCopyMicromapModeEXT mode; -} VkCopyMemoryToMicromapInfoEXT; - -typedef struct VkCopyMicromapInfoEXT { - VkStructureType sType; - const void* pNext; - VkMicromapEXT src; - VkMicromapEXT dst; - VkCopyMicromapModeEXT mode; -} VkCopyMicromapInfoEXT; - -typedef struct VkMicromapBuildSizesInfoEXT { - VkStructureType sType; - const void* pNext; - VkDeviceSize micromapSize; - VkDeviceSize buildScratchSize; - VkBool32 discardable; -} VkMicromapBuildSizesInfoEXT; - -typedef struct VkAccelerationStructureTrianglesOpacityMicromapEXT { - VkStructureType sType; - void* pNext; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR indexBuffer; - VkDeviceSize indexStride; - uint32_t baseTriangle; - uint32_t usageCountsCount; - const VkMicromapUsageEXT* pUsageCounts; - const VkMicromapUsageEXT* const* ppUsageCounts; - VkMicromapEXT micromap; -} VkAccelerationStructureTrianglesOpacityMicromapEXT; - -typedef struct VkMicromapTriangleEXT { - uint32_t dataOffset; - uint16_t subdivisionLevel; - uint16_t format; -} VkMicromapTriangleEXT; - -typedef VkResult ( *PFN_vkCreateMicromapEXT)(VkDevice device, const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap); -typedef void ( *PFN_vkDestroyMicromapEXT)(VkDevice device, VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkCmdBuildMicromapsEXT)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); -typedef VkResult ( *PFN_vkBuildMicromapsEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos); -typedef VkResult ( *PFN_vkCopyMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo); -typedef VkResult ( *PFN_vkCopyMicromapToMemoryEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo); -typedef VkResult ( *PFN_vkCopyMemoryToMicromapEXT)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo); -typedef VkResult ( *PFN_vkWriteMicromapsPropertiesEXT)(VkDevice device, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); -typedef void ( *PFN_vkCmdCopyMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo); -typedef void ( *PFN_vkCmdCopyMicromapToMemoryEXT)(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo); -typedef void ( *PFN_vkCmdCopyMemoryToMicromapEXT)(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo); -typedef void ( *PFN_vkCmdWriteMicromapsPropertiesEXT)(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef void ( *PFN_vkGetDeviceMicromapCompatibilityEXT)(VkDevice device, const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); -typedef void ( *PFN_vkGetMicromapBuildSizesEXT)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo); -# 16495 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI { - VkStructureType sType; - void* pNext; - VkBool32 clustercullingShader; - VkBool32 multiviewClusterCullingShader; -} VkPhysicalDeviceClusterCullingShaderFeaturesHUAWEI; - -typedef struct VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI { - VkStructureType sType; - void* pNext; - uint32_t maxWorkGroupCount[3]; - uint32_t maxWorkGroupSize[3]; - uint32_t maxOutputClusterCount; - VkDeviceSize indirectBufferOffsetAlignment; -} VkPhysicalDeviceClusterCullingShaderPropertiesHUAWEI; - -typedef void ( *PFN_vkCmdDrawClusterHUAWEI)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef void ( *PFN_vkCmdDrawClusterIndirectHUAWEI)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); -# 16532 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceBorderColorSwizzleFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 borderColorSwizzle; - VkBool32 borderColorSwizzleFromImage; -} VkPhysicalDeviceBorderColorSwizzleFeaturesEXT; - -typedef struct VkSamplerBorderColorComponentMappingCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkComponentMapping components; - VkBool32 srgb; -} VkSamplerBorderColorComponentMappingCreateInfoEXT; - - - - - - - -typedef struct VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pageableDeviceLocalMemory; -} VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT; - -typedef void ( *PFN_vkSetDeviceMemoryPriorityEXT)(VkDevice device, VkDeviceMemory memory, float priority); -# 16572 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceShaderCorePropertiesARM { - VkStructureType sType; - void* pNext; - uint32_t pixelRate; - uint32_t texelRate; - uint32_t fmaRate; -} VkPhysicalDeviceShaderCorePropertiesARM; - - - - - - - -typedef VkFlags64 VkPhysicalDeviceSchedulingControlsFlagsARM; - -typedef enum VkPhysicalDeviceSchedulingControlsFlagBitsARM { - VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_SHADER_CORE_COUNT_ARM = 0x00000001, - VK_PHYSICAL_DEVICE_SCHEDULING_CONTROLS_FLAG_BITS_MAX_ENUM_ARM = 0x7FFFFFFF -} VkPhysicalDeviceSchedulingControlsFlagBitsARM; -typedef struct VkDeviceQueueShaderCoreControlCreateInfoARM { - VkStructureType sType; - void* pNext; - uint32_t shaderCoreCount; -} VkDeviceQueueShaderCoreControlCreateInfoARM; - -typedef struct VkPhysicalDeviceSchedulingControlsFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 schedulingControls; -} VkPhysicalDeviceSchedulingControlsFeaturesARM; - -typedef struct VkPhysicalDeviceSchedulingControlsPropertiesARM { - VkStructureType sType; - void* pNext; - VkPhysicalDeviceSchedulingControlsFlagsARM schedulingControlsFlags; -} VkPhysicalDeviceSchedulingControlsPropertiesARM; -# 16617 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 imageSlicedViewOf3D; -} VkPhysicalDeviceImageSlicedViewOf3DFeaturesEXT; - -typedef struct VkImageViewSlicedCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t sliceOffset; - uint32_t sliceCount; -} VkImageViewSlicedCreateInfoEXT; - - - - - - - -typedef struct VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE { - VkStructureType sType; - void* pNext; - VkBool32 descriptorSetHostMapping; -} VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE; - -typedef struct VkDescriptorSetBindingReferenceVALVE { - VkStructureType sType; - const void* pNext; - VkDescriptorSetLayout descriptorSetLayout; - uint32_t binding; -} VkDescriptorSetBindingReferenceVALVE; - -typedef struct VkDescriptorSetLayoutHostMappingInfoVALVE { - VkStructureType sType; - void* pNext; - size_t descriptorOffset; - uint32_t descriptorSize; -} VkDescriptorSetLayoutHostMappingInfoVALVE; - -typedef void ( *PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE)(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); -typedef void ( *PFN_vkGetDescriptorSetHostMappingVALVE)(VkDevice device, VkDescriptorSet descriptorSet, void** ppData); -# 16676 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceDepthClampZeroOneFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 depthClampZeroOne; -} VkPhysicalDeviceDepthClampZeroOneFeaturesEXT; - - - - - - - -typedef struct VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 nonSeamlessCubeMap; -} VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT; - - - - - - - -typedef struct VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 fragmentDensityMapOffset; -} VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM; - -typedef struct VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM { - VkStructureType sType; - void* pNext; - VkExtent2D fragmentDensityOffsetGranularity; -} VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM; - -typedef struct VkSubpassFragmentDensityMapOffsetEndInfoQCOM { - VkStructureType sType; - const void* pNext; - uint32_t fragmentDensityOffsetCount; - const VkOffset2D* pFragmentDensityOffsets; -} VkSubpassFragmentDensityMapOffsetEndInfoQCOM; - - - - - - - -typedef struct VkCopyMemoryIndirectCommandNV { - VkDeviceAddress srcAddress; - VkDeviceAddress dstAddress; - VkDeviceSize size; -} VkCopyMemoryIndirectCommandNV; - -typedef struct VkCopyMemoryToImageIndirectCommandNV { - VkDeviceAddress srcAddress; - uint32_t bufferRowLength; - uint32_t bufferImageHeight; - VkImageSubresourceLayers imageSubresource; - VkOffset3D imageOffset; - VkExtent3D imageExtent; -} VkCopyMemoryToImageIndirectCommandNV; - -typedef struct VkPhysicalDeviceCopyMemoryIndirectFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 indirectCopy; -} VkPhysicalDeviceCopyMemoryIndirectFeaturesNV; - -typedef struct VkPhysicalDeviceCopyMemoryIndirectPropertiesNV { - VkStructureType sType; - void* pNext; - VkQueueFlags supportedQueues; -} VkPhysicalDeviceCopyMemoryIndirectPropertiesNV; - -typedef void ( *PFN_vkCmdCopyMemoryIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride); -typedef void ( *PFN_vkCmdCopyMemoryToImageIndirectNV)(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources); -# 16779 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef VkFlags64 VkMemoryDecompressionMethodFlagBitsNV; -static const VkMemoryDecompressionMethodFlagBitsNV VK_MEMORY_DECOMPRESSION_METHOD_GDEFLATE_1_0_BIT_NV = 0x00000001ULL; - -typedef VkFlags64 VkMemoryDecompressionMethodFlagsNV; -typedef struct VkDecompressMemoryRegionNV { - VkDeviceAddress srcAddress; - VkDeviceAddress dstAddress; - VkDeviceSize compressedSize; - VkDeviceSize decompressedSize; - VkMemoryDecompressionMethodFlagsNV decompressionMethod; -} VkDecompressMemoryRegionNV; - -typedef struct VkPhysicalDeviceMemoryDecompressionFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 memoryDecompression; -} VkPhysicalDeviceMemoryDecompressionFeaturesNV; - -typedef struct VkPhysicalDeviceMemoryDecompressionPropertiesNV { - VkStructureType sType; - void* pNext; - VkMemoryDecompressionMethodFlagsNV decompressionMethods; - uint64_t maxDecompressionIndirectCount; -} VkPhysicalDeviceMemoryDecompressionPropertiesNV; - -typedef void ( *PFN_vkCmdDecompressMemoryNV)(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); -typedef void ( *PFN_vkCmdDecompressMemoryIndirectCountNV)(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride); -# 16825 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 deviceGeneratedCompute; - VkBool32 deviceGeneratedComputePipelines; - VkBool32 deviceGeneratedComputeCaptureReplay; -} VkPhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV; - -typedef struct VkComputePipelineIndirectBufferInfoNV { - VkStructureType sType; - const void* pNext; - VkDeviceAddress deviceAddress; - VkDeviceSize size; - VkDeviceAddress pipelineDeviceAddressCaptureReplay; -} VkComputePipelineIndirectBufferInfoNV; - -typedef struct VkPipelineIndirectDeviceAddressInfoNV { - VkStructureType sType; - const void* pNext; - VkPipelineBindPoint pipelineBindPoint; - VkPipeline pipeline; -} VkPipelineIndirectDeviceAddressInfoNV; - -typedef struct VkBindPipelineIndirectCommandNV { - VkDeviceAddress pipelineAddress; -} VkBindPipelineIndirectCommandNV; - -typedef void ( *PFN_vkGetPipelineIndirectMemoryRequirementsNV)(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2* pMemoryRequirements); -typedef void ( *PFN_vkCmdUpdatePipelineIndirectBufferNV)(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); -typedef VkDeviceAddress ( *PFN_vkGetPipelineIndirectDeviceAddressNV)(VkDevice device, const VkPipelineIndirectDeviceAddressInfoNV* pInfo); -# 16877 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceLinearColorAttachmentFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 linearColorAttachment; -} VkPhysicalDeviceLinearColorAttachmentFeaturesNV; -# 16895 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 imageCompressionControlSwapchain; -} VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT; - - - - - - - -typedef struct VkImageViewSampleWeightCreateInfoQCOM { - VkStructureType sType; - const void* pNext; - VkOffset2D filterCenter; - VkExtent2D filterSize; - uint32_t numPhases; -} VkImageViewSampleWeightCreateInfoQCOM; - -typedef struct VkPhysicalDeviceImageProcessingFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 textureSampleWeighted; - VkBool32 textureBoxFilter; - VkBool32 textureBlockMatch; -} VkPhysicalDeviceImageProcessingFeaturesQCOM; - -typedef struct VkPhysicalDeviceImageProcessingPropertiesQCOM { - VkStructureType sType; - void* pNext; - uint32_t maxWeightFilterPhases; - VkExtent2D maxWeightFilterDimension; - VkExtent2D maxBlockMatchRegion; - VkExtent2D maxBoxFilterBlockSize; -} VkPhysicalDeviceImageProcessingPropertiesQCOM; - - - - - - - -typedef struct VkPhysicalDeviceNestedCommandBufferFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 nestedCommandBuffer; - VkBool32 nestedCommandBufferRendering; - VkBool32 nestedCommandBufferSimultaneousUse; -} VkPhysicalDeviceNestedCommandBufferFeaturesEXT; - -typedef struct VkPhysicalDeviceNestedCommandBufferPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxCommandBufferNestingLevel; -} VkPhysicalDeviceNestedCommandBufferPropertiesEXT; - - - - - - - -typedef struct VkExternalMemoryAcquireUnmodifiedEXT { - VkStructureType sType; - const void* pNext; - VkBool32 acquireUnmodifiedMemory; -} VkExternalMemoryAcquireUnmodifiedEXT; - - - - - - - -typedef struct VkPhysicalDeviceExtendedDynamicState3FeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 extendedDynamicState3TessellationDomainOrigin; - VkBool32 extendedDynamicState3DepthClampEnable; - VkBool32 extendedDynamicState3PolygonMode; - VkBool32 extendedDynamicState3RasterizationSamples; - VkBool32 extendedDynamicState3SampleMask; - VkBool32 extendedDynamicState3AlphaToCoverageEnable; - VkBool32 extendedDynamicState3AlphaToOneEnable; - VkBool32 extendedDynamicState3LogicOpEnable; - VkBool32 extendedDynamicState3ColorBlendEnable; - VkBool32 extendedDynamicState3ColorBlendEquation; - VkBool32 extendedDynamicState3ColorWriteMask; - VkBool32 extendedDynamicState3RasterizationStream; - VkBool32 extendedDynamicState3ConservativeRasterizationMode; - VkBool32 extendedDynamicState3ExtraPrimitiveOverestimationSize; - VkBool32 extendedDynamicState3DepthClipEnable; - VkBool32 extendedDynamicState3SampleLocationsEnable; - VkBool32 extendedDynamicState3ColorBlendAdvanced; - VkBool32 extendedDynamicState3ProvokingVertexMode; - VkBool32 extendedDynamicState3LineRasterizationMode; - VkBool32 extendedDynamicState3LineStippleEnable; - VkBool32 extendedDynamicState3DepthClipNegativeOneToOne; - VkBool32 extendedDynamicState3ViewportWScalingEnable; - VkBool32 extendedDynamicState3ViewportSwizzle; - VkBool32 extendedDynamicState3CoverageToColorEnable; - VkBool32 extendedDynamicState3CoverageToColorLocation; - VkBool32 extendedDynamicState3CoverageModulationMode; - VkBool32 extendedDynamicState3CoverageModulationTableEnable; - VkBool32 extendedDynamicState3CoverageModulationTable; - VkBool32 extendedDynamicState3CoverageReductionMode; - VkBool32 extendedDynamicState3RepresentativeFragmentTestEnable; - VkBool32 extendedDynamicState3ShadingRateImageEnable; -} VkPhysicalDeviceExtendedDynamicState3FeaturesEXT; - -typedef struct VkPhysicalDeviceExtendedDynamicState3PropertiesEXT { - VkStructureType sType; - void* pNext; - VkBool32 dynamicPrimitiveTopologyUnrestricted; -} VkPhysicalDeviceExtendedDynamicState3PropertiesEXT; - -typedef struct VkColorBlendEquationEXT { - VkBlendFactor srcColorBlendFactor; - VkBlendFactor dstColorBlendFactor; - VkBlendOp colorBlendOp; - VkBlendFactor srcAlphaBlendFactor; - VkBlendFactor dstAlphaBlendFactor; - VkBlendOp alphaBlendOp; -} VkColorBlendEquationEXT; - -typedef struct VkColorBlendAdvancedEXT { - VkBlendOp advancedBlendOp; - VkBool32 srcPremultiplied; - VkBool32 dstPremultiplied; - VkBlendOverlapEXT blendOverlap; - VkBool32 clampResults; -} VkColorBlendAdvancedEXT; - -typedef void ( *PFN_vkCmdSetTessellationDomainOriginEXT)(VkCommandBuffer commandBuffer, VkTessellationDomainOrigin domainOrigin); -typedef void ( *PFN_vkCmdSetDepthClampEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable); -typedef void ( *PFN_vkCmdSetPolygonModeEXT)(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode); -typedef void ( *PFN_vkCmdSetRasterizationSamplesEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples); -typedef void ( *PFN_vkCmdSetSampleMaskEXT)(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask); -typedef void ( *PFN_vkCmdSetAlphaToCoverageEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable); -typedef void ( *PFN_vkCmdSetAlphaToOneEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable); -typedef void ( *PFN_vkCmdSetLogicOpEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable); -typedef void ( *PFN_vkCmdSetColorBlendEnableEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables); -typedef void ( *PFN_vkCmdSetColorBlendEquationEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations); -typedef void ( *PFN_vkCmdSetColorWriteMaskEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks); -typedef void ( *PFN_vkCmdSetRasterizationStreamEXT)(VkCommandBuffer commandBuffer, uint32_t rasterizationStream); -typedef void ( *PFN_vkCmdSetConservativeRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode); -typedef void ( *PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT)(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize); -typedef void ( *PFN_vkCmdSetDepthClipEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable); -typedef void ( *PFN_vkCmdSetSampleLocationsEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable); -typedef void ( *PFN_vkCmdSetColorBlendAdvancedEXT)(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced); -typedef void ( *PFN_vkCmdSetProvokingVertexModeEXT)(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode); -typedef void ( *PFN_vkCmdSetLineRasterizationModeEXT)(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode); -typedef void ( *PFN_vkCmdSetLineStippleEnableEXT)(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable); -typedef void ( *PFN_vkCmdSetDepthClipNegativeOneToOneEXT)(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne); -typedef void ( *PFN_vkCmdSetViewportWScalingEnableNV)(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable); -typedef void ( *PFN_vkCmdSetViewportSwizzleNV)(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles); -typedef void ( *PFN_vkCmdSetCoverageToColorEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable); -typedef void ( *PFN_vkCmdSetCoverageToColorLocationNV)(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation); -typedef void ( *PFN_vkCmdSetCoverageModulationModeNV)(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode); -typedef void ( *PFN_vkCmdSetCoverageModulationTableEnableNV)(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable); -typedef void ( *PFN_vkCmdSetCoverageModulationTableNV)(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable); -typedef void ( *PFN_vkCmdSetShadingRateImageEnableNV)(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable); -typedef void ( *PFN_vkCmdSetRepresentativeFragmentTestEnableNV)(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable); -typedef void ( *PFN_vkCmdSetCoverageReductionModeNV)(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode); -# 17205 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkSubpassMergeStatusEXT { - VK_SUBPASS_MERGE_STATUS_MERGED_EXT = 0, - VK_SUBPASS_MERGE_STATUS_DISALLOWED_EXT = 1, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SIDE_EFFECTS_EXT = 2, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SAMPLES_MISMATCH_EXT = 3, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_VIEWS_MISMATCH_EXT = 4, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_ALIASING_EXT = 5, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPENDENCIES_EXT = 6, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INCOMPATIBLE_INPUT_ATTACHMENT_EXT = 7, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_TOO_MANY_ATTACHMENTS_EXT = 8, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_INSUFFICIENT_STORAGE_EXT = 9, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_DEPTH_STENCIL_COUNT_EXT = 10, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_RESOLVE_ATTACHMENT_REUSE_EXT = 11, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_SINGLE_SUBPASS_EXT = 12, - VK_SUBPASS_MERGE_STATUS_NOT_MERGED_UNSPECIFIED_EXT = 13, - VK_SUBPASS_MERGE_STATUS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkSubpassMergeStatusEXT; -typedef struct VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 subpassMergeFeedback; -} VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT; - -typedef struct VkRenderPassCreationControlEXT { - VkStructureType sType; - const void* pNext; - VkBool32 disallowMerging; -} VkRenderPassCreationControlEXT; - -typedef struct VkRenderPassCreationFeedbackInfoEXT { - uint32_t postMergeSubpassCount; -} VkRenderPassCreationFeedbackInfoEXT; - -typedef struct VkRenderPassCreationFeedbackCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkRenderPassCreationFeedbackInfoEXT* pRenderPassFeedback; -} VkRenderPassCreationFeedbackCreateInfoEXT; - -typedef struct VkRenderPassSubpassFeedbackInfoEXT { - VkSubpassMergeStatusEXT subpassMergeStatus; - char description[256U]; - uint32_t postMergeIndex; -} VkRenderPassSubpassFeedbackInfoEXT; - -typedef struct VkRenderPassSubpassFeedbackCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkRenderPassSubpassFeedbackInfoEXT* pSubpassFeedback; -} VkRenderPassSubpassFeedbackCreateInfoEXT; -# 17263 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkDirectDriverLoadingModeLUNARG { - VK_DIRECT_DRIVER_LOADING_MODE_EXCLUSIVE_LUNARG = 0, - VK_DIRECT_DRIVER_LOADING_MODE_INCLUSIVE_LUNARG = 1, - VK_DIRECT_DRIVER_LOADING_MODE_MAX_ENUM_LUNARG = 0x7FFFFFFF -} VkDirectDriverLoadingModeLUNARG; -typedef VkFlags VkDirectDriverLoadingFlagsLUNARG; -typedef PFN_vkVoidFunction ( *PFN_vkGetInstanceProcAddrLUNARG)( - VkInstance instance, const char* pName); - -typedef struct VkDirectDriverLoadingInfoLUNARG { - VkStructureType sType; - void* pNext; - VkDirectDriverLoadingFlagsLUNARG flags; - PFN_vkGetInstanceProcAddrLUNARG pfnGetInstanceProcAddr; -} VkDirectDriverLoadingInfoLUNARG; - -typedef struct VkDirectDriverLoadingListLUNARG { - VkStructureType sType; - void* pNext; - VkDirectDriverLoadingModeLUNARG mode; - uint32_t driverCount; - const VkDirectDriverLoadingInfoLUNARG* pDrivers; -} VkDirectDriverLoadingListLUNARG; -# 17294 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderModuleIdentifier; -} VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT; - -typedef struct VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT { - VkStructureType sType; - void* pNext; - uint8_t shaderModuleIdentifierAlgorithmUUID[16U]; -} VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT; - -typedef struct VkPipelineShaderStageModuleIdentifierCreateInfoEXT { - VkStructureType sType; - const void* pNext; - uint32_t identifierSize; - const uint8_t* pIdentifier; -} VkPipelineShaderStageModuleIdentifierCreateInfoEXT; - -typedef struct VkShaderModuleIdentifierEXT { - VkStructureType sType; - void* pNext; - uint32_t identifierSize; - uint8_t identifier[32U]; -} VkShaderModuleIdentifierEXT; - -typedef void ( *PFN_vkGetShaderModuleIdentifierEXT)(VkDevice device, VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier); -typedef void ( *PFN_vkGetShaderModuleCreateInfoIdentifierEXT)(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier); -# 17344 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkOpticalFlowSessionNV_T *VkOpticalFlowSessionNV; - - - -typedef enum VkOpticalFlowPerformanceLevelNV { - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_UNKNOWN_NV = 0, - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_SLOW_NV = 1, - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MEDIUM_NV = 2, - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_FAST_NV = 3, - VK_OPTICAL_FLOW_PERFORMANCE_LEVEL_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowPerformanceLevelNV; - -typedef enum VkOpticalFlowSessionBindingPointNV { - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_UNKNOWN_NV = 0, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_INPUT_NV = 1, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_REFERENCE_NV = 2, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_HINT_NV = 3, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_FLOW_VECTOR_NV = 4, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_FLOW_VECTOR_NV = 5, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_COST_NV = 6, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_BACKWARD_COST_NV = 7, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_GLOBAL_FLOW_NV = 8, - VK_OPTICAL_FLOW_SESSION_BINDING_POINT_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowSessionBindingPointNV; - -typedef enum VkOpticalFlowGridSizeFlagBitsNV { - VK_OPTICAL_FLOW_GRID_SIZE_UNKNOWN_NV = 0, - VK_OPTICAL_FLOW_GRID_SIZE_1X1_BIT_NV = 0x00000001, - VK_OPTICAL_FLOW_GRID_SIZE_2X2_BIT_NV = 0x00000002, - VK_OPTICAL_FLOW_GRID_SIZE_4X4_BIT_NV = 0x00000004, - VK_OPTICAL_FLOW_GRID_SIZE_8X8_BIT_NV = 0x00000008, - VK_OPTICAL_FLOW_GRID_SIZE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowGridSizeFlagBitsNV; -typedef VkFlags VkOpticalFlowGridSizeFlagsNV; - -typedef enum VkOpticalFlowUsageFlagBitsNV { - VK_OPTICAL_FLOW_USAGE_UNKNOWN_NV = 0, - VK_OPTICAL_FLOW_USAGE_INPUT_BIT_NV = 0x00000001, - VK_OPTICAL_FLOW_USAGE_OUTPUT_BIT_NV = 0x00000002, - VK_OPTICAL_FLOW_USAGE_HINT_BIT_NV = 0x00000004, - VK_OPTICAL_FLOW_USAGE_COST_BIT_NV = 0x00000008, - VK_OPTICAL_FLOW_USAGE_GLOBAL_FLOW_BIT_NV = 0x00000010, - VK_OPTICAL_FLOW_USAGE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowUsageFlagBitsNV; -typedef VkFlags VkOpticalFlowUsageFlagsNV; - -typedef enum VkOpticalFlowSessionCreateFlagBitsNV { - VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_HINT_BIT_NV = 0x00000001, - VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_COST_BIT_NV = 0x00000002, - VK_OPTICAL_FLOW_SESSION_CREATE_ENABLE_GLOBAL_FLOW_BIT_NV = 0x00000004, - VK_OPTICAL_FLOW_SESSION_CREATE_ALLOW_REGIONS_BIT_NV = 0x00000008, - VK_OPTICAL_FLOW_SESSION_CREATE_BOTH_DIRECTIONS_BIT_NV = 0x00000010, - VK_OPTICAL_FLOW_SESSION_CREATE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowSessionCreateFlagBitsNV; -typedef VkFlags VkOpticalFlowSessionCreateFlagsNV; - -typedef enum VkOpticalFlowExecuteFlagBitsNV { - VK_OPTICAL_FLOW_EXECUTE_DISABLE_TEMPORAL_HINTS_BIT_NV = 0x00000001, - VK_OPTICAL_FLOW_EXECUTE_FLAG_BITS_MAX_ENUM_NV = 0x7FFFFFFF -} VkOpticalFlowExecuteFlagBitsNV; -typedef VkFlags VkOpticalFlowExecuteFlagsNV; -typedef struct VkPhysicalDeviceOpticalFlowFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 opticalFlow; -} VkPhysicalDeviceOpticalFlowFeaturesNV; - -typedef struct VkPhysicalDeviceOpticalFlowPropertiesNV { - VkStructureType sType; - void* pNext; - VkOpticalFlowGridSizeFlagsNV supportedOutputGridSizes; - VkOpticalFlowGridSizeFlagsNV supportedHintGridSizes; - VkBool32 hintSupported; - VkBool32 costSupported; - VkBool32 bidirectionalFlowSupported; - VkBool32 globalFlowSupported; - uint32_t minWidth; - uint32_t minHeight; - uint32_t maxWidth; - uint32_t maxHeight; - uint32_t maxNumRegionsOfInterest; -} VkPhysicalDeviceOpticalFlowPropertiesNV; - -typedef struct VkOpticalFlowImageFormatInfoNV { - VkStructureType sType; - const void* pNext; - VkOpticalFlowUsageFlagsNV usage; -} VkOpticalFlowImageFormatInfoNV; - -typedef struct VkOpticalFlowImageFormatPropertiesNV { - VkStructureType sType; - const void* pNext; - VkFormat format; -} VkOpticalFlowImageFormatPropertiesNV; - -typedef struct VkOpticalFlowSessionCreateInfoNV { - VkStructureType sType; - void* pNext; - uint32_t width; - uint32_t height; - VkFormat imageFormat; - VkFormat flowVectorFormat; - VkFormat costFormat; - VkOpticalFlowGridSizeFlagsNV outputGridSize; - VkOpticalFlowGridSizeFlagsNV hintGridSize; - VkOpticalFlowPerformanceLevelNV performanceLevel; - VkOpticalFlowSessionCreateFlagsNV flags; -} VkOpticalFlowSessionCreateInfoNV; - -typedef struct VkOpticalFlowSessionCreatePrivateDataInfoNV { - VkStructureType sType; - void* pNext; - uint32_t id; - uint32_t size; - const void* pPrivateData; -} VkOpticalFlowSessionCreatePrivateDataInfoNV; - -typedef struct VkOpticalFlowExecuteInfoNV { - VkStructureType sType; - void* pNext; - VkOpticalFlowExecuteFlagsNV flags; - uint32_t regionCount; - const VkRect2D* pRegions; -} VkOpticalFlowExecuteInfoNV; - -typedef VkResult ( *PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV)(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); -typedef VkResult ( *PFN_vkCreateOpticalFlowSessionNV)(VkDevice device, const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession); -typedef void ( *PFN_vkDestroyOpticalFlowSessionNV)(VkDevice device, VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkBindOpticalFlowSessionImageNV)(VkDevice device, VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout); -typedef void ( *PFN_vkCmdOpticalFlowExecuteNV)(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo); -# 17511 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceLegacyDitheringFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 legacyDithering; -} VkPhysicalDeviceLegacyDitheringFeaturesEXT; - - - - - - - -typedef struct VkPhysicalDevicePipelineProtectedAccessFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pipelineProtectedAccess; -} VkPhysicalDevicePipelineProtectedAccessFeaturesEXT; - - - - - -typedef struct VkShaderEXT_T *VkShaderEXT; - - - -typedef enum VkShaderCodeTypeEXT { - VK_SHADER_CODE_TYPE_BINARY_EXT = 0, - VK_SHADER_CODE_TYPE_SPIRV_EXT = 1, - VK_SHADER_CODE_TYPE_MAX_ENUM_EXT = 0x7FFFFFFF -} VkShaderCodeTypeEXT; - -typedef enum VkShaderCreateFlagBitsEXT { - VK_SHADER_CREATE_LINK_STAGE_BIT_EXT = 0x00000001, - VK_SHADER_CREATE_ALLOW_VARYING_SUBGROUP_SIZE_BIT_EXT = 0x00000002, - VK_SHADER_CREATE_REQUIRE_FULL_SUBGROUPS_BIT_EXT = 0x00000004, - VK_SHADER_CREATE_NO_TASK_SHADER_BIT_EXT = 0x00000008, - VK_SHADER_CREATE_DISPATCH_BASE_BIT_EXT = 0x00000010, - VK_SHADER_CREATE_FRAGMENT_SHADING_RATE_ATTACHMENT_BIT_EXT = 0x00000020, - VK_SHADER_CREATE_FRAGMENT_DENSITY_MAP_ATTACHMENT_BIT_EXT = 0x00000040, - VK_SHADER_CREATE_FLAG_BITS_MAX_ENUM_EXT = 0x7FFFFFFF -} VkShaderCreateFlagBitsEXT; -typedef VkFlags VkShaderCreateFlagsEXT; -typedef struct VkPhysicalDeviceShaderObjectFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 shaderObject; -} VkPhysicalDeviceShaderObjectFeaturesEXT; - -typedef struct VkPhysicalDeviceShaderObjectPropertiesEXT { - VkStructureType sType; - void* pNext; - uint8_t shaderBinaryUUID[16U]; - uint32_t shaderBinaryVersion; -} VkPhysicalDeviceShaderObjectPropertiesEXT; - -typedef struct VkShaderCreateInfoEXT { - VkStructureType sType; - const void* pNext; - VkShaderCreateFlagsEXT flags; - VkShaderStageFlagBits stage; - VkShaderStageFlags nextStage; - VkShaderCodeTypeEXT codeType; - size_t codeSize; - const void* pCode; - const char* pName; - uint32_t setLayoutCount; - const VkDescriptorSetLayout* pSetLayouts; - uint32_t pushConstantRangeCount; - const VkPushConstantRange* pPushConstantRanges; - const VkSpecializationInfo* pSpecializationInfo; -} VkShaderCreateInfoEXT; - -typedef VkPipelineShaderStageRequiredSubgroupSizeCreateInfo VkShaderRequiredSubgroupSizeCreateInfoEXT; - -typedef VkResult ( *PFN_vkCreateShadersEXT)(VkDevice device, uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders); -typedef void ( *PFN_vkDestroyShaderEXT)(VkDevice device, VkShaderEXT shader, const VkAllocationCallbacks* pAllocator); -typedef VkResult ( *PFN_vkGetShaderBinaryDataEXT)(VkDevice device, VkShaderEXT shader, size_t* pDataSize, void* pData); -typedef void ( *PFN_vkCmdBindShadersEXT)(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders); -# 17622 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceTilePropertiesFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 tileProperties; -} VkPhysicalDeviceTilePropertiesFeaturesQCOM; - -typedef struct VkTilePropertiesQCOM { - VkStructureType sType; - void* pNext; - VkExtent3D tileSize; - VkExtent2D apronSize; - VkOffset2D origin; -} VkTilePropertiesQCOM; - -typedef VkResult ( *PFN_vkGetFramebufferTilePropertiesQCOM)(VkDevice device, VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties); -typedef VkResult ( *PFN_vkGetDynamicRenderingTilePropertiesQCOM)(VkDevice device, const VkRenderingInfo* pRenderingInfo, VkTilePropertiesQCOM* pProperties); -# 17657 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceAmigoProfilingFeaturesSEC { - VkStructureType sType; - void* pNext; - VkBool32 amigoProfiling; -} VkPhysicalDeviceAmigoProfilingFeaturesSEC; - -typedef struct VkAmigoProfilingSubmitInfoSEC { - VkStructureType sType; - const void* pNext; - uint64_t firstDrawTimestamp; - uint64_t swapBufferTimestamp; -} VkAmigoProfilingSubmitInfoSEC; - - - - - - - -typedef struct VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 multiviewPerViewViewports; -} VkPhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM; -# 17689 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkRayTracingInvocationReorderModeNV { - VK_RAY_TRACING_INVOCATION_REORDER_MODE_NONE_NV = 0, - VK_RAY_TRACING_INVOCATION_REORDER_MODE_REORDER_NV = 1, - VK_RAY_TRACING_INVOCATION_REORDER_MODE_MAX_ENUM_NV = 0x7FFFFFFF -} VkRayTracingInvocationReorderModeNV; -typedef struct VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV { - VkStructureType sType; - void* pNext; - VkRayTracingInvocationReorderModeNV rayTracingInvocationReorderReorderingHint; -} VkPhysicalDeviceRayTracingInvocationReorderPropertiesNV; - -typedef struct VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingInvocationReorder; -} VkPhysicalDeviceRayTracingInvocationReorderFeaturesNV; - - - - - - - -typedef struct VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 extendedSparseAddressSpace; -} VkPhysicalDeviceExtendedSparseAddressSpaceFeaturesNV; - -typedef struct VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV { - VkStructureType sType; - void* pNext; - VkDeviceSize extendedSparseAddressSpaceSize; - VkImageUsageFlags extendedSparseImageUsageFlags; - VkBufferUsageFlags extendedSparseBufferUsageFlags; -} VkPhysicalDeviceExtendedSparseAddressSpacePropertiesNV; -# 17738 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM { - VkStructureType sType; - void* pNext; - VkBool32 shaderCoreBuiltins; -} VkPhysicalDeviceShaderCoreBuiltinsFeaturesARM; - -typedef struct VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM { - VkStructureType sType; - void* pNext; - uint64_t shaderCoreMask; - uint32_t shaderCoreCount; - uint32_t shaderWarpsPerCore; -} VkPhysicalDeviceShaderCoreBuiltinsPropertiesARM; - - - - - - - -typedef struct VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 pipelineLibraryGroupHandles; -} VkPhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT; - - - - - - - -typedef struct VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 dynamicRenderingUnusedAttachments; -} VkPhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT; -# 17783 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkLatencyMarkerNV { - VK_LATENCY_MARKER_SIMULATION_START_NV = 0, - VK_LATENCY_MARKER_SIMULATION_END_NV = 1, - VK_LATENCY_MARKER_RENDERSUBMIT_START_NV = 2, - VK_LATENCY_MARKER_RENDERSUBMIT_END_NV = 3, - VK_LATENCY_MARKER_PRESENT_START_NV = 4, - VK_LATENCY_MARKER_PRESENT_END_NV = 5, - VK_LATENCY_MARKER_INPUT_SAMPLE_NV = 6, - VK_LATENCY_MARKER_TRIGGER_FLASH_NV = 7, - VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_START_NV = 8, - VK_LATENCY_MARKER_OUT_OF_BAND_RENDERSUBMIT_END_NV = 9, - VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_START_NV = 10, - VK_LATENCY_MARKER_OUT_OF_BAND_PRESENT_END_NV = 11, - VK_LATENCY_MARKER_MAX_ENUM_NV = 0x7FFFFFFF -} VkLatencyMarkerNV; - -typedef enum VkOutOfBandQueueTypeNV { - VK_OUT_OF_BAND_QUEUE_TYPE_RENDER_NV = 0, - VK_OUT_OF_BAND_QUEUE_TYPE_PRESENT_NV = 1, - VK_OUT_OF_BAND_QUEUE_TYPE_MAX_ENUM_NV = 0x7FFFFFFF -} VkOutOfBandQueueTypeNV; -typedef struct VkLatencySleepModeInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 lowLatencyMode; - VkBool32 lowLatencyBoost; - uint32_t minimumIntervalUs; -} VkLatencySleepModeInfoNV; - -typedef struct VkLatencySleepInfoNV { - VkStructureType sType; - const void* pNext; - VkSemaphore signalSemaphore; - uint64_t value; -} VkLatencySleepInfoNV; - -typedef struct VkSetLatencyMarkerInfoNV { - VkStructureType sType; - const void* pNext; - uint64_t presentID; - VkLatencyMarkerNV marker; -} VkSetLatencyMarkerInfoNV; - -typedef struct VkLatencyTimingsFrameReportNV { - VkStructureType sType; - const void* pNext; - uint64_t presentID; - uint64_t inputSampleTimeUs; - uint64_t simStartTimeUs; - uint64_t simEndTimeUs; - uint64_t renderSubmitStartTimeUs; - uint64_t renderSubmitEndTimeUs; - uint64_t presentStartTimeUs; - uint64_t presentEndTimeUs; - uint64_t driverStartTimeUs; - uint64_t driverEndTimeUs; - uint64_t osRenderQueueStartTimeUs; - uint64_t osRenderQueueEndTimeUs; - uint64_t gpuRenderStartTimeUs; - uint64_t gpuRenderEndTimeUs; -} VkLatencyTimingsFrameReportNV; - -typedef struct VkGetLatencyMarkerInfoNV { - VkStructureType sType; - const void* pNext; - VkLatencyTimingsFrameReportNV* pTimings; -} VkGetLatencyMarkerInfoNV; - -typedef struct VkLatencySubmissionPresentIdNV { - VkStructureType sType; - const void* pNext; - uint64_t presentID; -} VkLatencySubmissionPresentIdNV; - -typedef struct VkSwapchainLatencyCreateInfoNV { - VkStructureType sType; - const void* pNext; - VkBool32 latencyModeEnable; -} VkSwapchainLatencyCreateInfoNV; - -typedef struct VkOutOfBandQueueTypeInfoNV { - VkStructureType sType; - const void* pNext; - VkOutOfBandQueueTypeNV queueType; -} VkOutOfBandQueueTypeInfoNV; - -typedef struct VkLatencySurfaceCapabilitiesNV { - VkStructureType sType; - const void* pNext; - uint32_t presentModeCount; - VkPresentModeKHR* pPresentModes; -} VkLatencySurfaceCapabilitiesNV; - -typedef VkResult ( *PFN_vkSetLatencySleepModeNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo); -typedef VkResult ( *PFN_vkLatencySleepNV)(VkDevice device, VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo); -typedef void ( *PFN_vkSetLatencyMarkerNV)(VkDevice device, VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo); -typedef void ( *PFN_vkGetLatencyTimingsNV)(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pTimingCount, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo); -typedef void ( *PFN_vkQueueNotifyOutOfBandNV)(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo); -# 17914 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 multiviewPerViewRenderAreas; -} VkPhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM; - -typedef struct VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM { - VkStructureType sType; - const void* pNext; - uint32_t perViewRenderAreaCount; - const VkRect2D* pPerViewRenderAreas; -} VkMultiviewPerViewRenderAreasRenderPassBeginInfoQCOM; -# 17934 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkBlockMatchWindowCompareModeQCOM { - VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MIN_QCOM = 0, - VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_QCOM = 1, - VK_BLOCK_MATCH_WINDOW_COMPARE_MODE_MAX_ENUM_QCOM = 0x7FFFFFFF -} VkBlockMatchWindowCompareModeQCOM; -typedef struct VkPhysicalDeviceImageProcessing2FeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 textureBlockMatch2; -} VkPhysicalDeviceImageProcessing2FeaturesQCOM; - -typedef struct VkPhysicalDeviceImageProcessing2PropertiesQCOM { - VkStructureType sType; - void* pNext; - VkExtent2D maxBlockMatchWindow; -} VkPhysicalDeviceImageProcessing2PropertiesQCOM; - -typedef struct VkSamplerBlockMatchWindowCreateInfoQCOM { - VkStructureType sType; - const void* pNext; - VkExtent2D windowExtent; - VkBlockMatchWindowCompareModeQCOM windowCompareMode; -} VkSamplerBlockMatchWindowCreateInfoQCOM; -# 17965 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkCubicFilterWeightsQCOM { - VK_CUBIC_FILTER_WEIGHTS_CATMULL_ROM_QCOM = 0, - VK_CUBIC_FILTER_WEIGHTS_ZERO_TANGENT_CARDINAL_QCOM = 1, - VK_CUBIC_FILTER_WEIGHTS_B_SPLINE_QCOM = 2, - VK_CUBIC_FILTER_WEIGHTS_MITCHELL_NETRAVALI_QCOM = 3, - VK_CUBIC_FILTER_WEIGHTS_MAX_ENUM_QCOM = 0x7FFFFFFF -} VkCubicFilterWeightsQCOM; -typedef struct VkPhysicalDeviceCubicWeightsFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 selectableCubicWeights; -} VkPhysicalDeviceCubicWeightsFeaturesQCOM; - -typedef struct VkSamplerCubicWeightsCreateInfoQCOM { - VkStructureType sType; - const void* pNext; - VkCubicFilterWeightsQCOM cubicWeights; -} VkSamplerCubicWeightsCreateInfoQCOM; - -typedef struct VkBlitImageCubicWeightsInfoQCOM { - VkStructureType sType; - const void* pNext; - VkCubicFilterWeightsQCOM cubicWeights; -} VkBlitImageCubicWeightsInfoQCOM; - - - - - - - -typedef struct VkPhysicalDeviceYcbcrDegammaFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 ycbcrDegamma; -} VkPhysicalDeviceYcbcrDegammaFeaturesQCOM; - -typedef struct VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM { - VkStructureType sType; - void* pNext; - VkBool32 enableYDegamma; - VkBool32 enableCbCrDegamma; -} VkSamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM; - - - - - - - -typedef struct VkPhysicalDeviceCubicClampFeaturesQCOM { - VkStructureType sType; - void* pNext; - VkBool32 cubicRangeClamp; -} VkPhysicalDeviceCubicClampFeaturesQCOM; - - - - - - - -typedef struct VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 attachmentFeedbackLoopDynamicState; -} VkPhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT; - -typedef void ( *PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT)(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask); -# 18047 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkLayeredDriverUnderlyingApiMSFT { - VK_LAYERED_DRIVER_UNDERLYING_API_NONE_MSFT = 0, - VK_LAYERED_DRIVER_UNDERLYING_API_D3D12_MSFT = 1, - VK_LAYERED_DRIVER_UNDERLYING_API_MAX_ENUM_MSFT = 0x7FFFFFFF -} VkLayeredDriverUnderlyingApiMSFT; -typedef struct VkPhysicalDeviceLayeredDriverPropertiesMSFT { - VkStructureType sType; - void* pNext; - VkLayeredDriverUnderlyingApiMSFT underlyingAPI; -} VkPhysicalDeviceLayeredDriverPropertiesMSFT; - - - - - - - -typedef struct VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV { - VkStructureType sType; - void* pNext; - VkBool32 descriptorPoolOverallocation; -} VkPhysicalDeviceDescriptorPoolOverallocationFeaturesNV; -# 18077 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkBuildAccelerationStructureModeKHR { - VK_BUILD_ACCELERATION_STRUCTURE_MODE_BUILD_KHR = 0, - VK_BUILD_ACCELERATION_STRUCTURE_MODE_UPDATE_KHR = 1, - VK_BUILD_ACCELERATION_STRUCTURE_MODE_MAX_ENUM_KHR = 0x7FFFFFFF -} VkBuildAccelerationStructureModeKHR; - -typedef enum VkAccelerationStructureCreateFlagBitsKHR { - VK_ACCELERATION_STRUCTURE_CREATE_DEVICE_ADDRESS_CAPTURE_REPLAY_BIT_KHR = 0x00000001, - VK_ACCELERATION_STRUCTURE_CREATE_DESCRIPTOR_BUFFER_CAPTURE_REPLAY_BIT_EXT = 0x00000008, - VK_ACCELERATION_STRUCTURE_CREATE_MOTION_BIT_NV = 0x00000004, - VK_ACCELERATION_STRUCTURE_CREATE_FLAG_BITS_MAX_ENUM_KHR = 0x7FFFFFFF -} VkAccelerationStructureCreateFlagBitsKHR; -typedef VkFlags VkAccelerationStructureCreateFlagsKHR; -typedef struct VkAccelerationStructureBuildRangeInfoKHR { - uint32_t primitiveCount; - uint32_t primitiveOffset; - uint32_t firstVertex; - uint32_t transformOffset; -} VkAccelerationStructureBuildRangeInfoKHR; - -typedef struct VkAccelerationStructureGeometryTrianglesDataKHR { - VkStructureType sType; - const void* pNext; - VkFormat vertexFormat; - VkDeviceOrHostAddressConstKHR vertexData; - VkDeviceSize vertexStride; - uint32_t maxVertex; - VkIndexType indexType; - VkDeviceOrHostAddressConstKHR indexData; - VkDeviceOrHostAddressConstKHR transformData; -} VkAccelerationStructureGeometryTrianglesDataKHR; - -typedef struct VkAccelerationStructureGeometryAabbsDataKHR { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR data; - VkDeviceSize stride; -} VkAccelerationStructureGeometryAabbsDataKHR; - -typedef struct VkAccelerationStructureGeometryInstancesDataKHR { - VkStructureType sType; - const void* pNext; - VkBool32 arrayOfPointers; - VkDeviceOrHostAddressConstKHR data; -} VkAccelerationStructureGeometryInstancesDataKHR; - -typedef union VkAccelerationStructureGeometryDataKHR { - VkAccelerationStructureGeometryTrianglesDataKHR triangles; - VkAccelerationStructureGeometryAabbsDataKHR aabbs; - VkAccelerationStructureGeometryInstancesDataKHR instances; -} VkAccelerationStructureGeometryDataKHR; - -typedef struct VkAccelerationStructureGeometryKHR { - VkStructureType sType; - const void* pNext; - VkGeometryTypeKHR geometryType; - VkAccelerationStructureGeometryDataKHR geometry; - VkGeometryFlagsKHR flags; -} VkAccelerationStructureGeometryKHR; - -typedef struct VkAccelerationStructureBuildGeometryInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureTypeKHR type; - VkBuildAccelerationStructureFlagsKHR flags; - VkBuildAccelerationStructureModeKHR mode; - VkAccelerationStructureKHR srcAccelerationStructure; - VkAccelerationStructureKHR dstAccelerationStructure; - uint32_t geometryCount; - const VkAccelerationStructureGeometryKHR* pGeometries; - const VkAccelerationStructureGeometryKHR* const* ppGeometries; - VkDeviceOrHostAddressKHR scratchData; -} VkAccelerationStructureBuildGeometryInfoKHR; - -typedef struct VkAccelerationStructureCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureCreateFlagsKHR createFlags; - VkBuffer buffer; - VkDeviceSize offset; - VkDeviceSize size; - VkAccelerationStructureTypeKHR type; - VkDeviceAddress deviceAddress; -} VkAccelerationStructureCreateInfoKHR; - -typedef struct VkWriteDescriptorSetAccelerationStructureKHR { - VkStructureType sType; - const void* pNext; - uint32_t accelerationStructureCount; - const VkAccelerationStructureKHR* pAccelerationStructures; -} VkWriteDescriptorSetAccelerationStructureKHR; - -typedef struct VkPhysicalDeviceAccelerationStructureFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 accelerationStructure; - VkBool32 accelerationStructureCaptureReplay; - VkBool32 accelerationStructureIndirectBuild; - VkBool32 accelerationStructureHostCommands; - VkBool32 descriptorBindingAccelerationStructureUpdateAfterBind; -} VkPhysicalDeviceAccelerationStructureFeaturesKHR; - -typedef struct VkPhysicalDeviceAccelerationStructurePropertiesKHR { - VkStructureType sType; - void* pNext; - uint64_t maxGeometryCount; - uint64_t maxInstanceCount; - uint64_t maxPrimitiveCount; - uint32_t maxPerStageDescriptorAccelerationStructures; - uint32_t maxPerStageDescriptorUpdateAfterBindAccelerationStructures; - uint32_t maxDescriptorSetAccelerationStructures; - uint32_t maxDescriptorSetUpdateAfterBindAccelerationStructures; - uint32_t minAccelerationStructureScratchOffsetAlignment; -} VkPhysicalDeviceAccelerationStructurePropertiesKHR; - -typedef struct VkAccelerationStructureDeviceAddressInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR accelerationStructure; -} VkAccelerationStructureDeviceAddressInfoKHR; - -typedef struct VkAccelerationStructureVersionInfoKHR { - VkStructureType sType; - const void* pNext; - const uint8_t* pVersionData; -} VkAccelerationStructureVersionInfoKHR; - -typedef struct VkCopyAccelerationStructureToMemoryInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR src; - VkDeviceOrHostAddressKHR dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyAccelerationStructureToMemoryInfoKHR; - -typedef struct VkCopyMemoryToAccelerationStructureInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceOrHostAddressConstKHR src; - VkAccelerationStructureKHR dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyMemoryToAccelerationStructureInfoKHR; - -typedef struct VkCopyAccelerationStructureInfoKHR { - VkStructureType sType; - const void* pNext; - VkAccelerationStructureKHR src; - VkAccelerationStructureKHR dst; - VkCopyAccelerationStructureModeKHR mode; -} VkCopyAccelerationStructureInfoKHR; - -typedef struct VkAccelerationStructureBuildSizesInfoKHR { - VkStructureType sType; - const void* pNext; - VkDeviceSize accelerationStructureSize; - VkDeviceSize updateScratchSize; - VkDeviceSize buildScratchSize; -} VkAccelerationStructureBuildSizesInfoKHR; - -typedef VkResult ( *PFN_vkCreateAccelerationStructureKHR)(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure); -typedef void ( *PFN_vkDestroyAccelerationStructureKHR)(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator); -typedef void ( *PFN_vkCmdBuildAccelerationStructuresKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); -typedef void ( *PFN_vkCmdBuildAccelerationStructuresIndirectKHR)(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts); -typedef VkResult ( *PFN_vkBuildAccelerationStructuresKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); -typedef VkResult ( *PFN_vkCopyAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo); -typedef VkResult ( *PFN_vkCopyAccelerationStructureToMemoryKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -typedef VkResult ( *PFN_vkCopyMemoryToAccelerationStructureKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -typedef VkResult ( *PFN_vkWriteAccelerationStructuresPropertiesKHR)(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride); -typedef void ( *PFN_vkCmdCopyAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo); -typedef void ( *PFN_vkCmdCopyAccelerationStructureToMemoryKHR)(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); -typedef void ( *PFN_vkCmdCopyMemoryToAccelerationStructureKHR)(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); -typedef VkDeviceAddress ( *PFN_vkGetAccelerationStructureDeviceAddressKHR)(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); -typedef void ( *PFN_vkCmdWriteAccelerationStructuresPropertiesKHR)(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery); -typedef void ( *PFN_vkGetDeviceAccelerationStructureCompatibilityKHR)(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility); -typedef void ( *PFN_vkGetAccelerationStructureBuildSizesKHR)(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); -# 18353 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef enum VkShaderGroupShaderKHR { - VK_SHADER_GROUP_SHADER_GENERAL_KHR = 0, - VK_SHADER_GROUP_SHADER_CLOSEST_HIT_KHR = 1, - VK_SHADER_GROUP_SHADER_ANY_HIT_KHR = 2, - VK_SHADER_GROUP_SHADER_INTERSECTION_KHR = 3, - VK_SHADER_GROUP_SHADER_MAX_ENUM_KHR = 0x7FFFFFFF -} VkShaderGroupShaderKHR; -typedef struct VkRayTracingShaderGroupCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkRayTracingShaderGroupTypeKHR type; - uint32_t generalShader; - uint32_t closestHitShader; - uint32_t anyHitShader; - uint32_t intersectionShader; - const void* pShaderGroupCaptureReplayHandle; -} VkRayTracingShaderGroupCreateInfoKHR; - -typedef struct VkRayTracingPipelineInterfaceCreateInfoKHR { - VkStructureType sType; - const void* pNext; - uint32_t maxPipelineRayPayloadSize; - uint32_t maxPipelineRayHitAttributeSize; -} VkRayTracingPipelineInterfaceCreateInfoKHR; - -typedef struct VkRayTracingPipelineCreateInfoKHR { - VkStructureType sType; - const void* pNext; - VkPipelineCreateFlags flags; - uint32_t stageCount; - const VkPipelineShaderStageCreateInfo* pStages; - uint32_t groupCount; - const VkRayTracingShaderGroupCreateInfoKHR* pGroups; - uint32_t maxPipelineRayRecursionDepth; - const VkPipelineLibraryCreateInfoKHR* pLibraryInfo; - const VkRayTracingPipelineInterfaceCreateInfoKHR* pLibraryInterface; - const VkPipelineDynamicStateCreateInfo* pDynamicState; - VkPipelineLayout layout; - VkPipeline basePipelineHandle; - int32_t basePipelineIndex; -} VkRayTracingPipelineCreateInfoKHR; - -typedef struct VkPhysicalDeviceRayTracingPipelineFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayTracingPipeline; - VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplay; - VkBool32 rayTracingPipelineShaderGroupHandleCaptureReplayMixed; - VkBool32 rayTracingPipelineTraceRaysIndirect; - VkBool32 rayTraversalPrimitiveCulling; -} VkPhysicalDeviceRayTracingPipelineFeaturesKHR; - -typedef struct VkPhysicalDeviceRayTracingPipelinePropertiesKHR { - VkStructureType sType; - void* pNext; - uint32_t shaderGroupHandleSize; - uint32_t maxRayRecursionDepth; - uint32_t maxShaderGroupStride; - uint32_t shaderGroupBaseAlignment; - uint32_t shaderGroupHandleCaptureReplaySize; - uint32_t maxRayDispatchInvocationCount; - uint32_t shaderGroupHandleAlignment; - uint32_t maxRayHitAttributeSize; -} VkPhysicalDeviceRayTracingPipelinePropertiesKHR; - -typedef struct VkStridedDeviceAddressRegionKHR { - VkDeviceAddress deviceAddress; - VkDeviceSize stride; - VkDeviceSize size; -} VkStridedDeviceAddressRegionKHR; - -typedef struct VkTraceRaysIndirectCommandKHR { - uint32_t width; - uint32_t height; - uint32_t depth; -} VkTraceRaysIndirectCommandKHR; - -typedef void ( *PFN_vkCmdTraceRaysKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth); -typedef VkResult ( *PFN_vkCreateRayTracingPipelinesKHR)(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); -typedef VkResult ( *PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR)(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData); -typedef void ( *PFN_vkCmdTraceRaysIndirectKHR)(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress); -typedef VkDeviceSize ( *PFN_vkGetRayTracingShaderGroupStackSizeKHR)(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader); -typedef void ( *PFN_vkCmdSetRayTracingPipelineStackSizeKHR)(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize); -# 18489 "/usr/include/vulkan/vulkan_core.h" 3 4 -typedef struct VkPhysicalDeviceRayQueryFeaturesKHR { - VkStructureType sType; - void* pNext; - VkBool32 rayQuery; -} VkPhysicalDeviceRayQueryFeaturesKHR; - - - - - - - -typedef struct VkPhysicalDeviceMeshShaderFeaturesEXT { - VkStructureType sType; - void* pNext; - VkBool32 taskShader; - VkBool32 meshShader; - VkBool32 multiviewMeshShader; - VkBool32 primitiveFragmentShadingRateMeshShader; - VkBool32 meshShaderQueries; -} VkPhysicalDeviceMeshShaderFeaturesEXT; - -typedef struct VkPhysicalDeviceMeshShaderPropertiesEXT { - VkStructureType sType; - void* pNext; - uint32_t maxTaskWorkGroupTotalCount; - uint32_t maxTaskWorkGroupCount[3]; - uint32_t maxTaskWorkGroupInvocations; - uint32_t maxTaskWorkGroupSize[3]; - uint32_t maxTaskPayloadSize; - uint32_t maxTaskSharedMemorySize; - uint32_t maxTaskPayloadAndSharedMemorySize; - uint32_t maxMeshWorkGroupTotalCount; - uint32_t maxMeshWorkGroupCount[3]; - uint32_t maxMeshWorkGroupInvocations; - uint32_t maxMeshWorkGroupSize[3]; - uint32_t maxMeshSharedMemorySize; - uint32_t maxMeshPayloadAndSharedMemorySize; - uint32_t maxMeshOutputMemorySize; - uint32_t maxMeshPayloadAndOutputMemorySize; - uint32_t maxMeshOutputComponents; - uint32_t maxMeshOutputVertices; - uint32_t maxMeshOutputPrimitives; - uint32_t maxMeshOutputLayers; - uint32_t maxMeshMultiviewViewCount; - uint32_t meshOutputPerVertexGranularity; - uint32_t meshOutputPerPrimitiveGranularity; - uint32_t maxPreferredTaskWorkGroupInvocations; - uint32_t maxPreferredMeshWorkGroupInvocations; - VkBool32 prefersLocalInvocationVertexOutput; - VkBool32 prefersLocalInvocationPrimitiveOutput; - VkBool32 prefersCompactVertexOutput; - VkBool32 prefersCompactPrimitiveOutput; -} VkPhysicalDeviceMeshShaderPropertiesEXT; - -typedef struct VkDrawMeshTasksIndirectCommandEXT { - uint32_t groupCountX; - uint32_t groupCountY; - uint32_t groupCountZ; -} VkDrawMeshTasksIndirectCommandEXT; - -typedef void ( *PFN_vkCmdDrawMeshTasksEXT)(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ); -typedef void ( *PFN_vkCmdDrawMeshTasksIndirectEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); -typedef void ( *PFN_vkCmdDrawMeshTasksIndirectCountEXT)(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride); -# 18579 "/usr/include/vulkan/vulkan_core.h" 3 4 -} -# 12 "/usr/include/vulkan/vulkan.h" 2 3 4 -# 51 "third_party/volk.h" 2 -# 63 "third_party/volk.h" -extern "C" { - - -struct VolkDeviceTable; - - - - - - -VkResult volkInitialize(void); -# 82 "third_party/volk.h" -void volkInitializeCustom(PFN_vkGetInstanceProcAddr handler); - - - - - - -uint32_t volkGetInstanceVersion(void); - - - - -void volkLoadInstance(VkInstance instance); - - - - - -void volkLoadInstanceOnly(VkInstance instance); - - - - - - -void volkLoadDevice(VkDevice device); - - - - - -VkInstance volkGetLoadedInstance(void); - - - - - -VkDevice volkGetLoadedDevice(void); - - - - - -void volkLoadDeviceTable(struct VolkDeviceTable* table, VkDevice device); - - - - -struct VolkDeviceTable -{ - - - PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers; - PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets; - PFN_vkAllocateMemory vkAllocateMemory; - PFN_vkBeginCommandBuffer vkBeginCommandBuffer; - PFN_vkBindBufferMemory vkBindBufferMemory; - PFN_vkBindImageMemory vkBindImageMemory; - PFN_vkCmdBeginQuery vkCmdBeginQuery; - PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass; - PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets; - PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer; - PFN_vkCmdBindPipeline vkCmdBindPipeline; - PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers; - PFN_vkCmdBlitImage vkCmdBlitImage; - PFN_vkCmdClearAttachments vkCmdClearAttachments; - PFN_vkCmdClearColorImage vkCmdClearColorImage; - PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage; - PFN_vkCmdCopyBuffer vkCmdCopyBuffer; - PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage; - PFN_vkCmdCopyImage vkCmdCopyImage; - PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer; - PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults; - PFN_vkCmdDispatch vkCmdDispatch; - PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect; - PFN_vkCmdDraw vkCmdDraw; - PFN_vkCmdDrawIndexed vkCmdDrawIndexed; - PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect; - PFN_vkCmdDrawIndirect vkCmdDrawIndirect; - PFN_vkCmdEndQuery vkCmdEndQuery; - PFN_vkCmdEndRenderPass vkCmdEndRenderPass; - PFN_vkCmdExecuteCommands vkCmdExecuteCommands; - PFN_vkCmdFillBuffer vkCmdFillBuffer; - PFN_vkCmdNextSubpass vkCmdNextSubpass; - PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier; - PFN_vkCmdPushConstants vkCmdPushConstants; - PFN_vkCmdResetEvent vkCmdResetEvent; - PFN_vkCmdResetQueryPool vkCmdResetQueryPool; - PFN_vkCmdResolveImage vkCmdResolveImage; - PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants; - PFN_vkCmdSetDepthBias vkCmdSetDepthBias; - PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds; - PFN_vkCmdSetEvent vkCmdSetEvent; - PFN_vkCmdSetLineWidth vkCmdSetLineWidth; - PFN_vkCmdSetScissor vkCmdSetScissor; - PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask; - PFN_vkCmdSetStencilReference vkCmdSetStencilReference; - PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask; - PFN_vkCmdSetViewport vkCmdSetViewport; - PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer; - PFN_vkCmdWaitEvents vkCmdWaitEvents; - PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp; - PFN_vkCreateBuffer vkCreateBuffer; - PFN_vkCreateBufferView vkCreateBufferView; - PFN_vkCreateCommandPool vkCreateCommandPool; - PFN_vkCreateComputePipelines vkCreateComputePipelines; - PFN_vkCreateDescriptorPool vkCreateDescriptorPool; - PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout; - PFN_vkCreateEvent vkCreateEvent; - PFN_vkCreateFence vkCreateFence; - PFN_vkCreateFramebuffer vkCreateFramebuffer; - PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines; - PFN_vkCreateImage vkCreateImage; - PFN_vkCreateImageView vkCreateImageView; - PFN_vkCreatePipelineCache vkCreatePipelineCache; - PFN_vkCreatePipelineLayout vkCreatePipelineLayout; - PFN_vkCreateQueryPool vkCreateQueryPool; - PFN_vkCreateRenderPass vkCreateRenderPass; - PFN_vkCreateSampler vkCreateSampler; - PFN_vkCreateSemaphore vkCreateSemaphore; - PFN_vkCreateShaderModule vkCreateShaderModule; - PFN_vkDestroyBuffer vkDestroyBuffer; - PFN_vkDestroyBufferView vkDestroyBufferView; - PFN_vkDestroyCommandPool vkDestroyCommandPool; - PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool; - PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout; - PFN_vkDestroyDevice vkDestroyDevice; - PFN_vkDestroyEvent vkDestroyEvent; - PFN_vkDestroyFence vkDestroyFence; - PFN_vkDestroyFramebuffer vkDestroyFramebuffer; - PFN_vkDestroyImage vkDestroyImage; - PFN_vkDestroyImageView vkDestroyImageView; - PFN_vkDestroyPipeline vkDestroyPipeline; - PFN_vkDestroyPipelineCache vkDestroyPipelineCache; - PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout; - PFN_vkDestroyQueryPool vkDestroyQueryPool; - PFN_vkDestroyRenderPass vkDestroyRenderPass; - PFN_vkDestroySampler vkDestroySampler; - PFN_vkDestroySemaphore vkDestroySemaphore; - PFN_vkDestroyShaderModule vkDestroyShaderModule; - PFN_vkDeviceWaitIdle vkDeviceWaitIdle; - PFN_vkEndCommandBuffer vkEndCommandBuffer; - PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges; - PFN_vkFreeCommandBuffers vkFreeCommandBuffers; - PFN_vkFreeDescriptorSets vkFreeDescriptorSets; - PFN_vkFreeMemory vkFreeMemory; - PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements; - PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment; - PFN_vkGetDeviceQueue vkGetDeviceQueue; - PFN_vkGetEventStatus vkGetEventStatus; - PFN_vkGetFenceStatus vkGetFenceStatus; - PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; - PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements; - PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout; - PFN_vkGetPipelineCacheData vkGetPipelineCacheData; - PFN_vkGetQueryPoolResults vkGetQueryPoolResults; - PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity; - PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges; - PFN_vkMapMemory vkMapMemory; - PFN_vkMergePipelineCaches vkMergePipelineCaches; - PFN_vkQueueBindSparse vkQueueBindSparse; - PFN_vkQueueSubmit vkQueueSubmit; - PFN_vkQueueWaitIdle vkQueueWaitIdle; - PFN_vkResetCommandBuffer vkResetCommandBuffer; - PFN_vkResetCommandPool vkResetCommandPool; - PFN_vkResetDescriptorPool vkResetDescriptorPool; - PFN_vkResetEvent vkResetEvent; - PFN_vkResetFences vkResetFences; - PFN_vkSetEvent vkSetEvent; - PFN_vkUnmapMemory vkUnmapMemory; - PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets; - PFN_vkWaitForFences vkWaitForFences; - - - PFN_vkBindBufferMemory2 vkBindBufferMemory2; - PFN_vkBindImageMemory2 vkBindImageMemory2; - PFN_vkCmdDispatchBase vkCmdDispatchBase; - PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask; - PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate; - PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion; - PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate; - PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion; - PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2; - PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport; - PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures; - PFN_vkGetDeviceQueue2 vkGetDeviceQueue2; - PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2; - PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2; - PFN_vkTrimCommandPool vkTrimCommandPool; - PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate; - - - PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2; - PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount; - PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount; - PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2; - PFN_vkCmdNextSubpass2 vkCmdNextSubpass2; - PFN_vkCreateRenderPass2 vkCreateRenderPass2; - PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress; - PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress; - PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress; - PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue; - PFN_vkResetQueryPool vkResetQueryPool; - PFN_vkSignalSemaphore vkSignalSemaphore; - PFN_vkWaitSemaphores vkWaitSemaphores; - - - PFN_vkCmdBeginRendering vkCmdBeginRendering; - PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2; - PFN_vkCmdBlitImage2 vkCmdBlitImage2; - PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2; - PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2; - PFN_vkCmdCopyImage2 vkCmdCopyImage2; - PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2; - PFN_vkCmdEndRendering vkCmdEndRendering; - PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2; - PFN_vkCmdResetEvent2 vkCmdResetEvent2; - PFN_vkCmdResolveImage2 vkCmdResolveImage2; - PFN_vkCmdSetCullMode vkCmdSetCullMode; - PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable; - PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable; - PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp; - PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable; - PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable; - PFN_vkCmdSetEvent2 vkCmdSetEvent2; - PFN_vkCmdSetFrontFace vkCmdSetFrontFace; - PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable; - PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology; - PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable; - PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount; - PFN_vkCmdSetStencilOp vkCmdSetStencilOp; - PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable; - PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount; - PFN_vkCmdWaitEvents2 vkCmdWaitEvents2; - PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2; - PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot; - PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot; - PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements; - PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements; - PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements; - PFN_vkGetPrivateData vkGetPrivateData; - PFN_vkQueueSubmit2 vkQueueSubmit2; - PFN_vkSetPrivateData vkSetPrivateData; - - - PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD; - - - PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD; - - - PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD; - PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD; - - - PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD; - - - - - - - PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT; - - - PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT; - - - PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT; - - - PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT; - PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT; - - - PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT; - PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT; - PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT; - PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT; - PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT; - - - PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT; - PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT; - PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT; - PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT; - PFN_vkGetDescriptorEXT vkGetDescriptorEXT; - PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT; - PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT; - PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT; - PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT; - PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT; - - - PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT; - - - PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT; - - - PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT; - - - PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT; - PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT; - PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT; - PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT; - - - PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT; - PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT; - PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT; - PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT; - PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT; - PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT; - PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT; - PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT; - PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT; - PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT; - PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT; - PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT; - - - PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT; - PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT; - PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT; - PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT; - PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT; - - - PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT; - PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT; - PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT; - PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT; - PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT; - PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT; - PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT; - PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV; - PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV; - PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV; - PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV; - PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV; - PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV; - PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT; - PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT; - PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT; - PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT; - PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT; - PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT; - PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT; - PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT; - PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT; - PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT; - PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT; - PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV; - PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT; - PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT; - PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV; - PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT; - PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV; - PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV; - - - PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT; - - - - - - - PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT; - - - PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT; - - - PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT; - - - PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT; - - - PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT; - - - PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT; - PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT; - PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT; - - - - - - PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT; - PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT; - - - PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT; - PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT; - PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT; - PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT; - PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT; - PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT; - PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT; - PFN_vkCopyMicromapEXT vkCopyMicromapEXT; - PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT; - PFN_vkCreateMicromapEXT vkCreateMicromapEXT; - PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT; - PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT; - PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT; - PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT; - - - PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT; - - - PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT; - - - PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT; - PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT; - PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT; - PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT; - - - PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT; - - - PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT; - PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT; - - - PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT; - - - PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT; - PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT; - PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT; - PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT; - PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT; - PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT; - - - PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT; - PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT; - PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT; - PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT; - - - PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT; -# 549 "third_party/volk.h" - PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE; - PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE; - - - PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI; - - - PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI; - PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI; - - - PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL; - PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL; - PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL; - PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL; - PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL; - PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL; - PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL; - PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL; - PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL; - - - PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR; - PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR; - PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR; - PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR; - PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR; - PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR; - PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR; - PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR; - PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR; - PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR; - PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR; - PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR; - PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR; - PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR; - PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR; - PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR; - - - PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR; - PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR; - - - PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR; - PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR; - PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR; - - - PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR; - PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR; - PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR; - PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR; - PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR; - PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR; - - - PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR; - PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR; - PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR; - PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR; - - - PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR; - PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR; - PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR; - PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR; - PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR; - - - PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR; - PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR; - PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR; - - - PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR; - PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR; - PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR; - - - PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR; - - - PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR; - PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR; - - - PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR; - PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR; - - - PFN_vkGetFenceFdKHR vkGetFenceFdKHR; - PFN_vkImportFenceFdKHR vkImportFenceFdKHR; - - - - - - - PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR; - PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR; - - - - - - - PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR; - PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR; - - - - - - - PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR; - - - PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR; - PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR; - PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR; - - - PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR; - - - PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR; - - - PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR; - PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR; - PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR; - - - PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR; - PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR; - - - PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR; - PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR; - PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR; - - - PFN_vkWaitForPresentKHR vkWaitForPresentKHR; - - - PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR; - - - PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR; - - - PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR; - PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR; - PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR; - PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR; - PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; - PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR; - PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR; - - - PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR; - PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR; - - - PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR; - - - PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR; - PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR; - PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR; - PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; - PFN_vkQueuePresentKHR vkQueuePresentKHR; - - - PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR; - PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR; - PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR; - PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR; - PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR; - PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR; - - - PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD; - - - PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV; - - - PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR; - PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR; - PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR; - - - PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR; - - - - - - PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR; - PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR; - PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR; - PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR; - PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR; - PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR; - PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR; - PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR; - PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR; - PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR; - - - PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX; - PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX; - PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX; - PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX; - PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX; - - - PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX; - PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX; - - - PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV; - - - PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV; - PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV; - - - PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV; - PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV; - - - PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV; - PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV; - PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV; - PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV; - PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV; - PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV; - - - PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV; - - - - - - PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV; - - - PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV; - PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV; - - - PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV; - PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV; - PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV; - - - PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV; - PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV; - PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV; - PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV; - - - PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV; - PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV; - PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV; - PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV; - PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV; - PFN_vkCompileDeferredNV vkCompileDeferredNV; - PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV; - PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV; - PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV; - PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV; - PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV; - PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV; - - - PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV; - - - PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV; - PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV; - PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV; - - - PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM; - PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM; - - - PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE; - PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE; - - - - - - PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR; - - - PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR; - PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR; - - - PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR; - - -}; - - - -extern PFN_vkAllocateCommandBuffers vkAllocateCommandBuffers; -extern PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets; -extern PFN_vkAllocateMemory vkAllocateMemory; -extern PFN_vkBeginCommandBuffer vkBeginCommandBuffer; -extern PFN_vkBindBufferMemory vkBindBufferMemory; -extern PFN_vkBindImageMemory vkBindImageMemory; -extern PFN_vkCmdBeginQuery vkCmdBeginQuery; -extern PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass; -extern PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets; -extern PFN_vkCmdBindIndexBuffer vkCmdBindIndexBuffer; -extern PFN_vkCmdBindPipeline vkCmdBindPipeline; -extern PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers; -extern PFN_vkCmdBlitImage vkCmdBlitImage; -extern PFN_vkCmdClearAttachments vkCmdClearAttachments; -extern PFN_vkCmdClearColorImage vkCmdClearColorImage; -extern PFN_vkCmdClearDepthStencilImage vkCmdClearDepthStencilImage; -extern PFN_vkCmdCopyBuffer vkCmdCopyBuffer; -extern PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage; -extern PFN_vkCmdCopyImage vkCmdCopyImage; -extern PFN_vkCmdCopyImageToBuffer vkCmdCopyImageToBuffer; -extern PFN_vkCmdCopyQueryPoolResults vkCmdCopyQueryPoolResults; -extern PFN_vkCmdDispatch vkCmdDispatch; -extern PFN_vkCmdDispatchIndirect vkCmdDispatchIndirect; -extern PFN_vkCmdDraw vkCmdDraw; -extern PFN_vkCmdDrawIndexed vkCmdDrawIndexed; -extern PFN_vkCmdDrawIndexedIndirect vkCmdDrawIndexedIndirect; -extern PFN_vkCmdDrawIndirect vkCmdDrawIndirect; -extern PFN_vkCmdEndQuery vkCmdEndQuery; -extern PFN_vkCmdEndRenderPass vkCmdEndRenderPass; -extern PFN_vkCmdExecuteCommands vkCmdExecuteCommands; -extern PFN_vkCmdFillBuffer vkCmdFillBuffer; -extern PFN_vkCmdNextSubpass vkCmdNextSubpass; -extern PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier; -extern PFN_vkCmdPushConstants vkCmdPushConstants; -extern PFN_vkCmdResetEvent vkCmdResetEvent; -extern PFN_vkCmdResetQueryPool vkCmdResetQueryPool; -extern PFN_vkCmdResolveImage vkCmdResolveImage; -extern PFN_vkCmdSetBlendConstants vkCmdSetBlendConstants; -extern PFN_vkCmdSetDepthBias vkCmdSetDepthBias; -extern PFN_vkCmdSetDepthBounds vkCmdSetDepthBounds; -extern PFN_vkCmdSetEvent vkCmdSetEvent; -extern PFN_vkCmdSetLineWidth vkCmdSetLineWidth; -extern PFN_vkCmdSetScissor vkCmdSetScissor; -extern PFN_vkCmdSetStencilCompareMask vkCmdSetStencilCompareMask; -extern PFN_vkCmdSetStencilReference vkCmdSetStencilReference; -extern PFN_vkCmdSetStencilWriteMask vkCmdSetStencilWriteMask; -extern PFN_vkCmdSetViewport vkCmdSetViewport; -extern PFN_vkCmdUpdateBuffer vkCmdUpdateBuffer; -extern PFN_vkCmdWaitEvents vkCmdWaitEvents; -extern PFN_vkCmdWriteTimestamp vkCmdWriteTimestamp; -extern PFN_vkCreateBuffer vkCreateBuffer; -extern PFN_vkCreateBufferView vkCreateBufferView; -extern PFN_vkCreateCommandPool vkCreateCommandPool; -extern PFN_vkCreateComputePipelines vkCreateComputePipelines; -extern PFN_vkCreateDescriptorPool vkCreateDescriptorPool; -extern PFN_vkCreateDescriptorSetLayout vkCreateDescriptorSetLayout; -extern PFN_vkCreateDevice vkCreateDevice; -extern PFN_vkCreateEvent vkCreateEvent; -extern PFN_vkCreateFence vkCreateFence; -extern PFN_vkCreateFramebuffer vkCreateFramebuffer; -extern PFN_vkCreateGraphicsPipelines vkCreateGraphicsPipelines; -extern PFN_vkCreateImage vkCreateImage; -extern PFN_vkCreateImageView vkCreateImageView; -extern PFN_vkCreateInstance vkCreateInstance; -extern PFN_vkCreatePipelineCache vkCreatePipelineCache; -extern PFN_vkCreatePipelineLayout vkCreatePipelineLayout; -extern PFN_vkCreateQueryPool vkCreateQueryPool; -extern PFN_vkCreateRenderPass vkCreateRenderPass; -extern PFN_vkCreateSampler vkCreateSampler; -extern PFN_vkCreateSemaphore vkCreateSemaphore; -extern PFN_vkCreateShaderModule vkCreateShaderModule; -extern PFN_vkDestroyBuffer vkDestroyBuffer; -extern PFN_vkDestroyBufferView vkDestroyBufferView; -extern PFN_vkDestroyCommandPool vkDestroyCommandPool; -extern PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool; -extern PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout; -extern PFN_vkDestroyDevice vkDestroyDevice; -extern PFN_vkDestroyEvent vkDestroyEvent; -extern PFN_vkDestroyFence vkDestroyFence; -extern PFN_vkDestroyFramebuffer vkDestroyFramebuffer; -extern PFN_vkDestroyImage vkDestroyImage; -extern PFN_vkDestroyImageView vkDestroyImageView; -extern PFN_vkDestroyInstance vkDestroyInstance; -extern PFN_vkDestroyPipeline vkDestroyPipeline; -extern PFN_vkDestroyPipelineCache vkDestroyPipelineCache; -extern PFN_vkDestroyPipelineLayout vkDestroyPipelineLayout; -extern PFN_vkDestroyQueryPool vkDestroyQueryPool; -extern PFN_vkDestroyRenderPass vkDestroyRenderPass; -extern PFN_vkDestroySampler vkDestroySampler; -extern PFN_vkDestroySemaphore vkDestroySemaphore; -extern PFN_vkDestroyShaderModule vkDestroyShaderModule; -extern PFN_vkDeviceWaitIdle vkDeviceWaitIdle; -extern PFN_vkEndCommandBuffer vkEndCommandBuffer; -extern PFN_vkEnumerateDeviceExtensionProperties vkEnumerateDeviceExtensionProperties; -extern PFN_vkEnumerateDeviceLayerProperties vkEnumerateDeviceLayerProperties; -extern PFN_vkEnumerateInstanceExtensionProperties vkEnumerateInstanceExtensionProperties; -extern PFN_vkEnumerateInstanceLayerProperties vkEnumerateInstanceLayerProperties; -extern PFN_vkEnumeratePhysicalDevices vkEnumeratePhysicalDevices; -extern PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges; -extern PFN_vkFreeCommandBuffers vkFreeCommandBuffers; -extern PFN_vkFreeDescriptorSets vkFreeDescriptorSets; -extern PFN_vkFreeMemory vkFreeMemory; -extern PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements; -extern PFN_vkGetDeviceMemoryCommitment vkGetDeviceMemoryCommitment; -extern PFN_vkGetDeviceProcAddr vkGetDeviceProcAddr; -extern PFN_vkGetDeviceQueue vkGetDeviceQueue; -extern PFN_vkGetEventStatus vkGetEventStatus; -extern PFN_vkGetFenceStatus vkGetFenceStatus; -extern PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements; -extern PFN_vkGetImageSparseMemoryRequirements vkGetImageSparseMemoryRequirements; -extern PFN_vkGetImageSubresourceLayout vkGetImageSubresourceLayout; -extern PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr; -extern PFN_vkGetPhysicalDeviceFeatures vkGetPhysicalDeviceFeatures; -extern PFN_vkGetPhysicalDeviceFormatProperties vkGetPhysicalDeviceFormatProperties; -extern PFN_vkGetPhysicalDeviceImageFormatProperties vkGetPhysicalDeviceImageFormatProperties; -extern PFN_vkGetPhysicalDeviceMemoryProperties vkGetPhysicalDeviceMemoryProperties; -extern PFN_vkGetPhysicalDeviceProperties vkGetPhysicalDeviceProperties; -extern PFN_vkGetPhysicalDeviceQueueFamilyProperties vkGetPhysicalDeviceQueueFamilyProperties; -extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties vkGetPhysicalDeviceSparseImageFormatProperties; -extern PFN_vkGetPipelineCacheData vkGetPipelineCacheData; -extern PFN_vkGetQueryPoolResults vkGetQueryPoolResults; -extern PFN_vkGetRenderAreaGranularity vkGetRenderAreaGranularity; -extern PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges; -extern PFN_vkMapMemory vkMapMemory; -extern PFN_vkMergePipelineCaches vkMergePipelineCaches; -extern PFN_vkQueueBindSparse vkQueueBindSparse; -extern PFN_vkQueueSubmit vkQueueSubmit; -extern PFN_vkQueueWaitIdle vkQueueWaitIdle; -extern PFN_vkResetCommandBuffer vkResetCommandBuffer; -extern PFN_vkResetCommandPool vkResetCommandPool; -extern PFN_vkResetDescriptorPool vkResetDescriptorPool; -extern PFN_vkResetEvent vkResetEvent; -extern PFN_vkResetFences vkResetFences; -extern PFN_vkSetEvent vkSetEvent; -extern PFN_vkUnmapMemory vkUnmapMemory; -extern PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets; -extern PFN_vkWaitForFences vkWaitForFences; - - -extern PFN_vkBindBufferMemory2 vkBindBufferMemory2; -extern PFN_vkBindImageMemory2 vkBindImageMemory2; -extern PFN_vkCmdDispatchBase vkCmdDispatchBase; -extern PFN_vkCmdSetDeviceMask vkCmdSetDeviceMask; -extern PFN_vkCreateDescriptorUpdateTemplate vkCreateDescriptorUpdateTemplate; -extern PFN_vkCreateSamplerYcbcrConversion vkCreateSamplerYcbcrConversion; -extern PFN_vkDestroyDescriptorUpdateTemplate vkDestroyDescriptorUpdateTemplate; -extern PFN_vkDestroySamplerYcbcrConversion vkDestroySamplerYcbcrConversion; -extern PFN_vkEnumerateInstanceVersion vkEnumerateInstanceVersion; -extern PFN_vkEnumeratePhysicalDeviceGroups vkEnumeratePhysicalDeviceGroups; -extern PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2; -extern PFN_vkGetDescriptorSetLayoutSupport vkGetDescriptorSetLayoutSupport; -extern PFN_vkGetDeviceGroupPeerMemoryFeatures vkGetDeviceGroupPeerMemoryFeatures; -extern PFN_vkGetDeviceQueue2 vkGetDeviceQueue2; -extern PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2; -extern PFN_vkGetImageSparseMemoryRequirements2 vkGetImageSparseMemoryRequirements2; -extern PFN_vkGetPhysicalDeviceExternalBufferProperties vkGetPhysicalDeviceExternalBufferProperties; -extern PFN_vkGetPhysicalDeviceExternalFenceProperties vkGetPhysicalDeviceExternalFenceProperties; -extern PFN_vkGetPhysicalDeviceExternalSemaphoreProperties vkGetPhysicalDeviceExternalSemaphoreProperties; -extern PFN_vkGetPhysicalDeviceFeatures2 vkGetPhysicalDeviceFeatures2; -extern PFN_vkGetPhysicalDeviceFormatProperties2 vkGetPhysicalDeviceFormatProperties2; -extern PFN_vkGetPhysicalDeviceImageFormatProperties2 vkGetPhysicalDeviceImageFormatProperties2; -extern PFN_vkGetPhysicalDeviceMemoryProperties2 vkGetPhysicalDeviceMemoryProperties2; -extern PFN_vkGetPhysicalDeviceProperties2 vkGetPhysicalDeviceProperties2; -extern PFN_vkGetPhysicalDeviceQueueFamilyProperties2 vkGetPhysicalDeviceQueueFamilyProperties2; -extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 vkGetPhysicalDeviceSparseImageFormatProperties2; -extern PFN_vkTrimCommandPool vkTrimCommandPool; -extern PFN_vkUpdateDescriptorSetWithTemplate vkUpdateDescriptorSetWithTemplate; - - -extern PFN_vkCmdBeginRenderPass2 vkCmdBeginRenderPass2; -extern PFN_vkCmdDrawIndexedIndirectCount vkCmdDrawIndexedIndirectCount; -extern PFN_vkCmdDrawIndirectCount vkCmdDrawIndirectCount; -extern PFN_vkCmdEndRenderPass2 vkCmdEndRenderPass2; -extern PFN_vkCmdNextSubpass2 vkCmdNextSubpass2; -extern PFN_vkCreateRenderPass2 vkCreateRenderPass2; -extern PFN_vkGetBufferDeviceAddress vkGetBufferDeviceAddress; -extern PFN_vkGetBufferOpaqueCaptureAddress vkGetBufferOpaqueCaptureAddress; -extern PFN_vkGetDeviceMemoryOpaqueCaptureAddress vkGetDeviceMemoryOpaqueCaptureAddress; -extern PFN_vkGetSemaphoreCounterValue vkGetSemaphoreCounterValue; -extern PFN_vkResetQueryPool vkResetQueryPool; -extern PFN_vkSignalSemaphore vkSignalSemaphore; -extern PFN_vkWaitSemaphores vkWaitSemaphores; - - -extern PFN_vkCmdBeginRendering vkCmdBeginRendering; -extern PFN_vkCmdBindVertexBuffers2 vkCmdBindVertexBuffers2; -extern PFN_vkCmdBlitImage2 vkCmdBlitImage2; -extern PFN_vkCmdCopyBuffer2 vkCmdCopyBuffer2; -extern PFN_vkCmdCopyBufferToImage2 vkCmdCopyBufferToImage2; -extern PFN_vkCmdCopyImage2 vkCmdCopyImage2; -extern PFN_vkCmdCopyImageToBuffer2 vkCmdCopyImageToBuffer2; -extern PFN_vkCmdEndRendering vkCmdEndRendering; -extern PFN_vkCmdPipelineBarrier2 vkCmdPipelineBarrier2; -extern PFN_vkCmdResetEvent2 vkCmdResetEvent2; -extern PFN_vkCmdResolveImage2 vkCmdResolveImage2; -extern PFN_vkCmdSetCullMode vkCmdSetCullMode; -extern PFN_vkCmdSetDepthBiasEnable vkCmdSetDepthBiasEnable; -extern PFN_vkCmdSetDepthBoundsTestEnable vkCmdSetDepthBoundsTestEnable; -extern PFN_vkCmdSetDepthCompareOp vkCmdSetDepthCompareOp; -extern PFN_vkCmdSetDepthTestEnable vkCmdSetDepthTestEnable; -extern PFN_vkCmdSetDepthWriteEnable vkCmdSetDepthWriteEnable; -extern PFN_vkCmdSetEvent2 vkCmdSetEvent2; -extern PFN_vkCmdSetFrontFace vkCmdSetFrontFace; -extern PFN_vkCmdSetPrimitiveRestartEnable vkCmdSetPrimitiveRestartEnable; -extern PFN_vkCmdSetPrimitiveTopology vkCmdSetPrimitiveTopology; -extern PFN_vkCmdSetRasterizerDiscardEnable vkCmdSetRasterizerDiscardEnable; -extern PFN_vkCmdSetScissorWithCount vkCmdSetScissorWithCount; -extern PFN_vkCmdSetStencilOp vkCmdSetStencilOp; -extern PFN_vkCmdSetStencilTestEnable vkCmdSetStencilTestEnable; -extern PFN_vkCmdSetViewportWithCount vkCmdSetViewportWithCount; -extern PFN_vkCmdWaitEvents2 vkCmdWaitEvents2; -extern PFN_vkCmdWriteTimestamp2 vkCmdWriteTimestamp2; -extern PFN_vkCreatePrivateDataSlot vkCreatePrivateDataSlot; -extern PFN_vkDestroyPrivateDataSlot vkDestroyPrivateDataSlot; -extern PFN_vkGetDeviceBufferMemoryRequirements vkGetDeviceBufferMemoryRequirements; -extern PFN_vkGetDeviceImageMemoryRequirements vkGetDeviceImageMemoryRequirements; -extern PFN_vkGetDeviceImageSparseMemoryRequirements vkGetDeviceImageSparseMemoryRequirements; -extern PFN_vkGetPhysicalDeviceToolProperties vkGetPhysicalDeviceToolProperties; -extern PFN_vkGetPrivateData vkGetPrivateData; -extern PFN_vkQueueSubmit2 vkQueueSubmit2; -extern PFN_vkSetPrivateData vkSetPrivateData; - - -extern PFN_vkCmdWriteBufferMarkerAMD vkCmdWriteBufferMarkerAMD; - - -extern PFN_vkSetLocalDimmingAMD vkSetLocalDimmingAMD; - - -extern PFN_vkCmdDrawIndexedIndirectCountAMD vkCmdDrawIndexedIndirectCountAMD; -extern PFN_vkCmdDrawIndirectCountAMD vkCmdDrawIndirectCountAMD; - - -extern PFN_vkGetShaderInfoAMD vkGetShaderInfoAMD; - - - - - - -extern PFN_vkAcquireDrmDisplayEXT vkAcquireDrmDisplayEXT; -extern PFN_vkGetDrmDisplayEXT vkGetDrmDisplayEXT; - - - - - - -extern PFN_vkGetBufferDeviceAddressEXT vkGetBufferDeviceAddressEXT; - - -extern PFN_vkGetCalibratedTimestampsEXT vkGetCalibratedTimestampsEXT; -extern PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT vkGetPhysicalDeviceCalibrateableTimeDomainsEXT; - - -extern PFN_vkCmdSetColorWriteEnableEXT vkCmdSetColorWriteEnableEXT; - - -extern PFN_vkCmdBeginConditionalRenderingEXT vkCmdBeginConditionalRenderingEXT; -extern PFN_vkCmdEndConditionalRenderingEXT vkCmdEndConditionalRenderingEXT; - - -extern PFN_vkCmdDebugMarkerBeginEXT vkCmdDebugMarkerBeginEXT; -extern PFN_vkCmdDebugMarkerEndEXT vkCmdDebugMarkerEndEXT; -extern PFN_vkCmdDebugMarkerInsertEXT vkCmdDebugMarkerInsertEXT; -extern PFN_vkDebugMarkerSetObjectNameEXT vkDebugMarkerSetObjectNameEXT; -extern PFN_vkDebugMarkerSetObjectTagEXT vkDebugMarkerSetObjectTagEXT; - - -extern PFN_vkCreateDebugReportCallbackEXT vkCreateDebugReportCallbackEXT; -extern PFN_vkDebugReportMessageEXT vkDebugReportMessageEXT; -extern PFN_vkDestroyDebugReportCallbackEXT vkDestroyDebugReportCallbackEXT; - - -extern PFN_vkCmdBeginDebugUtilsLabelEXT vkCmdBeginDebugUtilsLabelEXT; -extern PFN_vkCmdEndDebugUtilsLabelEXT vkCmdEndDebugUtilsLabelEXT; -extern PFN_vkCmdInsertDebugUtilsLabelEXT vkCmdInsertDebugUtilsLabelEXT; -extern PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT; -extern PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT; -extern PFN_vkQueueBeginDebugUtilsLabelEXT vkQueueBeginDebugUtilsLabelEXT; -extern PFN_vkQueueEndDebugUtilsLabelEXT vkQueueEndDebugUtilsLabelEXT; -extern PFN_vkQueueInsertDebugUtilsLabelEXT vkQueueInsertDebugUtilsLabelEXT; -extern PFN_vkSetDebugUtilsObjectNameEXT vkSetDebugUtilsObjectNameEXT; -extern PFN_vkSetDebugUtilsObjectTagEXT vkSetDebugUtilsObjectTagEXT; -extern PFN_vkSubmitDebugUtilsMessageEXT vkSubmitDebugUtilsMessageEXT; - - -extern PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT vkCmdBindDescriptorBufferEmbeddedSamplersEXT; -extern PFN_vkCmdBindDescriptorBuffersEXT vkCmdBindDescriptorBuffersEXT; -extern PFN_vkCmdSetDescriptorBufferOffsetsEXT vkCmdSetDescriptorBufferOffsetsEXT; -extern PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT vkGetBufferOpaqueCaptureDescriptorDataEXT; -extern PFN_vkGetDescriptorEXT vkGetDescriptorEXT; -extern PFN_vkGetDescriptorSetLayoutBindingOffsetEXT vkGetDescriptorSetLayoutBindingOffsetEXT; -extern PFN_vkGetDescriptorSetLayoutSizeEXT vkGetDescriptorSetLayoutSizeEXT; -extern PFN_vkGetImageOpaqueCaptureDescriptorDataEXT vkGetImageOpaqueCaptureDescriptorDataEXT; -extern PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT vkGetImageViewOpaqueCaptureDescriptorDataEXT; -extern PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT vkGetSamplerOpaqueCaptureDescriptorDataEXT; - - -extern PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT; - - -extern PFN_vkGetDeviceFaultInfoEXT vkGetDeviceFaultInfoEXT; - - -extern PFN_vkReleaseDisplayEXT vkReleaseDisplayEXT; - - - - - - -extern PFN_vkCmdSetDiscardRectangleEXT vkCmdSetDiscardRectangleEXT; - - -extern PFN_vkDisplayPowerControlEXT vkDisplayPowerControlEXT; -extern PFN_vkGetSwapchainCounterEXT vkGetSwapchainCounterEXT; -extern PFN_vkRegisterDeviceEventEXT vkRegisterDeviceEventEXT; -extern PFN_vkRegisterDisplayEventEXT vkRegisterDisplayEventEXT; - - -extern PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT vkGetPhysicalDeviceSurfaceCapabilities2EXT; - - -extern PFN_vkCmdBindVertexBuffers2EXT vkCmdBindVertexBuffers2EXT; -extern PFN_vkCmdSetCullModeEXT vkCmdSetCullModeEXT; -extern PFN_vkCmdSetDepthBoundsTestEnableEXT vkCmdSetDepthBoundsTestEnableEXT; -extern PFN_vkCmdSetDepthCompareOpEXT vkCmdSetDepthCompareOpEXT; -extern PFN_vkCmdSetDepthTestEnableEXT vkCmdSetDepthTestEnableEXT; -extern PFN_vkCmdSetDepthWriteEnableEXT vkCmdSetDepthWriteEnableEXT; -extern PFN_vkCmdSetFrontFaceEXT vkCmdSetFrontFaceEXT; -extern PFN_vkCmdSetPrimitiveTopologyEXT vkCmdSetPrimitiveTopologyEXT; -extern PFN_vkCmdSetScissorWithCountEXT vkCmdSetScissorWithCountEXT; -extern PFN_vkCmdSetStencilOpEXT vkCmdSetStencilOpEXT; -extern PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT; -extern PFN_vkCmdSetViewportWithCountEXT vkCmdSetViewportWithCountEXT; - - -extern PFN_vkCmdSetDepthBiasEnableEXT vkCmdSetDepthBiasEnableEXT; -extern PFN_vkCmdSetLogicOpEXT vkCmdSetLogicOpEXT; -extern PFN_vkCmdSetPatchControlPointsEXT vkCmdSetPatchControlPointsEXT; -extern PFN_vkCmdSetPrimitiveRestartEnableEXT vkCmdSetPrimitiveRestartEnableEXT; -extern PFN_vkCmdSetRasterizerDiscardEnableEXT vkCmdSetRasterizerDiscardEnableEXT; - - -extern PFN_vkCmdSetAlphaToCoverageEnableEXT vkCmdSetAlphaToCoverageEnableEXT; -extern PFN_vkCmdSetAlphaToOneEnableEXT vkCmdSetAlphaToOneEnableEXT; -extern PFN_vkCmdSetColorBlendAdvancedEXT vkCmdSetColorBlendAdvancedEXT; -extern PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT; -extern PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT; -extern PFN_vkCmdSetColorWriteMaskEXT vkCmdSetColorWriteMaskEXT; -extern PFN_vkCmdSetConservativeRasterizationModeEXT vkCmdSetConservativeRasterizationModeEXT; -extern PFN_vkCmdSetCoverageModulationModeNV vkCmdSetCoverageModulationModeNV; -extern PFN_vkCmdSetCoverageModulationTableEnableNV vkCmdSetCoverageModulationTableEnableNV; -extern PFN_vkCmdSetCoverageModulationTableNV vkCmdSetCoverageModulationTableNV; -extern PFN_vkCmdSetCoverageReductionModeNV vkCmdSetCoverageReductionModeNV; -extern PFN_vkCmdSetCoverageToColorEnableNV vkCmdSetCoverageToColorEnableNV; -extern PFN_vkCmdSetCoverageToColorLocationNV vkCmdSetCoverageToColorLocationNV; -extern PFN_vkCmdSetDepthClampEnableEXT vkCmdSetDepthClampEnableEXT; -extern PFN_vkCmdSetDepthClipEnableEXT vkCmdSetDepthClipEnableEXT; -extern PFN_vkCmdSetDepthClipNegativeOneToOneEXT vkCmdSetDepthClipNegativeOneToOneEXT; -extern PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT vkCmdSetExtraPrimitiveOverestimationSizeEXT; -extern PFN_vkCmdSetLineRasterizationModeEXT vkCmdSetLineRasterizationModeEXT; -extern PFN_vkCmdSetLineStippleEnableEXT vkCmdSetLineStippleEnableEXT; -extern PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT; -extern PFN_vkCmdSetPolygonModeEXT vkCmdSetPolygonModeEXT; -extern PFN_vkCmdSetProvokingVertexModeEXT vkCmdSetProvokingVertexModeEXT; -extern PFN_vkCmdSetRasterizationSamplesEXT vkCmdSetRasterizationSamplesEXT; -extern PFN_vkCmdSetRasterizationStreamEXT vkCmdSetRasterizationStreamEXT; -extern PFN_vkCmdSetRepresentativeFragmentTestEnableNV vkCmdSetRepresentativeFragmentTestEnableNV; -extern PFN_vkCmdSetSampleLocationsEnableEXT vkCmdSetSampleLocationsEnableEXT; -extern PFN_vkCmdSetSampleMaskEXT vkCmdSetSampleMaskEXT; -extern PFN_vkCmdSetShadingRateImageEnableNV vkCmdSetShadingRateImageEnableNV; -extern PFN_vkCmdSetTessellationDomainOriginEXT vkCmdSetTessellationDomainOriginEXT; -extern PFN_vkCmdSetViewportSwizzleNV vkCmdSetViewportSwizzleNV; -extern PFN_vkCmdSetViewportWScalingEnableNV vkCmdSetViewportWScalingEnableNV; - - -extern PFN_vkGetMemoryHostPointerPropertiesEXT vkGetMemoryHostPointerPropertiesEXT; - - - - - - - -extern PFN_vkSetHdrMetadataEXT vkSetHdrMetadataEXT; - - -extern PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT; - - -extern PFN_vkResetQueryPoolEXT vkResetQueryPoolEXT; - - -extern PFN_vkGetImageSubresourceLayout2EXT vkGetImageSubresourceLayout2EXT; - - -extern PFN_vkGetImageDrmFormatModifierPropertiesEXT vkGetImageDrmFormatModifierPropertiesEXT; - - -extern PFN_vkCmdSetLineStippleEXT vkCmdSetLineStippleEXT; - - -extern PFN_vkCmdDrawMeshTasksEXT vkCmdDrawMeshTasksEXT; -extern PFN_vkCmdDrawMeshTasksIndirectCountEXT vkCmdDrawMeshTasksIndirectCountEXT; -extern PFN_vkCmdDrawMeshTasksIndirectEXT vkCmdDrawMeshTasksIndirectEXT; -# 1277 "third_party/volk.h" -extern PFN_vkCmdDrawMultiEXT vkCmdDrawMultiEXT; -extern PFN_vkCmdDrawMultiIndexedEXT vkCmdDrawMultiIndexedEXT; - - -extern PFN_vkBuildMicromapsEXT vkBuildMicromapsEXT; -extern PFN_vkCmdBuildMicromapsEXT vkCmdBuildMicromapsEXT; -extern PFN_vkCmdCopyMemoryToMicromapEXT vkCmdCopyMemoryToMicromapEXT; -extern PFN_vkCmdCopyMicromapEXT vkCmdCopyMicromapEXT; -extern PFN_vkCmdCopyMicromapToMemoryEXT vkCmdCopyMicromapToMemoryEXT; -extern PFN_vkCmdWriteMicromapsPropertiesEXT vkCmdWriteMicromapsPropertiesEXT; -extern PFN_vkCopyMemoryToMicromapEXT vkCopyMemoryToMicromapEXT; -extern PFN_vkCopyMicromapEXT vkCopyMicromapEXT; -extern PFN_vkCopyMicromapToMemoryEXT vkCopyMicromapToMemoryEXT; -extern PFN_vkCreateMicromapEXT vkCreateMicromapEXT; -extern PFN_vkDestroyMicromapEXT vkDestroyMicromapEXT; -extern PFN_vkGetDeviceMicromapCompatibilityEXT vkGetDeviceMicromapCompatibilityEXT; -extern PFN_vkGetMicromapBuildSizesEXT vkGetMicromapBuildSizesEXT; -extern PFN_vkWriteMicromapsPropertiesEXT vkWriteMicromapsPropertiesEXT; - - -extern PFN_vkSetDeviceMemoryPriorityEXT vkSetDeviceMemoryPriorityEXT; - - -extern PFN_vkGetPipelinePropertiesEXT vkGetPipelinePropertiesEXT; - - -extern PFN_vkCreatePrivateDataSlotEXT vkCreatePrivateDataSlotEXT; -extern PFN_vkDestroyPrivateDataSlotEXT vkDestroyPrivateDataSlotEXT; -extern PFN_vkGetPrivateDataEXT vkGetPrivateDataEXT; -extern PFN_vkSetPrivateDataEXT vkSetPrivateDataEXT; - - -extern PFN_vkCmdSetSampleLocationsEXT vkCmdSetSampleLocationsEXT; -extern PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT vkGetPhysicalDeviceMultisamplePropertiesEXT; - - -extern PFN_vkGetShaderModuleCreateInfoIdentifierEXT vkGetShaderModuleCreateInfoIdentifierEXT; -extern PFN_vkGetShaderModuleIdentifierEXT vkGetShaderModuleIdentifierEXT; - - -extern PFN_vkReleaseSwapchainImagesEXT vkReleaseSwapchainImagesEXT; - - -extern PFN_vkGetPhysicalDeviceToolPropertiesEXT vkGetPhysicalDeviceToolPropertiesEXT; - - -extern PFN_vkCmdBeginQueryIndexedEXT vkCmdBeginQueryIndexedEXT; -extern PFN_vkCmdBeginTransformFeedbackEXT vkCmdBeginTransformFeedbackEXT; -extern PFN_vkCmdBindTransformFeedbackBuffersEXT vkCmdBindTransformFeedbackBuffersEXT; -extern PFN_vkCmdDrawIndirectByteCountEXT vkCmdDrawIndirectByteCountEXT; -extern PFN_vkCmdEndQueryIndexedEXT vkCmdEndQueryIndexedEXT; -extern PFN_vkCmdEndTransformFeedbackEXT vkCmdEndTransformFeedbackEXT; - - -extern PFN_vkCreateValidationCacheEXT vkCreateValidationCacheEXT; -extern PFN_vkDestroyValidationCacheEXT vkDestroyValidationCacheEXT; -extern PFN_vkGetValidationCacheDataEXT vkGetValidationCacheDataEXT; -extern PFN_vkMergeValidationCachesEXT vkMergeValidationCachesEXT; - - -extern PFN_vkCmdSetVertexInputEXT vkCmdSetVertexInputEXT; -# 1361 "third_party/volk.h" -extern PFN_vkGetPastPresentationTimingGOOGLE vkGetPastPresentationTimingGOOGLE; -extern PFN_vkGetRefreshCycleDurationGOOGLE vkGetRefreshCycleDurationGOOGLE; - - -extern PFN_vkCmdBindInvocationMaskHUAWEI vkCmdBindInvocationMaskHUAWEI; - - -extern PFN_vkCmdSubpassShadingHUAWEI vkCmdSubpassShadingHUAWEI; -extern PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI; - - -extern PFN_vkAcquirePerformanceConfigurationINTEL vkAcquirePerformanceConfigurationINTEL; -extern PFN_vkCmdSetPerformanceMarkerINTEL vkCmdSetPerformanceMarkerINTEL; -extern PFN_vkCmdSetPerformanceOverrideINTEL vkCmdSetPerformanceOverrideINTEL; -extern PFN_vkCmdSetPerformanceStreamMarkerINTEL vkCmdSetPerformanceStreamMarkerINTEL; -extern PFN_vkGetPerformanceParameterINTEL vkGetPerformanceParameterINTEL; -extern PFN_vkInitializePerformanceApiINTEL vkInitializePerformanceApiINTEL; -extern PFN_vkQueueSetPerformanceConfigurationINTEL vkQueueSetPerformanceConfigurationINTEL; -extern PFN_vkReleasePerformanceConfigurationINTEL vkReleasePerformanceConfigurationINTEL; -extern PFN_vkUninitializePerformanceApiINTEL vkUninitializePerformanceApiINTEL; - - -extern PFN_vkBuildAccelerationStructuresKHR vkBuildAccelerationStructuresKHR; -extern PFN_vkCmdBuildAccelerationStructuresIndirectKHR vkCmdBuildAccelerationStructuresIndirectKHR; -extern PFN_vkCmdBuildAccelerationStructuresKHR vkCmdBuildAccelerationStructuresKHR; -extern PFN_vkCmdCopyAccelerationStructureKHR vkCmdCopyAccelerationStructureKHR; -extern PFN_vkCmdCopyAccelerationStructureToMemoryKHR vkCmdCopyAccelerationStructureToMemoryKHR; -extern PFN_vkCmdCopyMemoryToAccelerationStructureKHR vkCmdCopyMemoryToAccelerationStructureKHR; -extern PFN_vkCmdWriteAccelerationStructuresPropertiesKHR vkCmdWriteAccelerationStructuresPropertiesKHR; -extern PFN_vkCopyAccelerationStructureKHR vkCopyAccelerationStructureKHR; -extern PFN_vkCopyAccelerationStructureToMemoryKHR vkCopyAccelerationStructureToMemoryKHR; -extern PFN_vkCopyMemoryToAccelerationStructureKHR vkCopyMemoryToAccelerationStructureKHR; -extern PFN_vkCreateAccelerationStructureKHR vkCreateAccelerationStructureKHR; -extern PFN_vkDestroyAccelerationStructureKHR vkDestroyAccelerationStructureKHR; -extern PFN_vkGetAccelerationStructureBuildSizesKHR vkGetAccelerationStructureBuildSizesKHR; -extern PFN_vkGetAccelerationStructureDeviceAddressKHR vkGetAccelerationStructureDeviceAddressKHR; -extern PFN_vkGetDeviceAccelerationStructureCompatibilityKHR vkGetDeviceAccelerationStructureCompatibilityKHR; -extern PFN_vkWriteAccelerationStructuresPropertiesKHR vkWriteAccelerationStructuresPropertiesKHR; - - - - - -extern PFN_vkBindBufferMemory2KHR vkBindBufferMemory2KHR; -extern PFN_vkBindImageMemory2KHR vkBindImageMemory2KHR; - - -extern PFN_vkGetBufferDeviceAddressKHR vkGetBufferDeviceAddressKHR; -extern PFN_vkGetBufferOpaqueCaptureAddressKHR vkGetBufferOpaqueCaptureAddressKHR; -extern PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR vkGetDeviceMemoryOpaqueCaptureAddressKHR; - - -extern PFN_vkCmdBlitImage2KHR vkCmdBlitImage2KHR; -extern PFN_vkCmdCopyBuffer2KHR vkCmdCopyBuffer2KHR; -extern PFN_vkCmdCopyBufferToImage2KHR vkCmdCopyBufferToImage2KHR; -extern PFN_vkCmdCopyImage2KHR vkCmdCopyImage2KHR; -extern PFN_vkCmdCopyImageToBuffer2KHR vkCmdCopyImageToBuffer2KHR; -extern PFN_vkCmdResolveImage2KHR vkCmdResolveImage2KHR; - - -extern PFN_vkCmdBeginRenderPass2KHR vkCmdBeginRenderPass2KHR; -extern PFN_vkCmdEndRenderPass2KHR vkCmdEndRenderPass2KHR; -extern PFN_vkCmdNextSubpass2KHR vkCmdNextSubpass2KHR; -extern PFN_vkCreateRenderPass2KHR vkCreateRenderPass2KHR; - - -extern PFN_vkCreateDeferredOperationKHR vkCreateDeferredOperationKHR; -extern PFN_vkDeferredOperationJoinKHR vkDeferredOperationJoinKHR; -extern PFN_vkDestroyDeferredOperationKHR vkDestroyDeferredOperationKHR; -extern PFN_vkGetDeferredOperationMaxConcurrencyKHR vkGetDeferredOperationMaxConcurrencyKHR; -extern PFN_vkGetDeferredOperationResultKHR vkGetDeferredOperationResultKHR; - - -extern PFN_vkCreateDescriptorUpdateTemplateKHR vkCreateDescriptorUpdateTemplateKHR; -extern PFN_vkDestroyDescriptorUpdateTemplateKHR vkDestroyDescriptorUpdateTemplateKHR; -extern PFN_vkUpdateDescriptorSetWithTemplateKHR vkUpdateDescriptorSetWithTemplateKHR; - - -extern PFN_vkCmdDispatchBaseKHR vkCmdDispatchBaseKHR; -extern PFN_vkCmdSetDeviceMaskKHR vkCmdSetDeviceMaskKHR; -extern PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR vkGetDeviceGroupPeerMemoryFeaturesKHR; - - -extern PFN_vkEnumeratePhysicalDeviceGroupsKHR vkEnumeratePhysicalDeviceGroupsKHR; - - -extern PFN_vkCreateDisplayModeKHR vkCreateDisplayModeKHR; -extern PFN_vkCreateDisplayPlaneSurfaceKHR vkCreateDisplayPlaneSurfaceKHR; -extern PFN_vkGetDisplayModePropertiesKHR vkGetDisplayModePropertiesKHR; -extern PFN_vkGetDisplayPlaneCapabilitiesKHR vkGetDisplayPlaneCapabilitiesKHR; -extern PFN_vkGetDisplayPlaneSupportedDisplaysKHR vkGetDisplayPlaneSupportedDisplaysKHR; -extern PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR vkGetPhysicalDeviceDisplayPlanePropertiesKHR; -extern PFN_vkGetPhysicalDeviceDisplayPropertiesKHR vkGetPhysicalDeviceDisplayPropertiesKHR; - - -extern PFN_vkCreateSharedSwapchainsKHR vkCreateSharedSwapchainsKHR; - - -extern PFN_vkCmdDrawIndexedIndirectCountKHR vkCmdDrawIndexedIndirectCountKHR; -extern PFN_vkCmdDrawIndirectCountKHR vkCmdDrawIndirectCountKHR; - - -extern PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR; -extern PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR; - - -extern PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR vkGetPhysicalDeviceExternalFencePropertiesKHR; - - -extern PFN_vkGetFenceFdKHR vkGetFenceFdKHR; -extern PFN_vkImportFenceFdKHR vkImportFenceFdKHR; - - - - - - -extern PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR vkGetPhysicalDeviceExternalBufferPropertiesKHR; - - -extern PFN_vkGetMemoryFdKHR vkGetMemoryFdKHR; -extern PFN_vkGetMemoryFdPropertiesKHR vkGetMemoryFdPropertiesKHR; - - - - - - -extern PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR vkGetPhysicalDeviceExternalSemaphorePropertiesKHR; - - -extern PFN_vkGetSemaphoreFdKHR vkGetSemaphoreFdKHR; -extern PFN_vkImportSemaphoreFdKHR vkImportSemaphoreFdKHR; - - - - - - -extern PFN_vkCmdSetFragmentShadingRateKHR vkCmdSetFragmentShadingRateKHR; -extern PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR vkGetPhysicalDeviceFragmentShadingRatesKHR; - - -extern PFN_vkGetDisplayModeProperties2KHR vkGetDisplayModeProperties2KHR; -extern PFN_vkGetDisplayPlaneCapabilities2KHR vkGetDisplayPlaneCapabilities2KHR; -extern PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR vkGetPhysicalDeviceDisplayPlaneProperties2KHR; -extern PFN_vkGetPhysicalDeviceDisplayProperties2KHR vkGetPhysicalDeviceDisplayProperties2KHR; - - -extern PFN_vkGetBufferMemoryRequirements2KHR vkGetBufferMemoryRequirements2KHR; -extern PFN_vkGetImageMemoryRequirements2KHR vkGetImageMemoryRequirements2KHR; -extern PFN_vkGetImageSparseMemoryRequirements2KHR vkGetImageSparseMemoryRequirements2KHR; - - -extern PFN_vkGetPhysicalDeviceFeatures2KHR vkGetPhysicalDeviceFeatures2KHR; -extern PFN_vkGetPhysicalDeviceFormatProperties2KHR vkGetPhysicalDeviceFormatProperties2KHR; -extern PFN_vkGetPhysicalDeviceImageFormatProperties2KHR vkGetPhysicalDeviceImageFormatProperties2KHR; -extern PFN_vkGetPhysicalDeviceMemoryProperties2KHR vkGetPhysicalDeviceMemoryProperties2KHR; -extern PFN_vkGetPhysicalDeviceProperties2KHR vkGetPhysicalDeviceProperties2KHR; -extern PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR vkGetPhysicalDeviceQueueFamilyProperties2KHR; -extern PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR vkGetPhysicalDeviceSparseImageFormatProperties2KHR; - - -extern PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR vkGetPhysicalDeviceSurfaceCapabilities2KHR; -extern PFN_vkGetPhysicalDeviceSurfaceFormats2KHR vkGetPhysicalDeviceSurfaceFormats2KHR; - - -extern PFN_vkTrimCommandPoolKHR vkTrimCommandPoolKHR; - - -extern PFN_vkGetDescriptorSetLayoutSupportKHR vkGetDescriptorSetLayoutSupportKHR; - - -extern PFN_vkGetDeviceBufferMemoryRequirementsKHR vkGetDeviceBufferMemoryRequirementsKHR; -extern PFN_vkGetDeviceImageMemoryRequirementsKHR vkGetDeviceImageMemoryRequirementsKHR; -extern PFN_vkGetDeviceImageSparseMemoryRequirementsKHR vkGetDeviceImageSparseMemoryRequirementsKHR; - - -extern PFN_vkAcquireProfilingLockKHR vkAcquireProfilingLockKHR; -extern PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR; -extern PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR; -extern PFN_vkReleaseProfilingLockKHR vkReleaseProfilingLockKHR; - - -extern PFN_vkGetPipelineExecutableInternalRepresentationsKHR vkGetPipelineExecutableInternalRepresentationsKHR; -extern PFN_vkGetPipelineExecutablePropertiesKHR vkGetPipelineExecutablePropertiesKHR; -extern PFN_vkGetPipelineExecutableStatisticsKHR vkGetPipelineExecutableStatisticsKHR; - - -extern PFN_vkWaitForPresentKHR vkWaitForPresentKHR; - - -extern PFN_vkCmdPushDescriptorSetKHR vkCmdPushDescriptorSetKHR; - - -extern PFN_vkCmdTraceRaysIndirect2KHR vkCmdTraceRaysIndirect2KHR; - - -extern PFN_vkCmdSetRayTracingPipelineStackSizeKHR vkCmdSetRayTracingPipelineStackSizeKHR; -extern PFN_vkCmdTraceRaysIndirectKHR vkCmdTraceRaysIndirectKHR; -extern PFN_vkCmdTraceRaysKHR vkCmdTraceRaysKHR; -extern PFN_vkCreateRayTracingPipelinesKHR vkCreateRayTracingPipelinesKHR; -extern PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR vkGetRayTracingCaptureReplayShaderGroupHandlesKHR; -extern PFN_vkGetRayTracingShaderGroupHandlesKHR vkGetRayTracingShaderGroupHandlesKHR; -extern PFN_vkGetRayTracingShaderGroupStackSizeKHR vkGetRayTracingShaderGroupStackSizeKHR; - - -extern PFN_vkCreateSamplerYcbcrConversionKHR vkCreateSamplerYcbcrConversionKHR; -extern PFN_vkDestroySamplerYcbcrConversionKHR vkDestroySamplerYcbcrConversionKHR; - - -extern PFN_vkGetSwapchainStatusKHR vkGetSwapchainStatusKHR; - - -extern PFN_vkDestroySurfaceKHR vkDestroySurfaceKHR; -extern PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR vkGetPhysicalDeviceSurfaceCapabilitiesKHR; -extern PFN_vkGetPhysicalDeviceSurfaceFormatsKHR vkGetPhysicalDeviceSurfaceFormatsKHR; -extern PFN_vkGetPhysicalDeviceSurfacePresentModesKHR vkGetPhysicalDeviceSurfacePresentModesKHR; -extern PFN_vkGetPhysicalDeviceSurfaceSupportKHR vkGetPhysicalDeviceSurfaceSupportKHR; - - -extern PFN_vkAcquireNextImageKHR vkAcquireNextImageKHR; -extern PFN_vkCreateSwapchainKHR vkCreateSwapchainKHR; -extern PFN_vkDestroySwapchainKHR vkDestroySwapchainKHR; -extern PFN_vkGetSwapchainImagesKHR vkGetSwapchainImagesKHR; -extern PFN_vkQueuePresentKHR vkQueuePresentKHR; - - -extern PFN_vkCmdPipelineBarrier2KHR vkCmdPipelineBarrier2KHR; -extern PFN_vkCmdResetEvent2KHR vkCmdResetEvent2KHR; -extern PFN_vkCmdSetEvent2KHR vkCmdSetEvent2KHR; -extern PFN_vkCmdWaitEvents2KHR vkCmdWaitEvents2KHR; -extern PFN_vkCmdWriteTimestamp2KHR vkCmdWriteTimestamp2KHR; -extern PFN_vkQueueSubmit2KHR vkQueueSubmit2KHR; - - -extern PFN_vkCmdWriteBufferMarker2AMD vkCmdWriteBufferMarker2AMD; - - -extern PFN_vkGetQueueCheckpointData2NV vkGetQueueCheckpointData2NV; - - -extern PFN_vkGetSemaphoreCounterValueKHR vkGetSemaphoreCounterValueKHR; -extern PFN_vkSignalSemaphoreKHR vkSignalSemaphoreKHR; -extern PFN_vkWaitSemaphoresKHR vkWaitSemaphoresKHR; - - -extern PFN_vkCmdDecodeVideoKHR vkCmdDecodeVideoKHR; - - - - - -extern PFN_vkBindVideoSessionMemoryKHR vkBindVideoSessionMemoryKHR; -extern PFN_vkCmdBeginVideoCodingKHR vkCmdBeginVideoCodingKHR; -extern PFN_vkCmdControlVideoCodingKHR vkCmdControlVideoCodingKHR; -extern PFN_vkCmdEndVideoCodingKHR vkCmdEndVideoCodingKHR; -extern PFN_vkCreateVideoSessionKHR vkCreateVideoSessionKHR; -extern PFN_vkCreateVideoSessionParametersKHR vkCreateVideoSessionParametersKHR; -extern PFN_vkDestroyVideoSessionKHR vkDestroyVideoSessionKHR; -extern PFN_vkDestroyVideoSessionParametersKHR vkDestroyVideoSessionParametersKHR; -extern PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR vkGetPhysicalDeviceVideoCapabilitiesKHR; -extern PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR vkGetPhysicalDeviceVideoFormatPropertiesKHR; -extern PFN_vkGetVideoSessionMemoryRequirementsKHR vkGetVideoSessionMemoryRequirementsKHR; -extern PFN_vkUpdateVideoSessionParametersKHR vkUpdateVideoSessionParametersKHR; -# 1653 "third_party/volk.h" -extern PFN_vkCmdCuLaunchKernelNVX vkCmdCuLaunchKernelNVX; -extern PFN_vkCreateCuFunctionNVX vkCreateCuFunctionNVX; -extern PFN_vkCreateCuModuleNVX vkCreateCuModuleNVX; -extern PFN_vkDestroyCuFunctionNVX vkDestroyCuFunctionNVX; -extern PFN_vkDestroyCuModuleNVX vkDestroyCuModuleNVX; - - -extern PFN_vkGetImageViewAddressNVX vkGetImageViewAddressNVX; -extern PFN_vkGetImageViewHandleNVX vkGetImageViewHandleNVX; - - - - - - -extern PFN_vkCmdSetViewportWScalingNV vkCmdSetViewportWScalingNV; - - -extern PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV vkGetPhysicalDeviceCooperativeMatrixPropertiesNV; - - -extern PFN_vkCmdCopyMemoryIndirectNV vkCmdCopyMemoryIndirectNV; -extern PFN_vkCmdCopyMemoryToImageIndirectNV vkCmdCopyMemoryToImageIndirectNV; - - -extern PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV; - - -extern PFN_vkCmdSetCheckpointNV vkCmdSetCheckpointNV; -extern PFN_vkGetQueueCheckpointDataNV vkGetQueueCheckpointDataNV; - - -extern PFN_vkCmdBindPipelineShaderGroupNV vkCmdBindPipelineShaderGroupNV; -extern PFN_vkCmdExecuteGeneratedCommandsNV vkCmdExecuteGeneratedCommandsNV; -extern PFN_vkCmdPreprocessGeneratedCommandsNV vkCmdPreprocessGeneratedCommandsNV; -extern PFN_vkCreateIndirectCommandsLayoutNV vkCreateIndirectCommandsLayoutNV; -extern PFN_vkDestroyIndirectCommandsLayoutNV vkDestroyIndirectCommandsLayoutNV; -extern PFN_vkGetGeneratedCommandsMemoryRequirementsNV vkGetGeneratedCommandsMemoryRequirementsNV; - - -extern PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV vkGetPhysicalDeviceExternalImageFormatPropertiesNV; - - -extern PFN_vkGetMemoryRemoteAddressNV vkGetMemoryRemoteAddressNV; - - - - - -extern PFN_vkCmdSetFragmentShadingRateEnumNV vkCmdSetFragmentShadingRateEnumNV; - - -extern PFN_vkCmdDecompressMemoryIndirectCountNV vkCmdDecompressMemoryIndirectCountNV; -extern PFN_vkCmdDecompressMemoryNV vkCmdDecompressMemoryNV; - - -extern PFN_vkCmdDrawMeshTasksIndirectCountNV vkCmdDrawMeshTasksIndirectCountNV; -extern PFN_vkCmdDrawMeshTasksIndirectNV vkCmdDrawMeshTasksIndirectNV; -extern PFN_vkCmdDrawMeshTasksNV vkCmdDrawMeshTasksNV; - - -extern PFN_vkBindOpticalFlowSessionImageNV vkBindOpticalFlowSessionImageNV; -extern PFN_vkCmdOpticalFlowExecuteNV vkCmdOpticalFlowExecuteNV; -extern PFN_vkCreateOpticalFlowSessionNV vkCreateOpticalFlowSessionNV; -extern PFN_vkDestroyOpticalFlowSessionNV vkDestroyOpticalFlowSessionNV; -extern PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV vkGetPhysicalDeviceOpticalFlowImageFormatsNV; - - -extern PFN_vkBindAccelerationStructureMemoryNV vkBindAccelerationStructureMemoryNV; -extern PFN_vkCmdBuildAccelerationStructureNV vkCmdBuildAccelerationStructureNV; -extern PFN_vkCmdCopyAccelerationStructureNV vkCmdCopyAccelerationStructureNV; -extern PFN_vkCmdTraceRaysNV vkCmdTraceRaysNV; -extern PFN_vkCmdWriteAccelerationStructuresPropertiesNV vkCmdWriteAccelerationStructuresPropertiesNV; -extern PFN_vkCompileDeferredNV vkCompileDeferredNV; -extern PFN_vkCreateAccelerationStructureNV vkCreateAccelerationStructureNV; -extern PFN_vkCreateRayTracingPipelinesNV vkCreateRayTracingPipelinesNV; -extern PFN_vkDestroyAccelerationStructureNV vkDestroyAccelerationStructureNV; -extern PFN_vkGetAccelerationStructureHandleNV vkGetAccelerationStructureHandleNV; -extern PFN_vkGetAccelerationStructureMemoryRequirementsNV vkGetAccelerationStructureMemoryRequirementsNV; -extern PFN_vkGetRayTracingShaderGroupHandlesNV vkGetRayTracingShaderGroupHandlesNV; - - -extern PFN_vkCmdSetExclusiveScissorNV vkCmdSetExclusiveScissorNV; - - -extern PFN_vkCmdBindShadingRateImageNV vkCmdBindShadingRateImageNV; -extern PFN_vkCmdSetCoarseSampleOrderNV vkCmdSetCoarseSampleOrderNV; -extern PFN_vkCmdSetViewportShadingRatePaletteNV vkCmdSetViewportShadingRatePaletteNV; - - -extern PFN_vkGetDynamicRenderingTilePropertiesQCOM vkGetDynamicRenderingTilePropertiesQCOM; -extern PFN_vkGetFramebufferTilePropertiesQCOM vkGetFramebufferTilePropertiesQCOM; - - - - - - -extern PFN_vkGetDescriptorSetHostMappingVALVE vkGetDescriptorSetHostMappingVALVE; -extern PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE vkGetDescriptorSetLayoutHostMappingInfoVALVE; - - - - - -extern PFN_vkCmdPushDescriptorSetWithTemplateKHR vkCmdPushDescriptorSetWithTemplateKHR; - - -extern PFN_vkGetDeviceGroupPresentCapabilitiesKHR vkGetDeviceGroupPresentCapabilitiesKHR; -extern PFN_vkGetDeviceGroupSurfacePresentModesKHR vkGetDeviceGroupSurfacePresentModesKHR; -extern PFN_vkGetPhysicalDevicePresentRectanglesKHR vkGetPhysicalDevicePresentRectanglesKHR; - - -extern PFN_vkAcquireNextImage2KHR vkAcquireNextImage2KHR; - - - - -} -# 17 "src/renderer/descriptors/vk_descriptor_set.h" 2 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/compare" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/compare" 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 3 - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 -# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - typedef long unsigned int size_t; - typedef long int ptrdiff_t; - - - typedef decltype(nullptr) nullptr_t; - - -#pragma GCC visibility push(default) - - - extern "C++" __attribute__ ((__noreturn__, __always_inline__)) - inline void __terminate() noexcept - { - void terminate() noexcept __attribute__ ((__noreturn__)); - terminate(); - } -#pragma GCC visibility pop -} -# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -namespace __gnu_cxx -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ -#pragma GCC visibility push(default) - - - - - constexpr inline bool - __is_constant_evaluated() noexcept - { - - - - - - return __builtin_is_constant_evaluated(); - - - - } -#pragma GCC visibility pop -} -# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 -# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 -# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/initializer_list" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - template - class initializer_list - { - public: - typedef _E value_type; - typedef const _E& reference; - typedef const _E& const_reference; - typedef size_t size_type; - typedef const _E* iterator; - typedef const _E* const_iterator; - - private: - iterator _M_array; - size_type _M_len; - - - constexpr initializer_list(const_iterator __a, size_type __l) - : _M_array(__a), _M_len(__l) { } - - public: - constexpr initializer_list() noexcept - : _M_array(0), _M_len(0) { } - - - constexpr size_type - size() const noexcept { return _M_len; } - - - constexpr const_iterator - begin() const noexcept { return _M_array; } - - - constexpr const_iterator - end() const noexcept { return begin() + size(); } - }; - - - - - - - - template - constexpr const _Tp* - begin(initializer_list<_Tp> __ils) noexcept - { return __ils.begin(); } - - - - - - - - template - constexpr const _Tp* - end(initializer_list<_Tp> __ils) noexcept - { return __ils.end(); } -} -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - class reference_wrapper; -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } - - }; - - - - - - - - using true_type = integral_constant; - - - using false_type = integral_constant; - - - - template - using __bool_constant = integral_constant; - - - - - - - template - using bool_constant = integral_constant; - - - - - - - template - struct enable_if - { }; - - - template - struct enable_if - { typedef _Tp type; }; - - - template - using __enable_if_t = typename enable_if<_Cond, _Tp>::type; - - template - struct __conditional - { - template - using type = _Tp; - }; - - template<> - struct __conditional - { - template - using type = _Up; - }; - - - template - using __conditional_t - = typename __conditional<_Cond>::template type<_If, _Else>; - - - template - struct __type_identity - { using type = _Type; }; - - template - using __type_identity_t = typename __type_identity<_Tp>::type; - - namespace __detail - { - - template - using __first_t = _Tp; - - - template - auto __or_fn(int) -> __first_t...>; - - template - auto __or_fn(...) -> true_type; - - template - auto __and_fn(int) -> __first_t...>; - - template - auto __and_fn(...) -> false_type; - } - - - - - template - struct __or_ - : decltype(__detail::__or_fn<_Bn...>(0)) - { }; - - template - struct __and_ - : decltype(__detail::__and_fn<_Bn...>(0)) - { }; - - template - struct __not_ - : __bool_constant - { }; - - - - - - template - inline constexpr bool __or_v = __or_<_Bn...>::value; - template - inline constexpr bool __and_v = __and_<_Bn...>::value; - - namespace __detail - { - template - struct __disjunction_impl - { using type = _B1; }; - - template - struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __disjunction_impl::type; }; - - template - struct __conjunction_impl - { using type = _B1; }; - - template - struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __conjunction_impl::type; }; - } - - - - - template - struct conjunction - : __detail::__conjunction_impl::type - { }; - - template<> - struct conjunction<> - : true_type - { }; - - template - struct disjunction - : __detail::__disjunction_impl::type - { }; - - template<> - struct disjunction<> - : false_type - { }; - - template - struct negation - : __not_<_Pp>::type - { }; - - - - - template - inline constexpr bool conjunction_v = conjunction<_Bn...>::value; - - template - inline constexpr bool disjunction_v = disjunction<_Bn...>::value; - - template - inline constexpr bool negation_v = negation<_Pp>::value; - - - - - - template - struct is_reference; - template - struct is_function; - template - struct is_void; - template - struct remove_cv; - template - struct is_const; - - - template - struct __is_array_unknown_bounds; - - - - - template - constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) - { return {}; } - - template - constexpr typename __or_< - is_reference<_NestedType>, - is_function<_NestedType>, - is_void<_NestedType>, - __is_array_unknown_bounds<_NestedType> - >::type __is_complete_or_unbounded(_TypeIdentity) - { return {}; } - - - template - using __remove_cv_t = typename remove_cv<_Tp>::type; - - - - - - template - struct is_void - : public false_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - - template - struct __is_integral_helper - : public false_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; -# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_integral - : public __is_integral_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct __is_floating_point_helper - : public false_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; -# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_floating_point - : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_array - : public false_type { }; - - template - struct is_array<_Tp[_Size]> - : public true_type { }; - - template - struct is_array<_Tp[]> - : public true_type { }; - - template - struct __is_pointer_helper - : public false_type { }; - - template - struct __is_pointer_helper<_Tp*> - : public true_type { }; - - - template - struct is_pointer - : public __is_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_lvalue_reference - : public false_type { }; - - template - struct is_lvalue_reference<_Tp&> - : public true_type { }; - - - template - struct is_rvalue_reference - : public false_type { }; - - template - struct is_rvalue_reference<_Tp&&> - : public true_type { }; - - template - struct __is_member_object_pointer_helper - : public false_type { }; - - template - struct __is_member_object_pointer_helper<_Tp _Cp::*> - : public __not_>::type { }; - - - template - struct is_member_object_pointer - : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct __is_member_function_pointer_helper - : public false_type { }; - - template - struct __is_member_function_pointer_helper<_Tp _Cp::*> - : public is_function<_Tp>::type { }; - - - template - struct is_member_function_pointer - : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_enum - : public integral_constant - { }; - - - template - struct is_union - : public integral_constant - { }; - - - template - struct is_class - : public integral_constant - { }; - - - template - struct is_function - : public __bool_constant::value> { }; - - template - struct is_function<_Tp&> - : public false_type { }; - - template - struct is_function<_Tp&&> - : public false_type { }; - - - - - template - struct is_null_pointer - : public false_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - - - template - struct __is_nullptr_t - : public is_null_pointer<_Tp> - { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); - - - - - template - struct is_reference - : public false_type - { }; - - template - struct is_reference<_Tp&> - : public true_type - { }; - - template - struct is_reference<_Tp&&> - : public true_type - { }; - - - template - struct is_arithmetic - : public __or_, is_floating_point<_Tp>>::type - { }; - - - template - struct is_fundamental - : public __or_, is_void<_Tp>, - is_null_pointer<_Tp>>::type - { }; - - - template - struct is_object - : public __not_<__or_, is_reference<_Tp>, - is_void<_Tp>>>::type - { }; - - template - struct is_member_pointer; - - - template - struct is_scalar - : public __or_, is_enum<_Tp>, is_pointer<_Tp>, - is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type - { }; - - - template - struct is_compound - : public __not_>::type { }; - - - template - struct __is_member_pointer_helper - : public false_type { }; - - template - struct __is_member_pointer_helper<_Tp _Cp::*> - : public true_type { }; - - - - template - struct is_member_pointer - : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct is_same; - - - template - using __is_one_of = __or_...>; - - - __extension__ - template - using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, - signed char, signed short, signed int, signed long, - signed long long -# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - __extension__ - template - using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, - unsigned char, unsigned short, unsigned int, unsigned long, - unsigned long long -# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - template - using __is_standard_integer - = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; - - - template using __void_t = void; - - - - - - template - struct is_const - : public false_type { }; - - template - struct is_const<_Tp const> - : public true_type { }; - - - template - struct is_volatile - : public false_type { }; - - template - struct is_volatile<_Tp volatile> - : public true_type { }; - - - template - struct is_trivial - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copyable - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_standard_layout - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - template - struct - - is_pod - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct - [[__deprecated__]] - is_literal_type - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_empty - : public integral_constant - { }; - - - template - struct is_polymorphic - : public integral_constant - { }; - - - - - - template - struct is_final - : public integral_constant - { }; - - - - template - struct is_abstract - : public integral_constant - { }; - - - template::value> - struct __is_signed_helper - : public false_type { }; - - template - struct __is_signed_helper<_Tp, true> - : public integral_constant - { }; - - - - template - struct is_signed - : public __is_signed_helper<_Tp>::type - { }; - - - template - struct is_unsigned - : public __and_, __not_>>::type - { }; - - - template - _Up - __declval(int); - - template - _Tp - __declval(long); - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)); - - template - struct remove_all_extents; - - - template - struct __is_array_known_bounds - : public false_type - { }; - - template - struct __is_array_known_bounds<_Tp[_Size]> - : public true_type - { }; - - template - struct __is_array_unknown_bounds - : public false_type - { }; - - template - struct __is_array_unknown_bounds<_Tp[]> - : public true_type - { }; -# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - struct __do_is_destructible_impl - { - template().~_Tp())> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_destructible_impl - : public __do_is_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_destructible_safe; - - template - struct __is_destructible_safe<_Tp, false, false> - : public __is_destructible_impl::type>::type - { }; - - template - struct __is_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_destructible - : public __is_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - - struct __do_is_nt_destructible_impl - { - template - static __bool_constant().~_Tp())> - __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_nt_destructible_impl - : public __do_is_nt_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_nt_destructible_safe; - - template - struct __is_nt_destructible_safe<_Tp, false, false> - : public __is_nt_destructible_impl::type>::type - { }; - - template - struct __is_nt_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_nt_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_nothrow_destructible - : public __is_nt_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_constructible_impl - = __bool_constant<__is_constructible(_Tp, _Args...)>; - - - - template - struct is_constructible - : public __is_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_default_constructible - : public __is_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_lvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> - { using type = _Tp&; }; - - template - using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; - - - - template - struct is_copy_constructible - : public __is_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_rvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> - { using type = _Tp&&; }; - - template - using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; - - - - template - struct is_move_constructible - : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_constructible_impl - = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; - - - - template - struct is_nothrow_constructible - : public __is_nothrow_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_default_constructible - : public __is_nothrow_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; - - - - template - struct is_assignable - : public __is_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_copy_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_move_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_assignable_impl - = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; - - - - template - struct is_nothrow_assignable - : public __is_nothrow_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_constructible_impl - = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; - - - - template - struct is_trivially_constructible - : public __is_trivially_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_default_constructible - : public __is_trivially_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - struct __do_is_implicitly_default_constructible_impl - { - template - static void __helper(const _Tp&); - - template - static true_type __test(const _Tp&, - decltype(__helper({}))* = 0); - - static false_type __test(...); - }; - - template - struct __is_implicitly_default_constructible_impl - : public __do_is_implicitly_default_constructible_impl - { - typedef decltype(__test(declval<_Tp>())) type; - }; - - template - struct __is_implicitly_default_constructible_safe - : public __is_implicitly_default_constructible_impl<_Tp>::type - { }; - - template - struct __is_implicitly_default_constructible - : public __and_<__is_constructible_impl<_Tp>, - __is_implicitly_default_constructible_safe<_Tp>>::type - { }; - - - template - struct is_trivially_copy_constructible - : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_constructible - : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_assignable_impl - = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; - - - - template - struct is_trivially_assignable - : public __is_trivially_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copy_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_destructible - : public __and_<__is_destructible_safe<_Tp>, - __bool_constant<__has_trivial_destructor(_Tp)>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - struct has_virtual_destructor - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct alignment_of - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct rank - : public integral_constant { }; - - template - struct rank<_Tp[_Size]> - : public integral_constant::value> { }; - - template - struct rank<_Tp[]> - : public integral_constant::value> { }; - - - template - struct extent - : public integral_constant { }; - - template - struct extent<_Tp[_Size], 0> - : public integral_constant { }; - - template - struct extent<_Tp[_Size], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - template - struct extent<_Tp[], 0> - : public integral_constant { }; - - template - struct extent<_Tp[], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - - - - - template - struct is_same - - : public integral_constant - - - - { }; -# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_base_of - : public integral_constant - { }; - - - template - struct is_convertible - : public __bool_constant<__is_convertible(_From, _To)> - { }; -# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - using __is_array_convertible - = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; -# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_const - { typedef _Tp type; }; - - template - struct remove_const<_Tp const> - { typedef _Tp type; }; - - - template - struct remove_volatile - { typedef _Tp type; }; - - template - struct remove_volatile<_Tp volatile> - { typedef _Tp type; }; - - - - template - struct remove_cv - { using type = __remove_cv(_Tp); }; -# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct add_const - { using type = _Tp const; }; - - - template - struct add_volatile - { using type = _Tp volatile; }; - - - template - struct add_cv - { using type = _Tp const volatile; }; - - - - - - - template - using remove_const_t = typename remove_const<_Tp>::type; - - - template - using remove_volatile_t = typename remove_volatile<_Tp>::type; - - - template - using remove_cv_t = typename remove_cv<_Tp>::type; - - - template - using add_const_t = typename add_const<_Tp>::type; - - - template - using add_volatile_t = typename add_volatile<_Tp>::type; - - - template - using add_cv_t = typename add_cv<_Tp>::type; -# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_reference - { using type = _Tp; }; - - template - struct remove_reference<_Tp&> - { using type = _Tp; }; - - template - struct remove_reference<_Tp&&> - { using type = _Tp; }; - - - - template - struct add_lvalue_reference - { using type = __add_lval_ref_t<_Tp>; }; - - - template - struct add_rvalue_reference - { using type = __add_rval_ref_t<_Tp>; }; - - - - template - using remove_reference_t = typename remove_reference<_Tp>::type; - - - template - using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; - - - template - using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; - - - - - - - - template - struct __cv_selector; - - template - struct __cv_selector<_Unqualified, false, false> - { 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; }; -# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_unsigned_selector; - - template - class __make_unsigned_selector<_Tp, true, false> - { - using __unsigned_type - = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - class __make_unsigned_selector_base - { - protected: - template struct _List { }; - - template - struct _List<_Tp, _Up...> : _List<_Up...> - { static constexpr size_t __size = sizeof(_Tp); }; - - template - struct __select; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, true> - { using __type = _Uint; }; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, false> - : __select<_Sz, _List<_UInts...>> - { }; - }; - - - template - class __make_unsigned_selector<_Tp, false, true> - : __make_unsigned_selector_base - { - - using _UInts = _List; - - using __unsigned_type = typename __select::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - - - - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; -# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - - - - - - template - struct make_unsigned - { typedef typename __make_unsigned_selector<_Tp>::__type type; }; - - - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - - - - - template - struct __make_signed - { typedef _Tp __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed short __type; }; - - template<> - struct __make_signed - { typedef signed int __type; }; - - template<> - struct __make_signed - { typedef signed long __type; }; - - template<> - struct __make_signed - { typedef signed long long __type; }; -# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_signed_selector; - - template - class __make_signed_selector<_Tp, true, false> - { - using __signed_type - = typename __make_signed<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; - }; - - - template - class __make_signed_selector<_Tp, false, true> - { - typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; - - public: - typedef typename __make_signed_selector<__unsigned_type>::__type __type; - }; - - - - - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; -# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - - - - - - template - struct make_signed - { typedef typename __make_signed_selector<_Tp>::__type type; }; - - - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - - - - template - using make_signed_t = typename make_signed<_Tp>::type; - - - template - using make_unsigned_t = typename make_unsigned<_Tp>::type; - - - - - - template - struct remove_extent - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[_Size]> - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[]> - { typedef _Tp type; }; - - - template - struct remove_all_extents - { typedef _Tp type; }; - - template - struct remove_all_extents<_Tp[_Size]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - template - struct remove_all_extents<_Tp[]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - - - template - using remove_extent_t = typename remove_extent<_Tp>::type; - - - template - using remove_all_extents_t = typename remove_all_extents<_Tp>::type; - - - - - template - struct __remove_pointer_helper - { typedef _Tp type; }; - - template - struct __remove_pointer_helper<_Tp, _Up*> - { typedef _Up type; }; - - - template - struct remove_pointer - : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> - { }; - - template - struct __add_pointer_helper - { using type = _Tp; }; - - template - struct __add_pointer_helper<_Tp, __void_t<_Tp*>> - { using type = _Tp*; }; - - - template - struct add_pointer - : public __add_pointer_helper<_Tp> - { }; - - template - struct add_pointer<_Tp&> - { using type = _Tp*; }; - - template - struct add_pointer<_Tp&&> - { using type = _Tp*; }; - - - - template - using remove_pointer_t = typename remove_pointer<_Tp>::type; - - - template - using add_pointer_t = typename add_pointer<_Tp>::type; - - - template - struct __aligned_storage_msa - { - union __type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__)) { } __align; - }; - }; -# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::__type)> - struct - - aligned_storage - { - union type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__((_Align)))) { } __align; - }; - }; - - template - struct __strictest_alignment - { - static const size_t _S_alignment = 0; - static const size_t _S_size = 0; - }; - - template - struct __strictest_alignment<_Tp, _Types...> - { - static const size_t _S_alignment = - alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment - ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; - static const size_t _S_size = - sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size - ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -#pragma GCC diagnostic pop - - - - - - template - struct __decay_selector - : __conditional_t::value, - remove_cv<_Up>, - add_pointer<_Up>> - { }; - - template - struct __decay_selector<_Up[_Nm]> - { using type = _Up*; }; - - template - struct __decay_selector<_Up[]> - { using type = _Up*; }; - - - - - template - struct decay - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&> - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&&> - { using type = typename __decay_selector<_Tp>::type; }; - - - - - template - struct __strip_reference_wrapper - { - typedef _Tp __type; - }; - - template - struct __strip_reference_wrapper > - { - typedef _Tp& __type; - }; - - - template - using __decay_t = typename decay<_Tp>::type; - - template - using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; - - - - - - template - using _Require = __enable_if_t<__and_<_Cond...>::value>; - - - template - using __remove_cvref_t - = typename remove_cv::type>::type; - - - - - template - struct conditional - { typedef _Iftrue type; }; - - - template - struct conditional - { typedef _Iffalse type; }; - - - template - struct common_type; -# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __success_type - { typedef _Tp type; }; - - struct __failure_type - { }; - - struct __do_common_type_impl - { - template - using __cond_t - = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); - - - - template - static __success_type<__decay_t<__cond_t<_Tp, _Up>>> - _S_test(int); -# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - static __failure_type - _S_test_2(...); - - template - static decltype(_S_test_2<_Tp, _Up>(0)) - _S_test(...); - }; - - - template<> - struct common_type<> - { }; - - - template - struct common_type<_Tp0> - : public common_type<_Tp0, _Tp0> - { }; - - - template, typename _Dp2 = __decay_t<_Tp2>> - struct __common_type_impl - { - - - using type = common_type<_Dp1, _Dp2>; - }; - - template - struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> - : private __do_common_type_impl - { - - - using type = decltype(_S_test<_Tp1, _Tp2>(0)); - }; - - - template - struct common_type<_Tp1, _Tp2> - : public __common_type_impl<_Tp1, _Tp2>::type - { }; - - template - struct __common_type_pack - { }; - - template - struct __common_type_fold; - - - template - struct common_type<_Tp1, _Tp2, _Rp...> - : public __common_type_fold, - __common_type_pack<_Rp...>> - { }; - - - - - template - struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, - __void_t> - : public common_type - { }; - - - template - struct __common_type_fold<_CTp, _Rp, void> - { }; - - template::value> - struct __underlying_type_impl - { - using type = __underlying_type(_Tp); - }; - - template - struct __underlying_type_impl<_Tp, false> - { }; - - - - template - struct underlying_type - : public __underlying_type_impl<_Tp> - { }; - - - template - struct __declval_protector - { - static const bool __stop = false; - }; - - - - - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)) - { - static_assert(__declval_protector<_Tp>::__stop, - "declval() must not be used!"); - return __declval<_Tp>(0); - } - - - template - struct result_of; - - - - - - - struct __invoke_memfun_ref { }; - struct __invoke_memfun_deref { }; - struct __invoke_memobj_ref { }; - struct __invoke_memobj_deref { }; - struct __invoke_other { }; - - - template - struct __result_of_success : __success_type<_Tp> - { using __invoke_type = _Tag; }; - - - struct __result_of_memfun_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_ref - : private __result_of_memfun_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memfun_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_deref - : private __result_of_memfun_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memobj_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>() - ), __invoke_memobj_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_ref - : private __result_of_memobj_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - - struct __result_of_memobj_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>() - ), __invoke_memobj_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_deref - : private __result_of_memobj_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - template - struct __result_of_memobj; - - template - struct __result_of_memobj<_Res _Class::*, _Arg> - { - typedef __remove_cvref_t<_Arg> _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t<__or_, - is_base_of<_Class, _Argval>>::value, - __result_of_memobj_ref<_MemPtr, _Arg>, - __result_of_memobj_deref<_MemPtr, _Arg> - >::type type; - }; - - template - struct __result_of_memfun; - - template - struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> - { - typedef typename remove_reference<_Arg>::type _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t::value, - __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, - __result_of_memfun_deref<_MemPtr, _Arg, _Args...> - >::type type; - }; - - - - - - - template> - struct __inv_unwrap - { - using type = _Tp; - }; - - template - struct __inv_unwrap<_Tp, reference_wrapper<_Up>> - { - using type = _Up&; - }; - - template - struct __result_of_impl - { - typedef __failure_type type; - }; - - template - struct __result_of_impl - : public __result_of_memobj<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type> - { }; - - template - struct __result_of_impl - : public __result_of_memfun<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type, _Args...> - { }; - - - struct __result_of_other_impl - { - template - static __result_of_success()(std::declval<_Args>()...) - ), __invoke_other> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_impl - : private __result_of_other_impl - { - typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; - }; - - - template - struct __invoke_result - : public __result_of_impl< - is_member_object_pointer< - typename remove_reference<_Functor>::type - >::value, - is_member_function_pointer< - typename remove_reference<_Functor>::type - >::value, - _Functor, _ArgTypes... - >::type - { }; - - - template - struct result_of<_Functor(_ArgTypes...)> - : public __invoke_result<_Functor, _ArgTypes...> - { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template::__type)> - using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; - - template - using aligned_union_t = typename aligned_union<_Len, _Types...>::type; -#pragma GCC diagnostic pop - - - template - using decay_t = typename decay<_Tp>::type; - - - template - using enable_if_t = typename enable_if<_Cond, _Tp>::type; - - - template - using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; - - - template - using common_type_t = typename common_type<_Tp...>::type; - - - template - using underlying_type_t = typename underlying_type<_Tp>::type; - - - template - using result_of_t = typename result_of<_Tp>::type; - - - - - - template using void_t = void; -# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template class _Op, typename... _Args> - struct __detector - { - using type = _Default; - using __is_detected = false_type; - }; - - - template class _Op, - typename... _Args> - struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> - { - using type = _Op<_Args...>; - using __is_detected = true_type; - }; - - template class _Op, - typename... _Args> - using __detected_or = __detector<_Default, void, _Op, _Args...>; - - - - template class _Op, - typename... _Args> - using __detected_or_t - = typename __detected_or<_Default, _Op, _Args...>::type; -# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __is_swappable; - - template - struct __is_nothrow_swappable; - - template - struct __is_tuple_like_impl : false_type - { }; - - - template - struct __is_tuple_like - : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type - { }; - - - template - - inline - _Require<__not_<__is_tuple_like<_Tp>>, - is_move_constructible<_Tp>, - is_move_assignable<_Tp>> - swap(_Tp&, _Tp&) - noexcept(__and_, - is_nothrow_move_assignable<_Tp>>::value); - - template - - inline - __enable_if_t<__is_swappable<_Tp>::value> - swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(__is_nothrow_swappable<_Tp>::value); - - - namespace __swappable_details { - using std::swap; - - struct __do_is_swappable_impl - { - template(), std::declval<_Tp&>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_impl - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_nothrow_swappable_impl - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_swappable - : public __is_swappable_impl<_Tp>::type - { }; - - template - struct __is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { }; - - - - - - - - template - struct is_swappable - : public __is_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_v = - is_swappable<_Tp>::value; - - - template - inline constexpr bool is_nothrow_swappable_v = - is_nothrow_swappable<_Tp>::value; - - - - namespace __swappable_with_details { - using std::swap; - - struct __do_is_swappable_with_impl - { - template(), std::declval<_Up>())), - typename - = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_with_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) - && - noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_with_impl - : public __swappable_with_details::__do_is_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - template - struct __is_nothrow_swappable_with_impl - : public __swappable_with_details::__do_is_nothrow_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - - - template - struct is_swappable_with - : public __is_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable_with - : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_with_v = - is_swappable_with<_Tp, _Up>::value; - - - template - inline constexpr bool is_nothrow_swappable_with_v = - is_nothrow_swappable_with<_Tp, _Up>::value; -# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, typename = void> - struct __is_invocable_impl - : false_type - { - using __nothrow_conv = false_type; - }; - - - template - struct __is_invocable_impl<_Result, _Ret, - true, - __void_t> - : true_type - { - using __nothrow_conv = true_type; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - - template - struct __is_invocable_impl<_Result, _Ret, - false, - __void_t> - { - private: - - using _Res_t = typename _Result::type; - - - - static _Res_t _S_get() noexcept; - - - template - static void _S_conv(__type_identity_t<_Tp>) noexcept; - - - template(_S_get())), - typename = decltype(_S_conv<_Tp>(_S_get())), - - - - bool _Dangle = false - - > - static __bool_constant<_Nothrow && !_Dangle> - _S_test(int); - - template - static false_type - _S_test(...); - - public: - - using type = decltype(_S_test<_Ret, true>(1)); - - - using __nothrow_conv = decltype(_S_test<_Ret>(1)); - }; -#pragma GCC diagnostic pop - - template - struct __is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { }; - - template - constexpr bool __call_is_nt(__invoke_memfun_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept((std::declval<_Up>().*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memfun_deref) - { - return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept(std::declval<_Up>().*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_deref) - { - return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_other) - { - return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); - } - - template - struct __call_is_nothrow - : __bool_constant< - std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) - > - { }; - - template - using __call_is_nothrow_ - = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; - - - template - struct __is_nothrow_invocable - : __and_<__is_invocable<_Fn, _Args...>, - __call_is_nothrow_<_Fn, _Args...>>::type - { }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - struct __nonesuchbase {}; - struct __nonesuch : private __nonesuchbase { - ~__nonesuch() = delete; - __nonesuch(__nonesuch const&) = delete; - void operator=(__nonesuch const&) = delete; - }; -#pragma GCC diagnostic pop - - - - - - - template - struct invoke_result - : public __invoke_result<_Functor, _ArgTypes...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), - "_Functor must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; - - - template - struct is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - struct is_invocable_r - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_invocable - : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - - - - template - using __is_nt_invocable_impl - = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; - - - - template - struct is_nothrow_invocable_r - : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; -# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -template - inline constexpr bool is_void_v = is_void<_Tp>::value; -template - inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; -template - inline constexpr bool is_integral_v = is_integral<_Tp>::value; -template - inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; - -template - inline constexpr bool is_array_v = false; -template - inline constexpr bool is_array_v<_Tp[]> = true; -template - inline constexpr bool is_array_v<_Tp[_Num]> = true; - -template - inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; -template - inline constexpr bool is_lvalue_reference_v = false; -template - inline constexpr bool is_lvalue_reference_v<_Tp&> = true; -template - inline constexpr bool is_rvalue_reference_v = false; -template - inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; -template - inline constexpr bool is_member_object_pointer_v = - is_member_object_pointer<_Tp>::value; -template - inline constexpr bool is_member_function_pointer_v = - is_member_function_pointer<_Tp>::value; -template - inline constexpr bool is_enum_v = __is_enum(_Tp); -template - inline constexpr bool is_union_v = __is_union(_Tp); -template - inline constexpr bool is_class_v = __is_class(_Tp); -template - inline constexpr bool is_function_v = is_function<_Tp>::value; -template - inline constexpr bool is_reference_v = false; -template - inline constexpr bool is_reference_v<_Tp&> = true; -template - inline constexpr bool is_reference_v<_Tp&&> = true; -template - inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; -template - inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; -template - inline constexpr bool is_object_v = is_object<_Tp>::value; -template - inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; -template - inline constexpr bool is_compound_v = is_compound<_Tp>::value; -template - inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; -template - inline constexpr bool is_const_v = false; -template - inline constexpr bool is_const_v = true; -template - inline constexpr bool is_volatile_v = false; -template - inline constexpr bool is_volatile_v = true; - -template - inline constexpr bool is_trivial_v = __is_trivial(_Tp); -template - inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); -template - inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); -template - - inline constexpr bool is_pod_v = __is_pod(_Tp); -template - [[__deprecated__]] - inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); -template - inline constexpr bool is_empty_v = __is_empty(_Tp); -template - inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); -template - inline constexpr bool is_abstract_v = __is_abstract(_Tp); -template - inline constexpr bool is_final_v = __is_final(_Tp); - -template - inline constexpr bool is_signed_v = is_signed<_Tp>::value; -template - inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; - -template - inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); -template - inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); -template - inline constexpr bool is_copy_constructible_v - = __is_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_move_constructible_v - = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); -template - inline constexpr bool is_copy_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); -template - inline constexpr bool is_move_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; - -template - inline constexpr bool is_trivially_constructible_v - = __is_trivially_constructible(_Tp, _Args...); -template - inline constexpr bool is_trivially_default_constructible_v - = __is_trivially_constructible(_Tp); -template - inline constexpr bool is_trivially_copy_constructible_v - = __is_trivially_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_constructible_v - = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_trivially_assignable_v - = __is_trivially_assignable(_Tp, _Up); -template - inline constexpr bool is_trivially_copy_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>); -template - inline constexpr bool is_trivially_destructible_v = - is_trivially_destructible<_Tp>::value; -template - inline constexpr bool is_nothrow_constructible_v - = __is_nothrow_constructible(_Tp, _Args...); -template - inline constexpr bool is_nothrow_default_constructible_v - = __is_nothrow_constructible(_Tp); -template - inline constexpr bool is_nothrow_copy_constructible_v - = __is_nothrow_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_constructible_v - = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_assignable_v - = __is_nothrow_assignable(_Tp, _Up); -template - inline constexpr bool is_nothrow_copy_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_destructible_v = - is_nothrow_destructible<_Tp>::value; - -template - inline constexpr bool has_virtual_destructor_v - = __has_virtual_destructor(_Tp); - -template - inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; - -template - inline constexpr size_t rank_v = 0; -template - inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; -template - inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; - -template - inline constexpr size_t extent_v = 0; -template - inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; -template - inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; -template - inline constexpr size_t extent_v<_Tp[], 0> = 0; -template - inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; - - -template - inline constexpr bool is_same_v = __is_same(_Tp, _Up); - - - - - - -template - inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); -template - inline constexpr bool is_convertible_v = __is_convertible(_From, _To); -template - inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_v - = is_nothrow_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_invocable_r_v - = is_invocable_r<_Ret, _Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_r_v - = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; - - - - - - - template - struct has_unique_object_representations - : bool_constant<__has_unique_object_representations( - remove_cv_t> - )> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - inline constexpr bool has_unique_object_representations_v - = has_unique_object_representations<_Tp>::value; - - - - - - - template - struct is_aggregate - : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> - { }; - - - - - - template - inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); -# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - void - __throw_bad_exception(void) __attribute__((__noreturn__)); - - - void - __throw_bad_alloc(void) __attribute__((__noreturn__)); - - void - __throw_bad_array_new_length(void) __attribute__((__noreturn__)); - - - void - __throw_bad_cast(void) __attribute__((__noreturn__)); - - void - __throw_bad_typeid(void) __attribute__((__noreturn__)); - - - void - __throw_logic_error(const char*) __attribute__((__noreturn__)); - - void - __throw_domain_error(const char*) __attribute__((__noreturn__)); - - void - __throw_invalid_argument(const char*) __attribute__((__noreturn__)); - - void - __throw_length_error(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) - __attribute__((__format__(__gnu_printf__, 1, 2))); - - void - __throw_runtime_error(const char*) __attribute__((__noreturn__)); - - void - __throw_range_error(const char*) __attribute__((__noreturn__)); - - void - __throw_overflow_error(const char*) __attribute__((__noreturn__)); - - void - __throw_underflow_error(const char*) __attribute__((__noreturn__)); - - - void - __throw_ios_failure(const char*) __attribute__((__noreturn__)); - - void - __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); - - - void - __throw_system_error(int) __attribute__((__noreturn__)); - - - void - __throw_future_error(int) __attribute__((__noreturn__)); - - - void - __throw_bad_function_call() __attribute__((__noreturn__)); -# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -} -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - struct __true_type { }; - struct __false_type { }; - - template - struct __truth_type - { typedef __false_type __type; }; - - template<> - struct __truth_type - { typedef __true_type __type; }; - - - - template - struct __traitor - { - enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; - typedef typename __truth_type<__value>::__type __type; - }; - - - template - struct __are_same - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __are_same<_Tp, _Tp> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_void - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_void - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_integer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; - }; -# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template - struct __is_pointer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __is_pointer<_Tp*> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_arithmetic - : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > - { }; - - - - - template - struct __is_scalar - : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > - { }; - - - - - template - struct __is_char - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_byte - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - enum class byte : unsigned char; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template struct iterator_traits; - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = __is_trivially_copyable(_Tp) }; - }; - - - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = 0 }; - }; - - - template - struct __memcpyable - { - enum { __value = 0 }; - }; - - template - struct __memcpyable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcpyable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - template - struct __memcmpable - { - enum { __value = 0 }; - }; - - - template - struct __memcmpable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - - template::__value - - > - struct __is_memcmp_ordered - { - static const bool __value = _Tp(-1) > _Tp(1); - }; - - template - struct __is_memcmp_ordered<_Tp, false> - { - static const bool __value = false; - }; - - - template - struct __is_memcmp_ordered_with - { - static const bool __value = __is_memcmp_ordered<_Tp>::__value - && __is_memcmp_ordered<_Up>::__value; - }; - - template - struct __is_memcmp_ordered_with<_Tp, _Up, false> - { - static const bool __value = false; - }; -# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_memcmp_ordered_with - { static constexpr bool __value = true; }; - - template - struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> - { static constexpr bool __value = false; }; - - template - struct __is_memcmp_ordered_with - { static constexpr bool __value = false; }; - - - - - - template - struct __is_move_iterator - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - template - - inline _Iterator - __miter_base(_Iterator __it) - { return __it; } - - -} -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - - - - -extern "C++" { - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct __enable_if - { }; - - template - struct __enable_if - { typedef _Tp __type; }; - - - - template - struct __conditional_type - { typedef _Iftrue __type; }; - - template - struct __conditional_type - { typedef _Iffalse __type; }; - - - - template - struct __add_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned short __type; }; - - template<> - struct __add_unsigned - { typedef unsigned int __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long long __type; }; - - - template<> - struct __add_unsigned; - - template<> - struct __add_unsigned; - - - - template - struct __remove_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef short __type; }; - - template<> - struct __remove_unsigned - { typedef int __type; }; - - template<> - struct __remove_unsigned - { typedef long __type; }; - - template<> - struct __remove_unsigned - { typedef long long __type; }; - - - template<> - struct __remove_unsigned; - - template<> - struct __remove_unsigned; - - - - template - constexpr - inline bool - __is_null_pointer(_Type* __ptr) - { return __ptr == 0; } - - template - constexpr - inline bool - __is_null_pointer(_Type) - { return false; } - - - constexpr bool - __is_null_pointer(std::nullptr_t) - { return true; } - - - - - template::__value> - struct __promote - { typedef double __type; }; - - - - - template - struct __promote<_Tp, false> - { }; - - template<> - struct __promote - { typedef long double __type; }; - - template<> - struct __promote - { typedef double __type; }; - - template<> - struct __promote - { typedef float __type; }; -# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - template - using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); - - - - template - using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; - - template - using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; - - template - using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 -} -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - - - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __is_integer_nonstrict - : public std::__is_integer<_Tp> - { - using std::__is_integer<_Tp>::__value; - - - enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; - }; - - template - struct __numeric_traits_integer - { - - static_assert(__is_integer_nonstrict<_Value>::__value, - "invalid specialization"); - - - - - static const bool __is_signed = (_Value)(-1) < 0; - static const int __digits - = __is_integer_nonstrict<_Value>::__width - __is_signed; - - - static const _Value __max = __is_signed - ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) - : ~(_Value)0; - static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; - }; - - template - const _Value __numeric_traits_integer<_Value>::__min; - - template - const _Value __numeric_traits_integer<_Value>::__max; - - template - const bool __numeric_traits_integer<_Value>::__is_signed; - - template - const int __numeric_traits_integer<_Value>::__digits; -# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; - - - - - - - template - using __int_traits = __numeric_traits_integer<_Tp>; -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __numeric_traits_floating - { - - static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); - - - static const bool __is_signed = true; - static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); - static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); - }; - - template - const int __numeric_traits_floating<_Value>::__max_digits10; - - template - const bool __numeric_traits_floating<_Value>::__is_signed; - - template - const int __numeric_traits_floating<_Value>::__digits10; - - template - const int __numeric_traits_floating<_Value>::__max_exponent10; - - - - - - - template - struct __numeric_traits - : public __numeric_traits_integer<_Value> - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; -# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 -} -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - inline constexpr _Tp* - __addressof(_Tp& __r) noexcept - { return __builtin_addressof(__r); } -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type& __t) noexcept - { return static_cast<_Tp&&>(__t); } - - - - - - - - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type&& __t) noexcept - { - static_assert(!std::is_lvalue_reference<_Tp>::value, - "std::forward must not be used to convert an rvalue to an lvalue"); - return static_cast<_Tp&&>(__t); - } - - - - - - - template - [[__nodiscard__]] - constexpr typename std::remove_reference<_Tp>::type&& - move(_Tp&& __t) noexcept - { return static_cast::type&&>(__t); } - - - template - struct __move_if_noexcept_cond - : public __and_<__not_>, - is_copy_constructible<_Tp>>::type { }; -# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr - __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> - move_if_noexcept(_Tp& __x) noexcept - { return std::move(__x); } -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - inline constexpr _Tp* - addressof(_Tp& __r) noexcept - { return std::__addressof(__r); } - - - - template - const _Tp* addressof(const _Tp&&) = delete; - - - template - - inline _Tp - __exchange(_Tp& __obj, _Up&& __new_val) - { - _Tp __old_val = std::move(__obj); - __obj = std::forward<_Up>(__new_val); - return __old_val; - } -# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - - inline - - typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, - is_move_constructible<_Tp>, - is_move_assignable<_Tp>>::value>::type - - - - swap(_Tp& __a, _Tp& __b) - noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) - - { - - - - - _Tp __tmp = std::move(__a); - __a = std::move(__b); - __b = std::move(__tmp); - } - - - - - template - - inline - - typename enable_if<__is_swappable<_Tp>::value>::type - - - - swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(__is_nothrow_swappable<_Tp>::value) - { - for (size_t __n = 0; __n < _Nm; ++__n) - swap(__a[__n], __b[__n]); - } - - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct tuple_size; - - - - - - template::type, - typename = typename enable_if::value>::type, - size_t = tuple_size<_Tp>::value> - using __enable_if_has_tuple_size = _Tp; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - - template - inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; - - - - template - struct tuple_element; - - - template - using __tuple_element_t = typename tuple_element<__i, _Tp>::type; - - template - struct tuple_element<__i, const _Tp> - { - using type = const __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, volatile _Tp> - { - using type = volatile __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, const volatile _Tp> - { - using type = const volatile __tuple_element_t<__i, _Tp>; - }; - - - - - - template - constexpr size_t - __find_uniq_type_in_pack() - { - constexpr size_t __sz = sizeof...(_Types); - constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; - size_t __n = __sz; - for (size_t __i = 0; __i < __sz; ++__i) - { - if (__found[__i]) - { - if (__n < __sz) - return __sz; - __n = __i; - } - } - return __n; - } -# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - template - using tuple_element_t = typename tuple_element<__i, _Tp>::type; - - - - - template struct _Index_tuple { }; - - - template - struct _Build_index_tuple - { - - template - using _IdxTuple = _Index_tuple<_Indices...>; - - - using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; - - - - - }; - - - - - - - template - struct integer_sequence - { - typedef _Tp value_type; - static constexpr size_t size() noexcept { return sizeof...(_Idx); } - }; - - - template - using make_integer_sequence - - = __make_integer_seq; - - - - - - template - using index_sequence = integer_sequence; - - - template - using make_index_sequence = make_integer_sequence; - - - template - using index_sequence_for = make_index_sequence; - - - - struct in_place_t { - explicit in_place_t() = default; - }; - - inline constexpr in_place_t in_place{}; - - template struct in_place_type_t - { - explicit in_place_type_t() = default; - }; - - template - inline constexpr in_place_type_t<_Tp> in_place_type{}; - - template struct in_place_index_t - { - explicit in_place_index_t() = default; - }; - - template - inline constexpr in_place_index_t<_Idx> in_place_index{}; - - template - inline constexpr bool __is_in_place_type_v = false; - - template - inline constexpr bool __is_in_place_type_v> = true; - - template - using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; - - - - - template - struct _Nth_type - { }; - - template - struct _Nth_type<0, _Tp0, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Rest...> - { using type = _Tp1; }; - - template - struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp2; }; - - template - - - - struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> - : _Nth_type<_Np - 3, _Rest...> - { }; - - - template - struct _Nth_type<0, _Tp0, _Tp1, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp1; }; - - - - - - - -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; - - - inline constexpr piecewise_construct_t piecewise_construct = - piecewise_construct_t(); - - - - - template - class tuple; - - template - struct _Index_tuple; - - - - - - - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return __and_, - is_constructible<_T2, const _U2&>>::value; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return __and_, - is_convertible>::value; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return __and_, - is_constructible<_T2, _U2&&>>::value; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return __and_, - is_convertible<_U2&&, _T2>>::value; - } - }; - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return false; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return false; - } - }; - - - - template class __pair_base - { - - template friend struct pair; - __pair_base() = default; - ~__pair_base() = default; - __pair_base(const __pair_base&) = default; - __pair_base& operator=(const __pair_base&) = delete; - - }; -# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct pair - : public __pair_base<_T1, _T2> - { - typedef _T1 first_type; - typedef _T2 second_type; - - _T1 first; - _T2 second; - - - constexpr pair(const pair&) = default; - constexpr pair(pair&&) = default; - - template - - pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); - - - void - swap(pair& __p) - noexcept(__and_<__is_nothrow_swappable<_T1>, - __is_nothrow_swappable<_T2>>::value) - { - using std::swap; - swap(first, __p.first); - swap(second, __p.second); - } -# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - template - - pair(tuple<_Args1...>&, tuple<_Args2...>&, - _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); - public: -# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template , - __is_implicitly_default_constructible<_U2>> - ::value, bool>::type = true> - constexpr pair() - : first(), second() { } - - template , - is_default_constructible<_U2>, - __not_< - __and_<__is_implicitly_default_constructible<_U1>, - __is_implicitly_default_constructible<_U2>>>> - ::value, bool>::type = false> - explicit constexpr pair() - : first(), second() { } - - - - using _PCCP = _PCC; - - - - template() - && _PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - template() - && !_PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - - template - using _PCCFP = _PCC::value - || !is_same<_T2, _U2>::value, - _T1, _T2>; - - - template::template - _ConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } - - template::template - _ConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } -# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - - - - struct __zero_as_null_pointer_constant - { - __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) - { } - template::value>> - __zero_as_null_pointer_constant(_Tp) = delete; - }; - - public: - - - - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - is_convertible<_U1, _T1>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - is_convertible<_U2, _T2>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - - - template() - && _PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - template() - && !_PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - - template::template - _MoveConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - template::template - _MoveConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - - - pair& - operator=(__conditional_t<__and_, - is_copy_assignable<_T2>>::value, - const pair&, const __nonesuch&> __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - pair& - operator=(__conditional_t<__and_, - is_move_assignable<_T2>>::value, - pair&&, __nonesuch&&> __p) - noexcept(__and_, - is_nothrow_move_assignable<_T2>>::value) - { - first = std::forward(__p.first); - second = std::forward(__p.second); - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, const _U2&>>::value, - pair&>::type - operator=(const pair<_U1, _U2>& __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, _U2&&>>::value, - pair&>::type - operator=(pair<_U1, _U2>&& __p) - { - first = std::forward<_U1>(__p.first); - second = std::forward<_U2>(__p.second); - return *this; - } -# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - }; - - - - - template pair(_T1, _T2) -> pair<_T1, _T2>; - - - - template - inline constexpr bool - operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first == __y.first && __x.second == __y.second; } -# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline constexpr bool - operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first < __y.first - || (!(__y.first < __x.first) && __x.second < __y.second); } - - - template - inline constexpr bool - operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x == __y); } - - - template - inline constexpr bool - operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __y < __x; } - - - template - inline constexpr bool - operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__y < __x); } - - - template - inline constexpr bool - operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x < __y); } -# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline - - - typename enable_if<__and_<__is_swappable<_T1>, - __is_swappable<_T2>>::value>::type - - - - swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } -# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - typename enable_if, - __is_swappable<_T2>>::value>::type - swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; -# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - constexpr pair::__type, - typename __decay_and_strip<_T2>::__type> - make_pair(_T1&& __x, _T2&& __y) - { - typedef typename __decay_and_strip<_T1>::__type __ds_type1; - typedef typename __decay_and_strip<_T2>::__type __ds_type2; - typedef pair<__ds_type1, __ds_type2> __pair_type; - return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); - } -# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct __is_tuple_like_impl> : true_type - { }; - - - - template - struct tuple_size> - : public integral_constant { }; - - - template - struct tuple_element<0, pair<_Tp1, _Tp2>> - { typedef _Tp1 type; }; - - - template - struct tuple_element<1, pair<_Tp1, _Tp2>> - { typedef _Tp2 type; }; - - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr bool __is_pair = false; - - template - inline constexpr bool __is_pair> = true; - - - - template - struct __pair_get; - - template<> - struct __pair_get<0> - { - template - static constexpr _Tp1& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr _Tp1&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp1>(__pair.first); } - - template - static constexpr const _Tp1& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr const _Tp1&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.first); } - }; - - template<> - struct __pair_get<1> - { - template - static constexpr _Tp2& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr _Tp2&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp2>(__pair.second); } - - template - static constexpr const _Tp2& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr const _Tp2&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.second); } - }; - - - - - - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__get(__in); } - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__move_get(std::move(__in)); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(const pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__const_get(__in); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(const pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__const_move_get(std::move(__in)); } - - - - - - template - constexpr _Tp& - get(pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr const _Tp& - get(const pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr _Tp&& - get(pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr const _Tp&& - get(const pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr _Tp& - get(pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr const _Tp& - get(const pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr _Tp&& - get(pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } - - template - constexpr const _Tp&& - get(const pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } -# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - struct input_iterator_tag { }; - - - struct output_iterator_tag { }; - - - struct forward_iterator_tag : public input_iterator_tag { }; - - - - struct bidirectional_iterator_tag : public forward_iterator_tag { }; - - - - struct random_access_iterator_tag : public bidirectional_iterator_tag { }; -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct [[__deprecated__]] iterator - { - - typedef _Category iterator_category; - - typedef _Tp value_type; - - typedef _Distance difference_type; - - typedef _Pointer pointer; - - typedef _Reference reference; - }; -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits; - - - - - template> - struct __iterator_traits { }; - - - - template - struct __iterator_traits<_Iterator, - __void_t> - { - typedef typename _Iterator::iterator_category iterator_category; - typedef typename _Iterator::value_type value_type; - typedef typename _Iterator::difference_type difference_type; - typedef typename _Iterator::pointer pointer; - typedef typename _Iterator::reference reference; - }; - - - template - struct iterator_traits - : public __iterator_traits<_Iterator> { }; -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits<_Tp*> - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; - }; - - - template - struct iterator_traits - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; - }; - - - - - - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_Iter>::iterator_category - __iterator_category(const _Iter&) - { return typename iterator_traits<_Iter>::iterator_category(); } - - - - - template - using __iterator_category_t - = typename iterator_traits<_Iter>::iterator_category; - - template - using _RequireInputIter = - __enable_if_t, - input_iterator_tag>::value>; - - template> - struct __is_random_access_iter - : is_base_of - { - typedef is_base_of _Base; - enum { __value = _Base::value }; - }; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template struct _List_iterator; - template struct _List_const_iterator; - - - template - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - __distance(_InputIterator __first, _InputIterator __last, - input_iterator_tag) - { - - - - typename iterator_traits<_InputIterator>::difference_type __n = 0; - while (__first != __last) - { - ++__first; - ++__n; - } - return __n; - } - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_RandomAccessIterator>::difference_type - __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, - random_access_iterator_tag) - { - - - - return __last - __first; - } - - - - template - ptrdiff_t - __distance(std::_List_iterator<_Tp>, - std::_List_iterator<_Tp>, - input_iterator_tag); - - template - ptrdiff_t - __distance(std::_List_const_iterator<_Tp>, - std::_List_const_iterator<_Tp>, - input_iterator_tag); - - - - - template - void - __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; -# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - [[__nodiscard__]] __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - distance(_InputIterator __first, _InputIterator __last) - { - - return std::__distance(__first, __last, - std::__iterator_category(__first)); - } - - template - inline constexpr void - __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) - { - - - do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); - while (__n--) - ++__i; - } - - template - inline constexpr void - __advance(_BidirectionalIterator& __i, _Distance __n, - bidirectional_iterator_tag) - { - - - - if (__n > 0) - while (__n--) - ++__i; - else - while (__n++) - --__i; - } - - template - inline constexpr void - __advance(_RandomAccessIterator& __i, _Distance __n, - random_access_iterator_tag) - { - - - - if (__builtin_constant_p(__n) && __n == 1) - ++__i; - else if (__builtin_constant_p(__n) && __n == -1) - --__i; - else - __i += __n; - } - - - - template - void - __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; -# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - __attribute__((__always_inline__)) - inline constexpr void - advance(_InputIterator& __i, _Distance __n) - { - - typename iterator_traits<_InputIterator>::difference_type __d = __n; - std::__advance(__i, __d, std::__iterator_category(__i)); - } - - - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _InputIterator - next(_InputIterator __x, typename - iterator_traits<_InputIterator>::difference_type __n = 1) - { - - - std::advance(__x, __n); - return __x; - } - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _BidirectionalIterator - prev(_BidirectionalIterator __x, typename - iterator_traits<_BidirectionalIterator>::difference_type __n = 1) - { - - - - std::advance(__x, -__n); - return __x; - } - - - - -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 -# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - class __undefined; - - - - template - struct __get_first_arg - { using type = __undefined; }; - - template class _SomeTemplate, typename _Tp, - typename... _Types> - struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> - { using type = _Tp; }; - - - - template - struct __replace_first_arg - { }; - - template class _SomeTemplate, typename _Up, - typename _Tp, typename... _Types> - struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> - { using type = _SomeTemplate<_Up, _Types...>; }; - - - template - struct __ptr_traits_elem : __get_first_arg<_Ptr> - { }; - - - - - - - - template - struct __ptr_traits_elem<_Ptr, __void_t> - { using type = typename _Ptr::element_type; }; - - - template - using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; - - - - - template::value> - struct __ptr_traits_ptr_to - { - using pointer = _Ptr; - using element_type = _Elt; - - - - - - - - static pointer - pointer_to(element_type& __r) - - - - - - { return pointer::pointer_to(__r); } - }; - - - template - struct __ptr_traits_ptr_to<_Ptr, _Elt, true> - { }; - - - template - struct __ptr_traits_ptr_to<_Tp*, _Tp, false> - { - using pointer = _Tp*; - using element_type = _Tp; - - - - - - - static pointer - pointer_to(element_type& __r) noexcept - { return std::addressof(__r); } - }; - - template - struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> - { - private: - template - using __diff_t = typename _Tp::difference_type; - - template - using __rebind = __type_identity>; - - public: - - using pointer = _Ptr; - - - using element_type = _Elt; - - - using difference_type = __detected_or_t; - - - template - using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, - __rebind, _Ptr, _Up>::type; - }; - - - - template - struct __ptr_traits_impl<_Ptr, __undefined> - { }; - - - - - - - - template - struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> - { }; - - - - - - - - template - struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> - { - - typedef _Tp* pointer; - - typedef _Tp element_type; - - typedef ptrdiff_t difference_type; - - template using rebind = _Up*; - }; - - - template - using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; - - template - constexpr _Tp* - __to_address(_Tp* __ptr) noexcept - { - static_assert(!std::is_function<_Tp>::value, "not a function pointer"); - return __ptr; - } - - - template - constexpr typename std::pointer_traits<_Ptr>::element_type* - __to_address(const _Ptr& __ptr) - { return std::__to_address(__ptr.operator->()); } -# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 -# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class reverse_iterator - : public iterator::iterator_category, - typename iterator_traits<_Iterator>::value_type, - typename iterator_traits<_Iterator>::difference_type, - typename iterator_traits<_Iterator>::pointer, - typename iterator_traits<_Iterator>::reference> - { - template - friend class reverse_iterator; -# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - protected: - _Iterator current; - - typedef iterator_traits<_Iterator> __traits_type; - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::pointer pointer; - - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - constexpr - reverse_iterator() - noexcept(noexcept(_Iterator())) - : current() - { } - - - - - explicit constexpr - reverse_iterator(iterator_type __x) - noexcept(noexcept(_Iterator(__x))) - : current(__x) - { } - - - - - constexpr - reverse_iterator(const reverse_iterator& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - reverse_iterator& operator=(const reverse_iterator&) = default; - - - - - - - template - - - - constexpr - reverse_iterator(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - template - - - - - constexpr - reverse_iterator& - operator=(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(current = __x.current)) - { - current = __x.current; - return *this; - } - - - - - - [[__nodiscard__]] - constexpr iterator_type - base() const - noexcept(noexcept(_Iterator(current))) - { return current; } -# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - { - _Iterator __tmp = current; - return *--__tmp; - } - - - - - - - [[__nodiscard__]] - constexpr pointer - operator->() const - - - - - { - - - _Iterator __tmp = current; - --__tmp; - return _S_to_pointer(__tmp); - } - - - - - - - constexpr reverse_iterator& - operator++() - { - --current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator++(int) - { - reverse_iterator __tmp = *this; - --current; - return __tmp; - } - - - - - - - constexpr reverse_iterator& - operator--() - { - ++current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator--(int) - { - reverse_iterator __tmp = *this; - ++current; - return __tmp; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator+(difference_type __n) const - { return reverse_iterator(current - __n); } - - - - - - - - constexpr reverse_iterator& - operator+=(difference_type __n) - { - current -= __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator-(difference_type __n) const - { return reverse_iterator(current + __n); } - - - - - - - - constexpr reverse_iterator& - operator-=(difference_type __n) - { - current += __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - { return *(*this + __n); } -# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - private: - template - static constexpr _Tp* - _S_to_pointer(_Tp* __p) - { return __p; } - - template - static constexpr pointer - _S_to_pointer(_Tp __t) - { return __t.operator->(); } - }; -# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y.base() < __x.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() > __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() != __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() < __y.base(); } - - template - inline constexpr bool - operator<=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() >= __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() <= __y.base(); } -# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr auto - operator-(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - -> decltype(__y.base() - __x.base()) - { return __y.base() - __x.base(); } - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - operator+(typename reverse_iterator<_Iterator>::difference_type __n, - const reverse_iterator<_Iterator>& __x) - { return reverse_iterator<_Iterator>(__x.base() - __n); } - - - - template - inline constexpr reverse_iterator<_Iterator> - __make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } - - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } -# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) - { return __make_reverse_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - : __is_move_iterator<_Iterator> - { }; - - template - - auto - __miter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) - { return __make_reverse_iterator(__miter_base(__it.base())); } -# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class back_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - back_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - back_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_back(__value); - return *this; - } - - - back_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_back(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - back_insert_iterator& - operator*() - { return *this; } - - - - back_insert_iterator& - operator++() - { return *this; } - - - - back_insert_iterator - operator++(int) - { return *this; } - }; -# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline back_insert_iterator<_Container> - back_inserter(_Container& __x) - { return back_insert_iterator<_Container>(__x); } -# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class front_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - front_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - front_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_front(__value); - return *this; - } - - - front_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_front(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - front_insert_iterator& - operator*() - { return *this; } - - - - front_insert_iterator& - operator++() - { return *this; } - - - - front_insert_iterator - operator++(int) - { return *this; } - }; -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline front_insert_iterator<_Container> - front_inserter(_Container& __x) - { return front_insert_iterator<_Container>(__x); } -# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class insert_iterator - : public iterator - { - - - - typedef typename _Container::iterator _Iter; - - protected: - _Container* container; - _Iter iter; - - public: - - typedef _Container container_type; -# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator(_Container& __x, _Iter __i) - : container(std::__addressof(__x)), iter(__i) {} -# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator& - operator=(const typename _Container::value_type& __value) - { - iter = container->insert(iter, __value); - ++iter; - return *this; - } - - - insert_iterator& - operator=(typename _Container::value_type&& __value) - { - iter = container->insert(iter, std::move(__value)); - ++iter; - return *this; - } - - - - [[__nodiscard__]] - insert_iterator& - operator*() - { return *this; } - - - - insert_iterator& - operator++() - { return *this; } - - - - insert_iterator& - operator++(int) - { return *this; } - }; - -#pragma GCC diagnostic pop -# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline insert_iterator<_Container> - inserter(_Container& __x, typename _Container::iterator __i) - { return insert_iterator<_Container>(__x, __i); } - - - - - -} - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class __normal_iterator - { - protected: - _Iterator _M_current; - - typedef std::iterator_traits<_Iterator> __traits_type; - - - template - using __convertible_from - = std::__enable_if_t::value>; - - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; - typedef typename __traits_type::pointer pointer; - - - - - - constexpr __normal_iterator() noexcept - : _M_current(_Iterator()) { } - - explicit - __normal_iterator(const _Iterator& __i) noexcept - : _M_current(__i) { } - - - - template> - - __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) - noexcept -# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - : _M_current(__i.base()) { } - - - - reference - operator*() const noexcept - { return *_M_current; } - - - pointer - operator->() const noexcept - { return _M_current; } - - - __normal_iterator& - operator++() noexcept - { - ++_M_current; - return *this; - } - - - __normal_iterator - operator++(int) noexcept - { return __normal_iterator(_M_current++); } - - - - __normal_iterator& - operator--() noexcept - { - --_M_current; - return *this; - } - - - __normal_iterator - operator--(int) noexcept - { return __normal_iterator(_M_current--); } - - - - reference - operator[](difference_type __n) const noexcept - { return _M_current[__n]; } - - - __normal_iterator& - operator+=(difference_type __n) noexcept - { _M_current += __n; return *this; } - - - __normal_iterator - operator+(difference_type __n) const noexcept - { return __normal_iterator(_M_current + __n); } - - - __normal_iterator& - operator-=(difference_type __n) noexcept - { _M_current -= __n; return *this; } - - - __normal_iterator - operator-(difference_type __n) const noexcept - { return __normal_iterator(_M_current - __n); } - - - const _Iterator& - base() const noexcept - { return _M_current; } - }; -# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - - - - - - template - - - [[__nodiscard__]] - inline auto - operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept - -> decltype(__lhs.base() - __rhs.base()) - - - - - - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline typename __normal_iterator<_Iterator, _Container>::difference_type - operator-(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline __normal_iterator<_Iterator, _Container> - operator+(typename __normal_iterator<_Iterator, _Container>::difference_type - __n, const __normal_iterator<_Iterator, _Container>& __i) - noexcept - { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } - - -} - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - - _Iterator - __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it.base(); } - - - - - - - template - constexpr auto - __to_address(const __gnu_cxx::__normal_iterator<_Iterator, - _Container>& __it) noexcept - -> decltype(std::__to_address(__it.base())) - { return std::__to_address(__it.base()); } -# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - namespace __detail - { -# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - } -# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class move_iterator - - - - { - _Iterator _M_current; - - using __traits_type = iterator_traits<_Iterator>; - - using __base_ref = typename __traits_type::reference; - - - template - friend class move_iterator; -# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - public: - using iterator_type = _Iterator; -# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - - typedef _Iterator pointer; - - - using reference - = __conditional_t::value, - typename remove_reference<__base_ref>::type&&, - __base_ref>; - - - constexpr - move_iterator() - : _M_current() { } - - explicit constexpr - move_iterator(iterator_type __i) - : _M_current(std::move(__i)) { } - - template - - - - constexpr - move_iterator(const move_iterator<_Iter>& __i) - : _M_current(__i._M_current) { } - - template - - - - - constexpr - move_iterator& operator=(const move_iterator<_Iter>& __i) - { - _M_current = __i._M_current; - return *this; - } - - - [[__nodiscard__]] - constexpr iterator_type - base() const - { return _M_current; } -# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - - - - { return static_cast(*_M_current); } - - - [[__nodiscard__]] - constexpr pointer - operator->() const - { return _M_current; } - - constexpr move_iterator& - operator++() - { - ++_M_current; - return *this; - } - - constexpr move_iterator - operator++(int) - { - move_iterator __tmp = *this; - ++_M_current; - return __tmp; - } - - - - - - - - constexpr move_iterator& - operator--() - { - --_M_current; - return *this; - } - - constexpr move_iterator - operator--(int) - { - move_iterator __tmp = *this; - --_M_current; - return __tmp; - } - - [[__nodiscard__]] - constexpr move_iterator - operator+(difference_type __n) const - { return move_iterator(_M_current + __n); } - - constexpr move_iterator& - operator+=(difference_type __n) - { - _M_current += __n; - return *this; - } - - [[__nodiscard__]] - constexpr move_iterator - operator-(difference_type __n) const - { return move_iterator(_M_current - __n); } - - constexpr move_iterator& - operator-=(difference_type __n) - { - _M_current -= __n; - return *this; - } - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - - - - { return std::move(_M_current[__n]); } -# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - }; - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() == __y.base(); } -# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - { return !(__x == __y); } - - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } -# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - template - [[__nodiscard__]] - inline constexpr auto - operator-(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - -> decltype(__x.base() - __y.base()) - { return __x.base() - __y.base(); } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - operator+(typename move_iterator<_Iterator>::difference_type __n, - const move_iterator<_Iterator>& __x) - { return __x + __n; } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - make_move_iterator(_Iterator __i) - { return move_iterator<_Iterator>(std::move(__i)); } - - template::value_type>::value, - _Iterator, move_iterator<_Iterator>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Iterator __i) - { return _ReturnType(__i); } - - - - template::value, - const _Tp*, move_iterator<_Tp*>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Tp* __i) - { return _ReturnType(__i); } -# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(move_iterator<_Iterator> __it) - -> decltype(make_move_iterator(__niter_base(__it.base()))) - { return make_move_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template - - auto - __miter_base(move_iterator<_Iterator> __it) - -> decltype(__miter_base(__it.base())) - { return __miter_base(__it.base()); } -# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - using __iter_key_t = remove_const_t< - typename iterator_traits<_InputIterator>::value_type::first_type>; - - template - using __iter_val_t - = typename iterator_traits<_InputIterator>::value_type::second_type; - - template - struct pair; - - template - using __iter_to_alloc_t - = pair, __iter_val_t<_InputIterator>>; - - - -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 -namespace std -{ - namespace __debug { } -} - - - - -namespace __gnu_debug -{ - using namespace std::__debug; - - template - struct _Safe_iterator; -} -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 -namespace __gnu_cxx -{ -namespace __ops -{ - struct _Iter_less_iter - { - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 < *__it2; } - }; - - constexpr - inline _Iter_less_iter - __iter_less_iter() - { return _Iter_less_iter(); } - - struct _Iter_less_val - { - - constexpr _Iter_less_val() = default; - - - - - - explicit - _Iter_less_val(_Iter_less_iter) { } - - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it < __val; } - }; - - - inline _Iter_less_val - __iter_less_val() - { return _Iter_less_val(); } - - - inline _Iter_less_val - __iter_comp_val(_Iter_less_iter) - { return _Iter_less_val(); } - - struct _Val_less_iter - { - - constexpr _Val_less_iter() = default; - - - - - - explicit - _Val_less_iter(_Iter_less_iter) { } - - template - - bool - operator()(_Value& __val, _Iterator __it) const - { return __val < *__it; } - }; - - - inline _Val_less_iter - __val_less_iter() - { return _Val_less_iter(); } - - - inline _Val_less_iter - __val_comp_iter(_Iter_less_iter) - { return _Val_less_iter(); } - - struct _Iter_equal_to_iter - { - template - - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 == *__it2; } - }; - - - inline _Iter_equal_to_iter - __iter_equal_to_iter() - { return _Iter_equal_to_iter(); } - - struct _Iter_equal_to_val - { - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it == __val; } - }; - - - inline _Iter_equal_to_val - __iter_equal_to_val() - { return _Iter_equal_to_val(); } - - - inline _Iter_equal_to_val - __iter_comp_val(_Iter_equal_to_iter) - { return _Iter_equal_to_val(); } - - template - struct _Iter_comp_iter - { - _Compare _M_comp; - - explicit constexpr - _Iter_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) - { return bool(_M_comp(*__it1, *__it2)); } - }; - - template - constexpr - inline _Iter_comp_iter<_Compare> - __iter_comp_iter(_Compare __comp) - { return _Iter_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_comp_val - { - _Compare _M_comp; - - - explicit - _Iter_comp_val(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Iterator __it, _Value& __val) - { return bool(_M_comp(*__it, __val)); } - }; - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Compare __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Iter_comp_iter<_Compare> __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - struct _Val_comp_iter - { - _Compare _M_comp; - - - explicit - _Val_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Value& __val, _Iterator __it) - { return bool(_M_comp(__val, *__it)); } - }; - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Compare __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Iter_comp_iter<_Compare> __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_equals_val - { - _Value& _M_value; - - - explicit - _Iter_equals_val(_Value& __value) - : _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return *__it == _M_value; } - }; - - template - - inline _Iter_equals_val<_Value> - __iter_equals_val(_Value& __val) - { return _Iter_equals_val<_Value>(__val); } - - template - struct _Iter_equals_iter - { - _Iterator1 _M_it1; - - - explicit - _Iter_equals_iter(_Iterator1 __it1) - : _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return *__it2 == *_M_it1; } - }; - - template - - inline _Iter_equals_iter<_Iterator> - __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) - { return _Iter_equals_iter<_Iterator>(__it); } - - template - struct _Iter_pred - { - _Predicate _M_pred; - - - explicit - _Iter_pred(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_pred<_Predicate> - __pred_iter(_Predicate __pred) - { return _Iter_pred<_Predicate>(std::move(__pred)); } - - template - struct _Iter_comp_to_val - { - _Compare _M_comp; - _Value& _M_value; - - - _Iter_comp_to_val(_Compare __comp, _Value& __value) - : _M_comp(std::move(__comp)), _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_comp(*__it, _M_value)); } - }; - - template - _Iter_comp_to_val<_Compare, _Value> - - __iter_comp_val(_Compare __comp, _Value &__val) - { - return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); - } - - template - struct _Iter_comp_to_iter - { - _Compare _M_comp; - _Iterator1 _M_it1; - - - _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) - : _M_comp(std::move(__comp)), _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return bool(_M_comp(*__it2, *_M_it1)); } - }; - - template - - inline _Iter_comp_to_iter<_Compare, _Iterator> - __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) - { - return _Iter_comp_to_iter<_Compare, _Iterator>( - std::move(__comp._M_comp), __it); - } - - template - struct _Iter_negate - { - _Predicate _M_pred; - - - explicit - _Iter_negate(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return !bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_negate<_Predicate> - __negate(_Iter_pred<_Predicate> __pred) - { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } - -} -} -# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 - template - constexpr _Tp - __rotl(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); - else - return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); - } - - template - constexpr _Tp - __rotr(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); - else - return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); - } - - template - constexpr int - __countl_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - { - constexpr int __diff = _Nd_u - _Nd; - return __builtin_clz(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ul) - { - constexpr int __diff = _Nd_ul - _Nd; - return __builtin_clzl(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ull) - { - constexpr int __diff = _Nd_ull - _Nd; - return __builtin_clzll(__x) - __diff; - } - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - unsigned long long __high = __x >> _Nd_ull; - if (__high != 0) - { - constexpr int __diff = (2 * _Nd_ull) - _Nd; - return __builtin_clzll(__high) - __diff; - } - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - return (_Nd - _Nd_ull) + __builtin_clzll(__low); - } - } - - template - constexpr int - __countl_one(_Tp __x) noexcept - { - return std::__countl_zero<_Tp>((_Tp)~__x); - } - - template - constexpr int - __countr_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_ctz(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_ctzl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_ctzll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - if (__low != 0) - return __builtin_ctzll(__low); - unsigned long long __high = __x >> _Nd_ull; - return __builtin_ctzll(__high) + _Nd_ull; - } - } - - template - constexpr int - __countr_one(_Tp __x) noexcept - { - return std::__countr_zero((_Tp)~__x); - } - - template - constexpr int - __popcount(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_popcount(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_popcountl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_popcountll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - unsigned long long __high = __x >> _Nd_ull; - return __builtin_popcountll(__low) + __builtin_popcountll(__high); - } - } - - template - constexpr bool - __has_single_bit(_Tp __x) noexcept - { return std::__popcount(__x) == 1; } - - template - constexpr _Tp - __bit_ceil(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - if (__x == 0 || __x == 1) - return 1; - auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); - - - - - if (!std::__is_constant_evaluated()) - { - do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); - } - - using __promoted_type = decltype(__x << 1); - if constexpr (!is_same<__promoted_type, _Tp>::value) - { - - - - - - const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; - __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; - } - return (_Tp)1u << __shift_exponent; - } - - template - constexpr _Tp - __bit_floor(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if (__x == 0) - return 0; - return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); - } - - template - constexpr int - __bit_width(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - return _Nd - std::__countl_zero(__x); - } -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -} -# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - template - constexpr - inline int - __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) - { - - static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); -# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); - } -# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) - { -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - swap(*__a, *__b); - - } -# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - _ForwardIterator2 - swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - std::iter_swap(__first1, __first2); - return __first2; - } -# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b) - { - - - - if (__b < __a) - return __b; - return __a; - } -# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b) - { - - - - if (__a < __b) - return __b; - return __a; - } -# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__b, __a)) - return __b; - return __a; - } -# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__a, __b)) - return __b; - return __a; - } - - - - template - - inline _Iterator - __niter_base(_Iterator __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it; } - - template - _Ite - __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, - std::random_access_iterator_tag>&); - - - - - template - - inline _From - __niter_wrap(_From __from, _To __res) - { return __from + (__res - std::__niter_base(__from)); } - - - template - - inline _Iterator - __niter_wrap(const _Iterator&, _Iterator __res) - { return __res; } - - - - - - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = *__first; - return __result; - } - }; - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = std::move(*__first); - return __result; - } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = *__first; - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = *__from; } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = std::move(*__first); - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = std::move(*__from); } - }; - - - template - struct __copy_move<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_m(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result, __first); - return __result + _Num; - } - }; - - - - template - struct _Deque_iterator; - - struct _Bit_iterator; - - - - - - - template - struct char_traits; - - template - class istreambuf_iterator; - - template - class ostreambuf_iterator; - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(_CharT*, _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(const _CharT*, const _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - _CharT*>::__type - __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_move_a2( - istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>); - - - template - - inline _OI - __copy_move_a2(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::iterator_category _Category; - - - - - - return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, - _Category>::__copy_m(__first, __last, __result); - } - - template - _OI - __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_a1(_II __first, _II __last, _OI __result) - { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } - - template - - inline _OI - __copy_move_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_a1<_IsMove>(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); - - template - - _OutputIterator - __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, - bool) - { - if (__n > 0) - { - while (true) - { - *__result = *__first; - ++__result; - if (--__n > 0) - ++__first; - else - break; - } - } - return __result; - } - - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, _CharT*>::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, - _Size, _CharT*, bool); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>, - bool); -# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - copy(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a<__is_move_iterator<_II>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - move(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a(std::__miter_base(__first), - std::__miter_base(__last), __result); - } - - - - - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = *--__last; - return __result; - } - }; - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = *--__last; - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template - struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result - 1, __first); - return __result - _Num; - } - }; - - template - - inline _BI2 - __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) - { - typedef typename iterator_traits<_BI1>::iterator_category _Category; - - - - - - return std::__copy_move_backward<_IsMove, - __memcpyable<_BI2, _BI1>::__value, - _Category>::__copy_move_b(__first, - __last, - __result); - } - - template - - inline _BI2 - __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) - { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } - - template - _OI - __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_backward_a1( - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_backward_a1(_II, _II, - std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_backward_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_backward_a1<_IsMove> - (std::__niter_base(__first), std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_backward_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); -# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - move_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a(std::__miter_base(__first), - std::__miter_base(__last), - __result); - } - - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - for (; __first != __last; ++__first) - *__first = __value; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __first != __last; ++__first) - *__first = __tmp; - } - - - template - - inline typename - __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type - __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) - { - const _Tp __tmp = __c; -# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - if (const size_t __len = __last - __first) - __builtin_memset(__first, static_cast(__tmp), __len); - } - - template - - inline void - __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, - ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, - const _Tp& __value) - { std::__fill_a1(__first.base(), __last.base(), __value); } - - template - void - __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const _VTp&); - - - void - __fill_a1(std::_Bit_iterator, std::_Bit_iterator, - const bool&); - - template - - inline void - __fill_a(_FIte __first, _FIte __last, const _Tp& __value) - { std::__fill_a1(__first, __last, __value); } - - template - void - __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const _Tp&); -# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) - { - - - - ; - - std::__fill_a(__first, __last, __value); - } - - - inline constexpr int - __size_to_integer(int __n) { return __n; } - inline constexpr unsigned - __size_to_integer(unsigned __n) { return __n; } - inline constexpr long - __size_to_integer(long __n) { return __n; } - inline constexpr unsigned long - __size_to_integer(unsigned long __n) { return __n; } - inline constexpr long long - __size_to_integer(long long __n) { return __n; } - inline constexpr unsigned long long - __size_to_integer(unsigned long long __n) { return __n; } -# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - inline constexpr long long - __size_to_integer(float __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(double __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(long double __n) { return (long long)__n; } - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - for (; __n > 0; --__n, (void) ++__first) - *__first = __value; - return __first; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __n > 0; --__n, (void) ++__first) - *__first = __tmp; - return __first; - } - - template - ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, - _Size __n, const _Tp& __value, - std::input_iterator_tag); - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::output_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::input_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::random_access_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - if (__n <= 0) - return __first; - - ; - - std::__fill_a(__first, __first + __n, __value); - return __first + __n; - } -# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - fill_n(_OI __first, _Size __n, const _Tp& __value) - { - - - - return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, - std::__iterator_category(__first)); - } - - template - struct __equal - { - template - - static bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - for (; __first1 != __last1; ++__first1, (void) ++__first2) - if (!(*__first1 == *__first2)) - return false; - return true; - } - }; - - template<> - struct __equal - { - template - - static bool - equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) - { - if (const size_t __len = (__last1 - __first1)) - return !std::__memcmp(__first1, __first2, __len); - return true; - } - }; - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _II); - - template - bool - __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(_II, _II, - std::_Deque_iterator<_Tp, _Ref, _Ptr>); - - template - - inline bool - __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - const bool __simple = ((__is_integer<_ValueType1>::__value - || __is_pointer<_ValueType1>::__value) - && __memcmpable<_II1, _II2>::__value); - return std::__equal<__simple>::equal(__first1, __last1, __first2); - } - - template - - inline bool - __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) - { - return std::__equal_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2)); - } - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - _II2); - - template - bool - __equal_aux(_II1, _II1, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - struct __lc_rai - { - template - - static _II1 - __newlast1(_II1, _II1 __last1, _II2, _II2) - { return __last1; } - - template - - static bool - __cnd2(_II __first, _II __last) - { return __first != __last; } - }; - - template<> - struct __lc_rai - { - template - - static _RAI1 - __newlast1(_RAI1 __first1, _RAI1 __last1, - _RAI2 __first2, _RAI2 __last2) - { - const typename iterator_traits<_RAI1>::difference_type - __diff1 = __last1 - __first1; - const typename iterator_traits<_RAI2>::difference_type - __diff2 = __last2 - __first2; - return __diff2 < __diff1 ? __first1 + __diff2 : __last1; - } - - template - static bool - __cnd2(_RAI, _RAI) - { return true; } - }; - - template - - bool - __lexicographical_compare_impl(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, - _Compare __comp) - { - typedef typename iterator_traits<_II1>::iterator_category _Category1; - typedef typename iterator_traits<_II2>::iterator_category _Category2; - typedef std::__lc_rai<_Category1, _Category2> __rai_type; - - __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); - for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); - ++__first1, (void)++__first2) - { - if (__comp(__first1, __first2)) - return true; - if (__comp(__first2, __first1)) - return false; - } - return __first1 == __last1 && __first2 != __last2; - } - - template - struct __lexicographical_compare - { - template - - static bool - __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using __gnu_cxx::__ops::__iter_less_iter; - return std::__lexicographical_compare_impl(__first1, __last1, - __first2, __last2, - __iter_less_iter()); - } - - template - - static int - __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - while (__first1 != __last1) - { - if (__first2 == __last2) - return +1; - if (*__first1 < *__first2) - return -1; - if (*__first2 < *__first1) - return +1; - ++__first1; - ++__first2; - } - return int(__first2 == __last2) - 1; - } - }; - - template<> - struct __lexicographical_compare - { - template - - static bool - __lc(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { return __3way(__first1, __last1, __first2, __last2) < 0; } - - template - - static ptrdiff_t - __3way(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { - const size_t __len1 = __last1 - __first1; - const size_t __len2 = __last2 - __first2; - if (const size_t __len = std::min(__len1, __len2)) - if (int __result = std::__memcmp(__first1, __first2, __len)) - return __result; - return ptrdiff_t(__len1 - __len2); - } - }; - - template - - inline bool - __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - typedef typename iterator_traits<_II2>::value_type _ValueType2; - const bool __simple = - (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value - && __is_pointer<_II1>::__value - && __is_pointer<_II2>::__value - - - - - - - - ); - - return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, - __first2, __last2); - } - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - _Tp2*, _Tp2*); - - template - bool - __lexicographical_compare_aux1(_Tp1*, _Tp1*, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - - inline bool - __lexicographical_compare_aux(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - return std::__lexicographical_compare_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2), - std::__niter_base(__last2)); - } - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - _II2, _II2); - - template - bool - __lexicographical_compare_aux( - _II1, _II1, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - - _ForwardIterator - __lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val, _Compare __comp) - { - typedef typename iterator_traits<_ForwardIterator>::difference_type - _DistanceType; - - _DistanceType __len = std::distance(__first, __last); - - while (__len > 0) - { - _DistanceType __half = __len >> 1; - _ForwardIterator __middle = __first; - std::advance(__middle, __half); - if (__comp(__middle, __val)) - { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - else - __len = __half; - } - return __first; - } -# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _ForwardIterator - lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val) - { - - - - - ; - - return std::__lower_bound(__first, __last, __val, - __gnu_cxx::__ops::__iter_less_val()); - } - - - - template - inline constexpr _Tp - __lg(_Tp __n) - { - - return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; -# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - } -# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - - - - - - - ; - - return std::__equal_aux(__first1, __last1, __first2); - } -# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return true; - } - - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!(*__first1 == *__first2)) - return false; - return __first1 == __last1 && __first2 == __last2; - } - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, - _BinaryPredicate __binary_pred) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2, - __binary_pred); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return __first1 == __last1 && __first2 == __last2; - } -# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - - - - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2); - } -# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2, - __binary_pred); - } -# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { -# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - ; - ; - - return std::__lexicographical_compare_aux(__first1, __last1, - __first2, __last2); - } -# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, _Compare __comp) - { - - - - ; - ; - - return std::__lexicographical_compare_impl - (__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); - } -# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2) - { - - - - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __first2 != __last2 - && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2) - { - - - - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - - - template - - inline _InputIterator - __find_if(_InputIterator __first, _InputIterator __last, - _Predicate __pred, input_iterator_tag) - { - while (__first != __last && !__pred(__first)) - ++__first; - return __first; - } - - - template - - _RandomAccessIterator - __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Predicate __pred, random_access_iterator_tag) - { - typename iterator_traits<_RandomAccessIterator>::difference_type - __trip_count = (__last - __first) >> 2; - - for (; __trip_count > 0; --__trip_count) - { - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - } - - switch (__last - __first) - { - case 3: - if (__pred(__first)) - return __first; - ++__first; - - case 2: - if (__pred(__first)) - return __first; - ++__first; - - case 1: - if (__pred(__first)) - return __first; - ++__first; - - case 0: - default: - return __last; - } - } - - template - - inline _Iterator - __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) - { - return __find_if(__first, __last, __pred, - std::__iterator_category(__first)); - } - - template - - typename iterator_traits<_InputIterator>::difference_type - __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) - { - typename iterator_traits<_InputIterator>::difference_type __n = 0; - for (; __first != __last; ++__first) - if (__pred(__first)) - ++__n; - return __n; - } - - template - - _ForwardIterator - __remove_if(_ForwardIterator __first, _ForwardIterator __last, - _Predicate __pred) - { - __first = std::__find_if(__first, __last, __pred); - if (__first == __last) - return __first; - _ForwardIterator __result = __first; - ++__first; - for (; __first != __last; ++__first) - if (!__pred(__first)) - { - *__result = std::move(*__first); - ++__result; - } - return __result; - } - - - template - - bool - __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _BinaryPredicate __pred) - { - - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!__pred(__first1, __first2)) - break; - - if (__first1 == __last1) - return true; - - - - _ForwardIterator2 __last2 = __first2; - std::advance(__last2, std::distance(__first1, __last1)); - for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) - { - if (__scan != std::__find_if(__first1, __scan, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) - continue; - - auto __matches - = std::__count_if(__first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); - if (0 == __matches || - std::__count_if(__scan, __last1, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) - != __matches) - return false; - } - return true; - } -# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - - ; - - return std::__is_permutation(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } - - - -} -# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - begin(_Container& __cont) -> decltype(__cont.begin()) - { return __cont.begin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - begin(const _Container& __cont) -> decltype(__cont.begin()) - { return __cont.begin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - end(_Container& __cont) -> decltype(__cont.end()) - { return __cont.end(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - end(const _Container& __cont) -> decltype(__cont.end()) - { return __cont.end(); } - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr _Tp* - begin(_Tp (&__arr)[_Nm]) noexcept - { return __arr; } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr _Tp* - end(_Tp (&__arr)[_Nm]) noexcept - { return __arr + _Nm; } - - - - template class valarray; - - template _Tp* begin(valarray<_Tp>&) noexcept; - template const _Tp* begin(const valarray<_Tp>&) noexcept; - template _Tp* end(valarray<_Tp>&) noexcept; - template const _Tp* end(const valarray<_Tp>&) noexcept; - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - constexpr auto - cbegin(const _Container& __cont) noexcept(noexcept(std::begin(__cont))) - -> decltype(std::begin(__cont)) - { return std::begin(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - constexpr auto - cend(const _Container& __cont) noexcept(noexcept(std::end(__cont))) - -> decltype(std::end(__cont)) - { return std::end(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rbegin(_Container& __cont) -> decltype(__cont.rbegin()) - { return __cont.rbegin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rbegin(const _Container& __cont) -> decltype(__cont.rbegin()) - { return __cont.rbegin(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rend(_Container& __cont) -> decltype(__cont.rend()) - { return __cont.rend(); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - rend(const _Container& __cont) -> decltype(__cont.rend()) - { return __cont.rend(); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Tp*> - rbegin(_Tp (&__arr)[_Nm]) noexcept - { return reverse_iterator<_Tp*>(__arr + _Nm); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Tp*> - rend(_Tp (&__arr)[_Nm]) noexcept - { return reverse_iterator<_Tp*>(__arr); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator - rbegin(initializer_list<_Tp> __il) noexcept - { return reverse_iterator(__il.end()); } - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator - rend(initializer_list<_Tp> __il) noexcept - { return reverse_iterator(__il.begin()); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - crbegin(const _Container& __cont) -> decltype(std::rbegin(__cont)) - { return std::rbegin(__cont); } - - - - - - - template - [[__nodiscard__, __gnu__::__always_inline__]] - inline constexpr auto - crend(const _Container& __cont) -> decltype(std::rend(__cont)) - { return std::rend(__cont); } -# 261 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - size(const _Container& __cont) noexcept(noexcept(__cont.size())) - -> decltype(__cont.size()) - { return __cont.size(); } - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr size_t - size(const _Tp (&)[_Nm]) noexcept - { return _Nm; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - empty(const _Container& __cont) noexcept(noexcept(__cont.empty())) - -> decltype(__cont.empty()) - { return __cont.empty(); } - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr bool - empty(const _Tp (&)[_Nm]) noexcept - { return false; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr bool - empty(initializer_list<_Tp> __il) noexcept - { return __il.size() == 0;} - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - data(_Container& __cont) noexcept(noexcept(__cont.data())) - -> decltype(__cont.data()) - { return __cont.data(); } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr auto - data(const _Container& __cont) noexcept(noexcept(__cont.data())) - -> decltype(__cont.data()) - { return __cont.data(); } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr _Tp* - data(_Tp (&__array)[_Nm]) noexcept - { return __array; } - - - - - - template - [[nodiscard, __gnu__::__always_inline__]] - constexpr const _Tp* - data(initializer_list<_Tp> __il) noexcept - { return __il.begin(); } -# 371 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/range_access.h" 3 -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 2 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - struct __array_traits - { - using _Type = _Tp[_Nm]; - using _Is_swappable = __is_swappable<_Tp>; - using _Is_nothrow_swappable = __is_nothrow_swappable<_Tp>; - }; - - template - struct __array_traits<_Tp, 0> - { - - struct _Type - { - - __attribute__((__always_inline__,__noreturn__)) - _Tp& operator[](size_t) const noexcept { __builtin_trap(); } - - - __attribute__((__always_inline__)) - constexpr explicit operator _Tp*() const noexcept { return nullptr; } - }; - - using _Is_swappable = true_type; - using _Is_nothrow_swappable = true_type; - }; -# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 - template - struct array - { - typedef _Tp value_type; - typedef value_type* pointer; - typedef const value_type* const_pointer; - typedef value_type& reference; - typedef const value_type& const_reference; - typedef value_type* iterator; - typedef const value_type* const_iterator; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - typedef std::reverse_iterator reverse_iterator; - typedef std::reverse_iterator const_reverse_iterator; - - - typename __array_traits<_Tp, _Nm>::_Type _M_elems; - - - - - void - fill(const value_type& __u) - { std::fill_n(begin(), size(), __u); } - - void - swap(array& __other) - noexcept(__array_traits<_Tp, _Nm>::_Is_nothrow_swappable::value) - { std::swap_ranges(begin(), end(), __other.begin()); } - - - [[__gnu__::__const__, __nodiscard__]] - constexpr iterator - begin() noexcept - { return iterator(data()); } - - [[__nodiscard__]] - constexpr const_iterator - begin() const noexcept - { return const_iterator(data()); } - - [[__gnu__::__const__, __nodiscard__]] - constexpr iterator - end() noexcept - { return iterator(data() + _Nm); } - - [[__nodiscard__]] - constexpr const_iterator - end() const noexcept - { return const_iterator(data() + _Nm); } - - [[__gnu__::__const__, __nodiscard__]] - constexpr reverse_iterator - rbegin() noexcept - { return reverse_iterator(end()); } - - [[__nodiscard__]] - constexpr const_reverse_iterator - rbegin() const noexcept - { return const_reverse_iterator(end()); } - - [[__gnu__::__const__, __nodiscard__]] - constexpr reverse_iterator - rend() noexcept - { return reverse_iterator(begin()); } - - [[__nodiscard__]] - constexpr const_reverse_iterator - rend() const noexcept - { return const_reverse_iterator(begin()); } - - [[__nodiscard__]] - constexpr const_iterator - cbegin() const noexcept - { return const_iterator(data()); } - - [[__nodiscard__]] - constexpr const_iterator - cend() const noexcept - { return const_iterator(data() + _Nm); } - - [[__nodiscard__]] - constexpr const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(end()); } - - [[__nodiscard__]] - constexpr const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(begin()); } - - - [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] - constexpr size_type - size() const noexcept { return _Nm; } - - [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] - constexpr size_type - max_size() const noexcept { return _Nm; } - - [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] - constexpr bool - empty() const noexcept { return size() == 0; } - - - [[__nodiscard__]] - constexpr reference - operator[](size_type __n) noexcept - { - ; - return _M_elems[__n]; - } - - [[__nodiscard__]] - constexpr const_reference - operator[](size_type __n) const noexcept - { - - ; - - return _M_elems[__n]; - } - - constexpr reference - at(size_type __n) - { - if (__n >= _Nm) - std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), - - __n, _Nm); - return _M_elems[__n]; - } - - constexpr const_reference - at(size_type __n) const - { - - - return __n < _Nm ? _M_elems[__n] - : (std::__throw_out_of_range_fmt(("array::at: __n (which is %zu) " ">= _Nm (which is %zu)"), - - __n, _Nm), - _M_elems[__n]); - } - - [[__nodiscard__]] - constexpr reference - front() noexcept - { - ; - return _M_elems[(size_type)0]; - } - - [[__nodiscard__]] - constexpr const_reference - front() const noexcept - { - - ; - - return _M_elems[(size_type)0]; - } - - [[__nodiscard__]] - constexpr reference - back() noexcept - { - ; - return _M_elems[_Nm - 1]; - } - - [[__nodiscard__]] - constexpr const_reference - back() const noexcept - { - - ; - - return _M_elems[_Nm - 1]; - } - - [[__nodiscard__, __gnu__::__const__, __gnu__::__always_inline__]] - constexpr pointer - data() noexcept - { return static_cast(_M_elems); } - - [[__nodiscard__]] - constexpr const_pointer - data() const noexcept - { return static_cast(_M_elems); } - }; - - - template - array(_Tp, _Up...) - -> array && ...), _Tp>, - 1 + sizeof...(_Up)>; - - - - template - [[__nodiscard__]] - - inline bool - operator==(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return std::equal(__one.begin(), __one.end(), __two.begin()); } -# 322 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 - template - [[__nodiscard__]] - - inline bool - operator!=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return !(__one == __two); } - - template - [[__nodiscard__]] - - inline bool - operator<(const array<_Tp, _Nm>& __a, const array<_Tp, _Nm>& __b) - { - return std::lexicographical_compare(__a.begin(), __a.end(), - __b.begin(), __b.end()); - } - - template - [[__nodiscard__]] - - inline bool - operator>(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return __two < __one; } - - template - [[__nodiscard__]] - - inline bool - operator<=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return !(__one > __two); } - - template - [[__nodiscard__]] - - inline bool - operator>=(const array<_Tp, _Nm>& __one, const array<_Tp, _Nm>& __two) - { return !(__one < __two); } - - - - template - - inline - - - __enable_if_t<__array_traits<_Tp, _Nm>::_Is_swappable::value> - - - - swap(array<_Tp, _Nm>& __one, array<_Tp, _Nm>& __two) - noexcept(noexcept(__one.swap(__two))) - { __one.swap(__two); } - - - template - __enable_if_t::_Is_swappable::value> - swap(array<_Tp, _Nm>&, array<_Tp, _Nm>&) = delete; - - - template - [[__nodiscard__]] - constexpr _Tp& - get(array<_Tp, _Nm>& __arr) noexcept - { - static_assert(_Int < _Nm, "array index is within bounds"); - return __arr._M_elems[_Int]; - } - - template - [[__nodiscard__]] - constexpr _Tp&& - get(array<_Tp, _Nm>&& __arr) noexcept - { - static_assert(_Int < _Nm, "array index is within bounds"); - return std::move(std::get<_Int>(__arr)); - } - - template - [[__nodiscard__]] - constexpr const _Tp& - get(const array<_Tp, _Nm>& __arr) noexcept - { - static_assert(_Int < _Nm, "array index is within bounds"); - return __arr._M_elems[_Int]; - } - - template - [[__nodiscard__]] - constexpr const _Tp&& - get(const array<_Tp, _Nm>&& __arr) noexcept - { - static_assert(_Int < _Nm, "array index is within bounds"); - return std::move(std::get<_Int>(__arr)); - } -# 460 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/array" 3 - template - struct tuple_size> - : public integral_constant { }; - - - template - struct tuple_element<_Ind, array<_Tp, _Nm>> - { - static_assert(_Ind < _Nm, "array index is in range"); - using type = _Tp; - }; - - - template - inline constexpr size_t tuple_size_v> = _Nm; - - template - inline constexpr size_t tuple_size_v> = _Nm; - - - template - struct __is_tuple_like_impl> : true_type - { }; - - -} -# 18 "src/renderer/descriptors/vk_descriptor_set.h" 2 - - -namespace mlx -{ - class DescriptorSet - { - public: - void init(class Renderer* renderer, class DescriptorPool* pool, class DescriptorSetLayout* layout); - - void writeDescriptor(int binding, class UBO* ubo) noexcept; - void writeDescriptor(int binding, VkImageView view, VkSampler sampler) noexcept; - - inline bool isInit() noexcept { return _pool != nullptr && _renderer != nullptr; } - - DescriptorSet duplicate(); - - VkDescriptorSet& operator()() noexcept; - VkDescriptorSet& get() noexcept; - - private: - std::array _desc_set; - class DescriptorPool* _pool = nullptr; - class DescriptorSetLayout* _layout = nullptr; - class Renderer* _renderer = nullptr; - }; -} -# 14 "src/renderer/descriptors/vk_descriptor_set.cpp" 2 -# 1 "src/renderer/descriptors/vk_descriptor_pool.h" 1 -# 16 "src/renderer/descriptors/vk_descriptor_pool.h" -# 1 "third_party/volk.h" 1 -# 17 "src/renderer/descriptors/vk_descriptor_pool.h" 2 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 1 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 - - - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 -# 51 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 2 3 - -extern "C++" -{ - -namespace std -{ - - using ::max_align_t; -} - - - -namespace std -{ - - - - - enum class byte : unsigned char {}; - - template struct __byte_operand { }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - - - - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; - template<> struct __byte_operand { using __type = byte; }; -# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstddef" 3 - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - template - struct __byte_operand - : __byte_operand<_IntegerType> { }; - - template - using __byte_op_t = typename __byte_operand<_IntegerType>::__type; - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType> - operator<<(byte __b, _IntegerType __shift) noexcept - { return (byte)(unsigned char)((unsigned)__b << __shift); } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType> - operator>>(byte __b, _IntegerType __shift) noexcept - { return (byte)(unsigned char)((unsigned)__b >> __shift); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator|(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l | (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator&(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l & (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator^(byte __l, byte __r) noexcept - { return (byte)(unsigned char)((unsigned)__l ^ (unsigned)__r); } - - [[__gnu__::__always_inline__]] - constexpr byte - operator~(byte __b) noexcept - { return (byte)(unsigned char)~(unsigned)__b; } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType>& - operator<<=(byte& __b, _IntegerType __shift) noexcept - { return __b = __b << __shift; } - - template - [[__gnu__::__always_inline__]] - constexpr __byte_op_t<_IntegerType>& - operator>>=(byte& __b, _IntegerType __shift) noexcept - { return __b = __b >> __shift; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator|=(byte& __l, byte __r) noexcept - { return __l = __l | __r; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator&=(byte& __l, byte __r) noexcept - { return __l = __l & __r; } - - [[__gnu__::__always_inline__]] - constexpr byte& - operator^=(byte& __l, byte __r) noexcept - { return __l = __l ^ __r; } - - template - [[nodiscard,__gnu__::__always_inline__]] - constexpr _IntegerType - to_integer(__byte_op_t<_IntegerType> __b) noexcept - { return _IntegerType(__b); } - - -} - -} -# 18 "src/renderer/descriptors/vk_descriptor_pool.h" 2 - -namespace mlx -{ - class DescriptorPool - { - public: - void init(std::size_t n, VkDescriptorPoolSize* size); - void destroy() noexcept; - - inline VkDescriptorPool& operator()() noexcept { return _pool; } - inline VkDescriptorPool& get() noexcept { return _pool; } - - private: - VkDescriptorPool _pool = nullptr; - }; -} -# 15 "src/renderer/descriptors/vk_descriptor_set.cpp" 2 -# 1 "src/renderer/descriptors/vk_descriptor_set_layout.h" 1 -# 16 "src/renderer/descriptors/vk_descriptor_set_layout.h" -# 1 "third_party/volk.h" 1 -# 17 "src/renderer/descriptors/vk_descriptor_set_layout.h" 2 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 1 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 1 3 -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 1 3 -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 - - - -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception.h" 3 - class exception - { - public: - exception() noexcept { } - virtual ~exception() noexcept; - - exception(const exception&) = default; - exception& operator=(const exception&) = default; - exception(exception&&) = default; - exception& operator=(exception&&) = default; - - - - - virtual const char* - what() const noexcept; - }; - - - -} - -} -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 2 3 - -#pragma GCC visibility push(default) - -extern "C++" { - -namespace std -{ - - - - - - - class bad_alloc : public exception - { - public: - bad_alloc() throw() { } - - - bad_alloc(const bad_alloc&) = default; - bad_alloc& operator=(const bad_alloc&) = default; - - - - - virtual ~bad_alloc() throw(); - - - virtual const char* what() const throw(); - }; - - - class bad_array_new_length : public bad_alloc - { - public: - bad_array_new_length() throw() { } - - - - virtual ~bad_array_new_length() throw(); - - - virtual const char* what() const throw(); - }; - - - - enum class align_val_t: size_t {}; - - - struct nothrow_t - { - - explicit nothrow_t() = default; - - }; - - extern const nothrow_t nothrow; - - - - typedef void (*new_handler)(); - - - - new_handler set_new_handler(new_handler) throw(); - - - - new_handler get_new_handler() noexcept; - -} -# 126 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -[[__nodiscard__]] void* operator new(std::size_t) - __attribute__((__externally_visible__)); -[[__nodiscard__]] void* operator new[](std::size_t) - __attribute__((__externally_visible__)); -void operator delete(void*) noexcept - __attribute__((__externally_visible__)); -void operator delete[](void*) noexcept - __attribute__((__externally_visible__)); - - - - - - -[[__nodiscard__]] void* operator new(std::size_t, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new[](std::size_t, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete(void*, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__)); -void operator delete[](void*, const std::nothrow_t&) noexcept - __attribute__((__externally_visible__)); - -[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t) - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new(std::size_t, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete(void*, std::align_val_t) - noexcept __attribute__((__externally_visible__)); -void operator delete(void*, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__)); -[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t) - __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -[[__nodiscard__]] void* operator new[](std::size_t, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__, __alloc_size__ (1), __malloc__)); -void operator delete[](void*, std::align_val_t) - noexcept __attribute__((__externally_visible__)); -void operator delete[](void*, std::align_val_t, const std::nothrow_t&) - noexcept __attribute__((__externally_visible__)); -# 174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -[[__nodiscard__]] inline void* operator new(std::size_t, void* __p) noexcept -{ return __p; } -[[__nodiscard__]] inline void* operator new[](std::size_t, void* __p) noexcept -{ return __p; } - - -inline void operator delete (void*, void*) noexcept { } -inline void operator delete[](void*, void*) noexcept { } - -} - - -namespace std -{ - - - - template - [[nodiscard]] constexpr _Tp* - launder(_Tp* __p) noexcept - { return __builtin_launder(__p); } - - - - - template - void launder(_Ret (*)(_Args...) noexcept (_NE)) = delete; - template - void launder(_Ret (*)(_Args......) noexcept (_NE)) = delete; - - void launder(void*) = delete; - void launder(const void*) = delete; - void launder(volatile void*) = delete; - void launder(const volatile void*) = delete; - - - - - - - -} -# 236 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/new" 3 -#pragma GCC visibility pop -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - template - class __new_allocator - { - public: - typedef _Tp value_type; - typedef std::size_t size_type; - typedef std::ptrdiff_t difference_type; - - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - - template - struct rebind - { typedef __new_allocator<_Tp1> other; }; - - - - - - typedef std::true_type propagate_on_container_move_assignment; - - - __attribute__((__always_inline__)) - - __new_allocator() noexcept { } - - __attribute__((__always_inline__)) - - __new_allocator(const __new_allocator&) noexcept { } - - template - __attribute__((__always_inline__)) - - __new_allocator(const __new_allocator<_Tp1>&) noexcept { } - - - ~__new_allocator() noexcept { } - - pointer - address(reference __x) const noexcept - { return std::__addressof(__x); } - - const_pointer - address(const_reference __x) const noexcept - { return std::__addressof(__x); } -# 121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - [[__nodiscard__]] _Tp* - allocate(size_type __n, const void* = static_cast(0)) - { - - - - static_assert(sizeof(_Tp) != 0, "cannot allocate incomplete types"); - - - if (__builtin_expect(__n > this->_M_max_size(), false)) - { - - - if (__n > (std::size_t(-1) / sizeof(_Tp))) - std::__throw_bad_array_new_length(); - std::__throw_bad_alloc(); - } - - - if (alignof(_Tp) > 16UL) - { - std::align_val_t __al = std::align_val_t(alignof(_Tp)); - return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp), - __al)); - } - - return static_cast<_Tp*>(__builtin_operator_new(__n * sizeof(_Tp))); - } - - - void - deallocate(_Tp* __p, size_type __n __attribute__ ((__unused__))) - { - - - - - - - - if (alignof(_Tp) > 16UL) - { - __builtin_operator_delete((__p), - std::align_val_t(alignof(_Tp))); - return; - } - - __builtin_operator_delete((__p)); - } - - - - - - - __attribute__((__always_inline__)) - size_type - max_size() const noexcept - { return _M_max_size(); } - - - template - __attribute__((__always_inline__)) - void - construct(_Up* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); } - - template - __attribute__((__always_inline__)) - void - destroy(_Up* __p) - noexcept(std::is_nothrow_destructible<_Up>::value) - { __p->~_Up(); } -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/new_allocator.h" 3 - template - friend __attribute__((__always_inline__)) bool - operator==(const __new_allocator&, const __new_allocator<_Up>&) - noexcept - { return true; } - - - template - friend __attribute__((__always_inline__)) bool - operator!=(const __new_allocator&, const __new_allocator<_Up>&) - noexcept - { return false; } - - - private: - __attribute__((__always_inline__)) - constexpr size_type - _M_max_size() const noexcept - { - - return std::size_t(9223372036854775807L) / sizeof(_Tp); - - - - } - }; - - -} -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 2 3 - - -namespace std -{ -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++allocator.h" 3 - template - using __allocator_base = __new_allocator<_Tp>; -} -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 1 3 -# 47 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memoryfwd.h" 3 - template - class allocator; - - template<> - class allocator; - - - - - template - struct uses_allocator; - - template - struct allocator_traits; - - - - - -} -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - template<> - class allocator - { - public: - typedef void value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - - - typedef void* pointer; - typedef const void* const_pointer; - - template - struct rebind - { typedef allocator<_Tp1> other; }; - - - - - - using propagate_on_container_move_assignment = true_type; - - using is_always_equal - - = true_type; -# 117 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - }; -# 129 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - template - class allocator : public __allocator_base<_Tp> - { - public: - typedef _Tp value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - - - - typedef _Tp* pointer; - typedef const _Tp* const_pointer; - typedef _Tp& reference; - typedef const _Tp& const_reference; - - template - struct rebind - { typedef allocator<_Tp1> other; }; - - - - - - using propagate_on_container_move_assignment = true_type; - - using is_always_equal - - = true_type; - - - - - __attribute__((__always_inline__)) - - allocator() noexcept { } - - __attribute__((__always_inline__)) - - allocator(const allocator& __a) noexcept - : __allocator_base<_Tp>(__a) { } - - - - allocator& operator=(const allocator&) = default; - - - template - __attribute__((__always_inline__)) - - allocator(const allocator<_Tp1>&) noexcept { } - - __attribute__((__always_inline__)) - - - - ~allocator() noexcept { } -# 214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/allocator.h" 3 - friend __attribute__((__always_inline__)) - bool - operator==(const allocator&, const allocator&) noexcept - { return true; } - - - friend __attribute__((__always_inline__)) - bool - operator!=(const allocator&, const allocator&) noexcept - { return false; } - - - - }; - - - - - - - template - __attribute__((__always_inline__)) - inline bool - operator==(const allocator<_T1>&, const allocator<_T2>&) - noexcept - { return true; } - - - template - __attribute__((__always_inline__)) - inline bool - operator!=(const allocator<_T1>&, const allocator<_T2>&) - noexcept - { return false; } - - - - - - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - template - class allocator - { - public: - typedef _Tp value_type; - template allocator(const allocator<_Up>&) { } - }; - - - - - - - - extern template class allocator; - extern template class allocator; - - - - - - -} -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 1 3 -# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - inline void - destroy_at(_Tp* __location) - { - if constexpr (201703L > 201703L && is_array_v<_Tp>) - { - for (auto& __x : *__location) - std::destroy_at(std::__addressof(__x)); - } - else - __location->~_Tp(); - } -# 106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - template - - inline void - _Construct(_Tp* __p, _Args&&... __args) - { -# 119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); - } -# 132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_construct.h" 3 - template - inline void - _Construct_novalue(_T1* __p) - { ::new((void*)__p) _T1; } - - template - void - _Destroy(_ForwardIterator __first, _ForwardIterator __last); - - - - - template - constexpr inline void - _Destroy(_Tp* __pointer) - { - - - - __pointer->~_Tp(); - - } - - template - struct _Destroy_aux - { - template - static void - __destroy(_ForwardIterator __first, _ForwardIterator __last) - { - for (; __first != __last; ++__first) - std::_Destroy(std::__addressof(*__first)); - } - }; - - template<> - struct _Destroy_aux - { - template - static void - __destroy(_ForwardIterator, _ForwardIterator) { } - }; - - - - - - - template - inline void - _Destroy(_ForwardIterator __first, _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _Value_type; - - - static_assert(is_destructible<_Value_type>::value, - "value type is destructible"); - - - - - - std::_Destroy_aux<__has_trivial_destructor(_Value_type)>:: - __destroy(__first, __last); - } - - template - struct _Destroy_n_aux - { - template - static _ForwardIterator - __destroy_n(_ForwardIterator __first, _Size __count) - { - for (; __count > 0; (void)++__first, --__count) - std::_Destroy(std::__addressof(*__first)); - return __first; - } - }; - - template<> - struct _Destroy_n_aux - { - template - static _ForwardIterator - __destroy_n(_ForwardIterator __first, _Size __count) - { - std::advance(__first, __count); - return __first; - } - }; - - - - - - - template - inline _ForwardIterator - _Destroy_n(_ForwardIterator __first, _Size __count) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _Value_type; - - - static_assert(is_destructible<_Value_type>::value, - "value type is destructible"); - - - - - - return std::_Destroy_n_aux<__has_trivial_destructor(_Value_type)>:: - __destroy_n(__first, __count); - } - - - template - inline void - destroy(_ForwardIterator __first, _ForwardIterator __last) - { - std::_Destroy(__first, __last); - } - - template - inline _ForwardIterator - destroy_n(_ForwardIterator __first, _Size __count) - { - return std::_Destroy_n(__first, __count); - } - - - -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 1 3 -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 1 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - struct __allocator_traits_base - { - template - struct __rebind : __replace_first_arg<_Tp, _Up> - { - static_assert(is_same< - typename __replace_first_arg<_Tp, typename _Tp::value_type>::type, - _Tp>::value, - "allocator_traits::rebind_alloc must be A"); - }; - - template - struct __rebind<_Tp, _Up, - __void_t::other>> - { - using type = typename _Tp::template rebind<_Up>::other; - - static_assert(is_same< - typename _Tp::template rebind::other, - _Tp>::value, - "allocator_traits::rebind_alloc must be A"); - }; - - protected: - template - using __pointer = typename _Tp::pointer; - template - using __c_pointer = typename _Tp::const_pointer; - template - using __v_pointer = typename _Tp::void_pointer; - template - using __cv_pointer = typename _Tp::const_void_pointer; - template - using __pocca = typename _Tp::propagate_on_container_copy_assignment; - template - using __pocma = typename _Tp::propagate_on_container_move_assignment; - template - using __pocs = typename _Tp::propagate_on_container_swap; - template - using __equal = __type_identity; - }; - - template - using __alloc_rebind - = typename __allocator_traits_base::template __rebind<_Alloc, _Up>::type; -# 104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct allocator_traits : __allocator_traits_base - { - - typedef _Alloc allocator_type; - - typedef typename _Alloc::value_type value_type; - - - - - - - using pointer = __detected_or_t; - - private: - - template class _Func, typename _Tp, typename = void> - struct _Ptr - { - using type = typename pointer_traits::template rebind<_Tp>; - }; - - template class _Func, typename _Tp> - struct _Ptr<_Func, _Tp, __void_t<_Func<_Alloc>>> - { - using type = _Func<_Alloc>; - }; - - - template - struct _Diff - { using type = typename pointer_traits<_PtrT>::difference_type; }; - - template - struct _Diff<_A2, _PtrT, __void_t> - { using type = typename _A2::difference_type; }; - - - template - struct _Size : make_unsigned<_DiffT> { }; - - template - struct _Size<_A2, _DiffT, __void_t> - { using type = typename _A2::size_type; }; - - public: - - - - - - - using const_pointer = typename _Ptr<__c_pointer, const value_type>::type; - - - - - - - - using void_pointer = typename _Ptr<__v_pointer, void>::type; - - - - - - - - using const_void_pointer = typename _Ptr<__cv_pointer, const void>::type; - - - - - - - - using difference_type = typename _Diff<_Alloc, pointer>::type; - - - - - - - - using size_type = typename _Size<_Alloc, difference_type>::type; - - - - - - - - using propagate_on_container_copy_assignment - = __detected_or_t; - - - - - - - - using propagate_on_container_move_assignment - = __detected_or_t; - - - - - - - - using propagate_on_container_swap - = __detected_or_t; - - - - - - - - using is_always_equal - = typename __detected_or_t, __equal, _Alloc>::type; - - template - using rebind_alloc = __alloc_rebind<_Alloc, _Tp>; - template - using rebind_traits = allocator_traits>; - - private: - template - static constexpr auto - _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer __hint, int) - -> decltype(__a.allocate(__n, __hint)) - { return __a.allocate(__n, __hint); } - - template - static constexpr pointer - _S_allocate(_Alloc2& __a, size_type __n, const_void_pointer, ...) - { return __a.allocate(__n); } - - template - struct __construct_helper - { - template()->construct( - std::declval<_Tp*>(), std::declval<_Args>()...))> - static true_type __test(int); - - template - static false_type __test(...); - - using type = decltype(__test<_Alloc>(0)); - }; - - template - using __has_construct - = typename __construct_helper<_Tp, _Args...>::type; - - template - static constexpr _Require<__has_construct<_Tp, _Args...>> - _S_construct(_Alloc& __a, _Tp* __p, _Args&&... __args) - noexcept(noexcept(__a.construct(__p, std::forward<_Args>(__args)...))) - { __a.construct(__p, std::forward<_Args>(__args)...); } - - template - static constexpr - _Require<__and_<__not_<__has_construct<_Tp, _Args...>>, - is_constructible<_Tp, _Args...>>> - _S_construct(_Alloc&, _Tp* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Tp, _Args...>::value) - { - - ::new((void*)__p) _Tp(std::forward<_Args>(__args)...); - - - - } - - template - static constexpr auto - _S_destroy(_Alloc2& __a, _Tp* __p, int) - noexcept(noexcept(__a.destroy(__p))) - -> decltype(__a.destroy(__p)) - { __a.destroy(__p); } - - template - static constexpr void - _S_destroy(_Alloc2&, _Tp* __p, ...) - noexcept(std::is_nothrow_destructible<_Tp>::value) - { std::_Destroy(__p); } - - template - static constexpr auto - _S_max_size(_Alloc2& __a, int) - -> decltype(__a.max_size()) - { return __a.max_size(); } - - template - static constexpr size_type - _S_max_size(_Alloc2&, ...) - { - - - return __gnu_cxx::__numeric_traits::__max - / sizeof(value_type); - } - - template - static constexpr auto - _S_select(_Alloc2& __a, int) - -> decltype(__a.select_on_container_copy_construction()) - { return __a.select_on_container_copy_construction(); } - - template - static constexpr _Alloc2 - _S_select(_Alloc2& __a, ...) - { return __a; } - - public: -# 331 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__]] static pointer - allocate(_Alloc& __a, size_type __n) - { return __a.allocate(__n); } -# 346 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__]] static pointer - allocate(_Alloc& __a, size_type __n, const_void_pointer __hint) - { return _S_allocate(__a, __n, __hint, 0); } -# 358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static void - deallocate(_Alloc& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 373 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - static auto - construct(_Alloc& __a, _Tp* __p, _Args&&... __args) - noexcept(noexcept(_S_construct(__a, __p, - std::forward<_Args>(__args)...))) - -> decltype(_S_construct(__a, __p, std::forward<_Args>(__args)...)) - { _S_construct(__a, __p, std::forward<_Args>(__args)...); } -# 389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - static void - destroy(_Alloc& __a, _Tp* __p) - noexcept(noexcept(_S_destroy(__a, __p, 0))) - { _S_destroy(__a, __p, 0); } -# 403 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static size_type - max_size(const _Alloc& __a) noexcept - { return _S_max_size(__a, 0); } -# 415 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - static _Alloc - select_on_container_copy_construction(const _Alloc& __rhs) - { return _S_select(__rhs, 0); } - }; -# 427 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct allocator_traits> - { - - using allocator_type = allocator<_Tp>; - - - using value_type = _Tp; - - - using pointer = _Tp*; - - - using const_pointer = const _Tp*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - using propagate_on_container_copy_assignment = false_type; - - - using propagate_on_container_move_assignment = true_type; - - - using propagate_on_container_swap = false_type; - - - using is_always_equal = true_type; - - template - using rebind_alloc = allocator<_Up>; - - template - using rebind_traits = allocator_traits>; -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__,__gnu__::__always_inline__]] - static pointer - allocate(allocator_type& __a, size_type __n) - { return __a.allocate(__n); } -# 494 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__nodiscard__,__gnu__::__always_inline__]] - static pointer - allocate(allocator_type& __a, size_type __n, const_void_pointer __hint) - { - - return __a.allocate(__n, __hint); - - - - } -# 513 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - [[__gnu__::__always_inline__]] - static void - deallocate(allocator_type& __a, pointer __p, size_type __n) - { __a.deallocate(__p, __n); } -# 529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - construct(allocator_type& __a __attribute__((__unused__)), _Up* __p, - _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { - - __a.construct(__p, std::forward<_Args>(__args)...); - - - - } -# 550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { - - __a.destroy(__p); - - - - } - - - - - - - [[__gnu__::__always_inline__]] - static size_type - max_size(const allocator_type& __a __attribute__((__unused__))) noexcept - { - - return __a.max_size(); - - - - } - - - - - - - [[__gnu__::__always_inline__]] - static allocator_type - select_on_container_copy_construction(const allocator_type& __rhs) - { return __rhs; } - }; - - - template<> - struct allocator_traits> - { - - using allocator_type = allocator; - - - using value_type = void; - - - using pointer = void*; - - - using const_pointer = const void*; - - - using void_pointer = void*; - - - using const_void_pointer = const void*; - - - using difference_type = std::ptrdiff_t; - - - using size_type = std::size_t; - - - using propagate_on_container_copy_assignment = false_type; - - - using propagate_on_container_move_assignment = true_type; - - - using propagate_on_container_swap = false_type; - - - using is_always_equal = true_type; - - template - using rebind_alloc = allocator<_Up>; - - template - using rebind_traits = allocator_traits>; - - - static void* - allocate(allocator_type&, size_type, const void* = nullptr) = delete; - - - static void - deallocate(allocator_type&, void*, size_type) = delete; -# 655 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - construct(allocator_type&, _Up* __p, _Args&&... __args) - noexcept(std::is_nothrow_constructible<_Up, _Args...>::value) - { std::_Construct(__p, std::forward<_Args>(__args)...); } -# 669 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - static void - destroy(allocator_type&, _Up* __p) - noexcept(is_nothrow_destructible<_Up>::value) - { std::_Destroy(__p); } - - - static size_type - max_size(const allocator_type&) = delete; - - - - - - - [[__gnu__::__always_inline__]] - static allocator_type - select_on_container_copy_construction(const allocator_type& __rhs) - { return __rhs; } - }; -# 707 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_copy(_Alloc& __one, const _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocca = - typename __traits::propagate_on_container_copy_assignment::type; - - if constexpr (__pocca::value) - __one = __two; - - - - } - - template - [[__gnu__::__always_inline__]] - constexpr _Alloc - __alloc_on_copy(const _Alloc& __a) - { - typedef allocator_traits<_Alloc> __traits; - return __traits::select_on_container_copy_construction(__a); - } -# 744 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_move(_Alloc& __one, _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocma - = typename __traits::propagate_on_container_move_assignment::type; - - if constexpr (__pocma::value) - __one = std::move(__two); - - - - } -# 775 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - [[__gnu__::__always_inline__]] - constexpr inline void - __alloc_on_swap(_Alloc& __one, _Alloc& __two) - { - using __traits = allocator_traits<_Alloc>; - using __pocs = typename __traits::propagate_on_container_swap::type; - - if constexpr (__pocs::value) - { - using std::swap; - swap(__one, __two); - } - - - - } - - template, - typename = void> - struct __is_alloc_insertable_impl - : false_type - { }; - - template - struct __is_alloc_insertable_impl<_Alloc, _Tp, _ValueT, - __void_t::construct( - std::declval<_Alloc&>(), std::declval<_ValueT*>(), - std::declval<_Tp>()))>> - : true_type - { }; - - - - - template - struct __is_copy_insertable - : __is_alloc_insertable_impl<_Alloc, - typename _Alloc::value_type const&>::type - { }; - - - - template - struct __is_copy_insertable> - : is_copy_constructible<_Tp> - { }; - - - - - - template - struct __is_move_insertable - : __is_alloc_insertable_impl<_Alloc, typename _Alloc::value_type>::type - { }; - - - - template - struct __is_move_insertable> - : is_move_constructible<_Tp> - { }; - - - - template - struct __is_allocator : false_type { }; - - template - struct __is_allocator<_Alloc, - __void_t().allocate(size_t{}))>> - : true_type { }; - - template - using _RequireAllocator - = typename enable_if<__is_allocator<_Alloc>::value, _Alloc>::type; - - template - using _RequireNotAllocator - = typename enable_if::value, _Alloc>::type; -# 872 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - struct __alloc_swap - { static void _S_do_it(_Alloc&, _Alloc&) noexcept { } }; - - template - struct __alloc_swap<_Alloc, false> - { - static void - _S_do_it(_Alloc& __one, _Alloc& __two) noexcept - { - - if (__one != __two) - swap(__one, __two); - } - }; - - - template, - is_nothrow_move_constructible>::value> - struct __shrink_to_fit_aux - { static bool _S_do_it(_Tp&) noexcept { return false; } }; - - template - struct __shrink_to_fit_aux<_Tp, true> - { - - static bool - _S_do_it(_Tp& __c) noexcept - { - - try - { - _Tp(__make_move_if_noexcept_iterator(__c.begin()), - __make_move_if_noexcept_iterator(__c.end()), - __c.get_allocator()).swap(__c); - return true; - } - catch(...) - { return false; } - - - - } - }; -# 925 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/alloc_traits.h" 3 - template - - void - _Destroy(_ForwardIterator __first, _ForwardIterator __last, - _Allocator& __alloc) - { - for (; __first != __last; ++__first) - - - - allocator_traits<_Allocator>::destroy(__alloc, - std::__addressof(*__first)); - - } - - - template - __attribute__((__always_inline__)) - inline void - _Destroy(_ForwardIterator __first, _ForwardIterator __last, - allocator<_Tp>&) - { - std::_Destroy(__first, __last); - } - - - - -} -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 2 3 - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - - - -template - struct __alloc_traits - - : std::allocator_traits<_Alloc> - - { - typedef _Alloc allocator_type; - - typedef std::allocator_traits<_Alloc> _Base_type; - typedef typename _Base_type::value_type value_type; - typedef typename _Base_type::pointer pointer; - typedef typename _Base_type::const_pointer const_pointer; - typedef typename _Base_type::size_type size_type; - typedef typename _Base_type::difference_type difference_type; - - typedef value_type& reference; - typedef const value_type& const_reference; - using _Base_type::allocate; - using _Base_type::deallocate; - using _Base_type::construct; - using _Base_type::destroy; - using _Base_type::max_size; - - private: - template - using __is_custom_pointer - = std::__and_, - std::__not_>>; - - public: - - template - [[__gnu__::__always_inline__]] - static constexpr - std::__enable_if_t<__is_custom_pointer<_Ptr>::value> - construct(_Alloc& __a, _Ptr __p, _Args&&... __args) - noexcept(noexcept(_Base_type::construct(__a, std::__to_address(__p), - std::forward<_Args>(__args)...))) - { - _Base_type::construct(__a, std::__to_address(__p), - std::forward<_Args>(__args)...); - } - - - template - [[__gnu__::__always_inline__]] - static constexpr - std::__enable_if_t<__is_custom_pointer<_Ptr>::value> - destroy(_Alloc& __a, _Ptr __p) - noexcept(noexcept(_Base_type::destroy(__a, std::__to_address(__p)))) - { _Base_type::destroy(__a, std::__to_address(__p)); } - - [[__gnu__::__always_inline__]] - static constexpr _Alloc _S_select_on_copy(const _Alloc& __a) - { return _Base_type::select_on_container_copy_construction(__a); } - - [[__gnu__::__always_inline__]] - static constexpr void _S_on_swap(_Alloc& __a, _Alloc& __b) - { std::__alloc_on_swap(__a, __b); } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_copy_assign() - { return _Base_type::propagate_on_container_copy_assignment::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_move_assign() - { return _Base_type::propagate_on_container_move_assignment::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_propagate_on_swap() - { return _Base_type::propagate_on_container_swap::value; } - - [[__gnu__::__always_inline__]] - static constexpr bool _S_always_equal() - { return _Base_type::is_always_equal::value; } - - __attribute__((__always_inline__)) - static constexpr bool _S_nothrow_move() - { return _S_propagate_on_move_assign() || _S_always_equal(); } - - template - struct rebind - { typedef typename _Base_type::template rebind_alloc<_Tp> other; }; -# 180 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/alloc_traits.h" 3 - }; - - -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 2 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 81 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - constexpr bool - __check_constructible() - { - - - - - - static_assert(is_constructible<_ValueType, _Tp>::value, - "result type must be constructible from input type"); - - return true; - } -# 110 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - - _ForwardIterator - __do_uninit_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { - _ForwardIterator __cur = __result; - try - { - for (; __first != __last; ++__first, (void)++__cur) - std::_Construct(std::__addressof(*__cur), *__first); - return __cur; - } - catch(...) - { - std::_Destroy(__result, __cur); - throw; - } - } - - template - struct __uninitialized_copy - { - template - static _ForwardIterator - __uninit_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { return std::__do_uninit_copy(__first, __last, __result); } - }; - - template<> - struct __uninitialized_copy - { - template - static _ForwardIterator - __uninit_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { return std::copy(__first, __last, __result); } - }; -# 161 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_copy(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { - typedef typename iterator_traits<_InputIterator>::value_type - _ValueType1; - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType2; - - - - - const bool __can_memmove = __is_trivial(_ValueType1); - - - - - using _From = decltype(*__first); - - const bool __assignable - = __is_trivial(_ValueType2) && __is_assignable(_ValueType2&, _From) && std::__check_constructible<_ValueType2, _From>(); - - return std::__uninitialized_copy<__can_memmove && __assignable>:: - __uninit_copy(__first, __last, __result); - } - - - - template - void - __do_uninit_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { - _ForwardIterator __cur = __first; - try - { - for (; __cur != __last; ++__cur) - std::_Construct(std::__addressof(*__cur), __x); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - - template - struct __uninitialized_fill - { - template - static void - __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { std::__do_uninit_fill(__first, __last, __x); } - }; - - template<> - struct __uninitialized_fill - { - template - static void - __uninit_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { std::fill(__first, __last, __x); } - }; -# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline void - uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - - - const bool __can_fill - = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>(); - - std::__uninitialized_fill<__can_fill>:: - __uninit_fill(__first, __last, __x); - } - - - - template - - _ForwardIterator - __do_uninit_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) - { - _ForwardIterator __cur = __first; - try - { - for (; __n > 0; --__n, (void) ++__cur) - std::_Construct(std::__addressof(*__cur), __x); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - - template - struct __uninitialized_fill_n - { - template - static _ForwardIterator - __uninit_fill_n(_ForwardIterator __first, _Size __n, - const _Tp& __x) - { return std::__do_uninit_fill_n(__first, __n, __x); } - }; - - template<> - struct __uninitialized_fill_n - { - template - static _ForwardIterator - __uninit_fill_n(_ForwardIterator __first, _Size __n, - const _Tp& __x) - { return std::fill_n(__first, __n, __x); } - }; -# 310 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - - - const bool __can_fill - = __is_trivial(_ValueType) && __is_assignable(_ValueType&, const _Tp&) && std::__check_constructible<_ValueType, const _Tp&>() - - - - && __is_integer<_Size>::__value; - - return __uninitialized_fill_n<__can_fill>:: - __uninit_fill_n(__first, __n, __x); - } -# 340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - - _ForwardIterator - __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - { - _ForwardIterator __cur = __result; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __first != __last; ++__first, (void)++__cur) - __traits::construct(__alloc, std::__addressof(*__cur), *__first); - return __cur; - } - catch(...) - { - std::_Destroy(__result, __cur, __alloc); - throw; - } - } - - - template - - inline _ForwardIterator - __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, allocator<_Tp>&) - { - - - - - return std::uninitialized_copy(__first, __last, __result); - } - - - template - - inline _ForwardIterator - __uninitialized_move_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - { - return std::__uninitialized_copy_a(std::make_move_iterator(__first), - std::make_move_iterator(__last), - __result, __alloc); - } - - template - - inline _ForwardIterator - __uninitialized_move_if_noexcept_a(_InputIterator __first, - _InputIterator __last, - _ForwardIterator __result, - _Allocator& __alloc) - { - return std::__uninitialized_copy_a - (std::__make_move_if_noexcept_iterator(__first), - std::__make_move_if_noexcept_iterator(__last), __result, __alloc); - } - - template - - void - __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x, _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __cur != __last; ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur), __x); - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - template - - inline void - __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __x, allocator<_Tp2>&) - { - - - - - std::uninitialized_fill(__first, __last, __x); - } - - - template - - _ForwardIterator - __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, - const _Tp& __x, _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __n > 0; --__n, (void) ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur), __x); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - template - - inline _ForwardIterator - __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, - const _Tp& __x, allocator<_Tp2>&) - { - - - - - return std::uninitialized_fill_n(__first, __n, __x); - } -# 485 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - __uninitialized_copy_move(_InputIterator1 __first1, - _InputIterator1 __last1, - _InputIterator2 __first2, - _InputIterator2 __last2, - _ForwardIterator __result, - _Allocator& __alloc) - { - _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, - __result, - __alloc); - try - { - return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); - } - catch(...) - { - std::_Destroy(__result, __mid, __alloc); - throw; - } - } - - - - - - template - inline _ForwardIterator - __uninitialized_move_copy(_InputIterator1 __first1, - _InputIterator1 __last1, - _InputIterator2 __first2, - _InputIterator2 __last2, - _ForwardIterator __result, - _Allocator& __alloc) - { - _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, - __result, - __alloc); - try - { - return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); - } - catch(...) - { - std::_Destroy(__result, __mid, __alloc); - throw; - } - } - - - - - template - inline _ForwardIterator - __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, - const _Tp& __x, _InputIterator __first, - _InputIterator __last, _Allocator& __alloc) - { - std::__uninitialized_fill_a(__result, __mid, __x, __alloc); - try - { - return std::__uninitialized_move_a(__first, __last, __mid, __alloc); - } - catch(...) - { - std::_Destroy(__result, __mid, __alloc); - throw; - } - } - - - - - template - inline void - __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, - _ForwardIterator __first2, - _ForwardIterator __last2, const _Tp& __x, - _Allocator& __alloc) - { - _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, - __first2, - __alloc); - try - { - std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); - } - catch(...) - { - std::_Destroy(__first2, __mid2, __alloc); - throw; - } - } -# 592 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - struct __uninitialized_default_1 - { - template - static void - __uninit_default(_ForwardIterator __first, _ForwardIterator __last) - { - _ForwardIterator __cur = __first; - try - { - for (; __cur != __last; ++__cur) - std::_Construct(std::__addressof(*__cur)); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_1 - { - template - static void - __uninit_default(_ForwardIterator __first, _ForwardIterator __last) - { - if (__first == __last) - return; - - typename iterator_traits<_ForwardIterator>::value_type* __val - = std::__addressof(*__first); - std::_Construct(__val); - if (++__first != __last) - std::fill(__first, __last, *__val); - } - }; - - template - struct __uninitialized_default_n_1 - { - template - - static _ForwardIterator - __uninit_default_n(_ForwardIterator __first, _Size __n) - { - _ForwardIterator __cur = __first; - try - { - for (; __n > 0; --__n, (void) ++__cur) - std::_Construct(std::__addressof(*__cur)); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_n_1 - { - template - - static _ForwardIterator - __uninit_default_n(_ForwardIterator __first, _Size __n) - { - if (__n > 0) - { - typename iterator_traits<_ForwardIterator>::value_type* __val - = std::__addressof(*__first); - std::_Construct(__val); - ++__first; - __first = std::fill_n(__first, __n - 1, *__val); - } - return __first; - } - }; - - - - template - inline void - __uninitialized_default(_ForwardIterator __first, - _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - const bool __assignable = is_copy_assignable<_ValueType>::value; - - std::__uninitialized_default_1<__is_trivial(_ValueType) - && __assignable>:: - __uninit_default(__first, __last); - } - - - - template - - inline _ForwardIterator - __uninitialized_default_n(_ForwardIterator __first, _Size __n) - { - - - - - - - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - constexpr bool __can_fill - = __and_, is_copy_assignable<_ValueType>>::value; - - return __uninitialized_default_n_1<__is_trivial(_ValueType) - && __can_fill>:: - __uninit_default_n(__first, __n); - } - - - - - - template - void - __uninitialized_default_a(_ForwardIterator __first, - _ForwardIterator __last, - _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __cur != __last; ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur)); - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - template - inline void - __uninitialized_default_a(_ForwardIterator __first, - _ForwardIterator __last, - allocator<_Tp>&) - { std::__uninitialized_default(__first, __last); } - - - - - - template - _ForwardIterator - __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, - _Allocator& __alloc) - { - _ForwardIterator __cur = __first; - try - { - typedef __gnu_cxx::__alloc_traits<_Allocator> __traits; - for (; __n > 0; --__n, (void) ++__cur) - __traits::construct(__alloc, std::__addressof(*__cur)); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur, __alloc); - throw; - } - } - - - - - template - - inline _ForwardIterator - __uninitialized_default_n_a(_ForwardIterator __first, _Size __n, - allocator<_Tp>&) - { return std::__uninitialized_default_n(__first, __n); } - - - template - struct __uninitialized_default_novalue_1 - { - template - static void - __uninit_default_novalue(_ForwardIterator __first, - _ForwardIterator __last) - { - _ForwardIterator __cur = __first; - try - { - for (; __cur != __last; ++__cur) - std::_Construct_novalue(std::__addressof(*__cur)); - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_novalue_1 - { - template - static void - __uninit_default_novalue(_ForwardIterator __first, - _ForwardIterator __last) - { - } - }; - - template - struct __uninitialized_default_novalue_n_1 - { - template - static _ForwardIterator - __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) - { - _ForwardIterator __cur = __first; - try - { - for (; __n > 0; --__n, (void) ++__cur) - std::_Construct_novalue(std::__addressof(*__cur)); - return __cur; - } - catch(...) - { - std::_Destroy(__first, __cur); - throw; - } - } - }; - - template<> - struct __uninitialized_default_novalue_n_1 - { - template - static _ForwardIterator - __uninit_default_novalue_n(_ForwardIterator __first, _Size __n) - { return std::next(__first, __n); } - }; - - - - template - inline void - __uninitialized_default_novalue(_ForwardIterator __first, - _ForwardIterator __last) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - std::__uninitialized_default_novalue_1< - is_trivially_default_constructible<_ValueType>::value>:: - __uninit_default_novalue(__first, __last); - } - - - - template - inline _ForwardIterator - __uninitialized_default_novalue_n(_ForwardIterator __first, _Size __n) - { - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType; - - return __uninitialized_default_novalue_n_1< - is_trivially_default_constructible<_ValueType>::value>:: - __uninit_default_novalue_n(__first, __n); - } - - template - _ForwardIterator - __uninitialized_copy_n(_InputIterator __first, _Size __n, - _ForwardIterator __result, input_iterator_tag) - { - _ForwardIterator __cur = __result; - try - { - for (; __n > 0; --__n, (void) ++__first, ++__cur) - std::_Construct(std::__addressof(*__cur), *__first); - return __cur; - } - catch(...) - { - std::_Destroy(__result, __cur); - throw; - } - } - - template - inline _ForwardIterator - __uninitialized_copy_n(_RandomAccessIterator __first, _Size __n, - _ForwardIterator __result, - random_access_iterator_tag) - { return std::uninitialized_copy(__first, __first + __n, __result); } - - template - pair<_InputIterator, _ForwardIterator> - __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, - _ForwardIterator __result, input_iterator_tag) - { - _ForwardIterator __cur = __result; - try - { - for (; __n > 0; --__n, (void) ++__first, ++__cur) - std::_Construct(std::__addressof(*__cur), *__first); - return {__first, __cur}; - } - catch(...) - { - std::_Destroy(__result, __cur); - throw; - } - } - - template - inline pair<_RandomAccessIterator, _ForwardIterator> - __uninitialized_copy_n_pair(_RandomAccessIterator __first, _Size __n, - _ForwardIterator __result, - random_access_iterator_tag) - { - auto __second_res = uninitialized_copy(__first, __first + __n, __result); - auto __first_res = std::next(__first, __n); - return {__first_res, __second_res}; - } -# 947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_copy_n(_InputIterator __first, _Size __n, - _ForwardIterator __result) - { return std::__uninitialized_copy_n(__first, __n, __result, - std::__iterator_category(__first)); } - - - template - inline pair<_InputIterator, _ForwardIterator> - __uninitialized_copy_n_pair(_InputIterator __first, _Size __n, - _ForwardIterator __result) - { - return - std::__uninitialized_copy_n_pair(__first, __n, __result, - std::__iterator_category(__first)); - } -# 976 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline void - uninitialized_default_construct(_ForwardIterator __first, - _ForwardIterator __last) - { - __uninitialized_default_novalue(__first, __last); - } -# 991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_default_construct_n(_ForwardIterator __first, _Size __count) - { - return __uninitialized_default_novalue_n(__first, __count); - } - - - - - - - - template - inline void - uninitialized_value_construct(_ForwardIterator __first, - _ForwardIterator __last) - { - return __uninitialized_default(__first, __last); - } -# 1019 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_value_construct_n(_ForwardIterator __first, _Size __count) - { - return __uninitialized_default_n(__first, __count); - } -# 1034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline _ForwardIterator - uninitialized_move(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result) - { - return std::uninitialized_copy - (std::make_move_iterator(__first), - std::make_move_iterator(__last), __result); - } -# 1052 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - template - inline pair<_InputIterator, _ForwardIterator> - uninitialized_move_n(_InputIterator __first, _Size __count, - _ForwardIterator __result) - { - auto __res = std::__uninitialized_copy_n_pair - (std::make_move_iterator(__first), - __count, __result); - return {__res.first.base(), __res.second}; - } - - - - - - template - - inline void - __relocate_object_a(_Tp* __restrict __dest, _Up* __restrict __orig, - _Allocator& __alloc) - noexcept(noexcept(std::allocator_traits<_Allocator>::construct(__alloc, - __dest, std::move(*__orig))) - && noexcept(std::allocator_traits<_Allocator>::destroy( - __alloc, std::__addressof(*__orig)))) - { - typedef std::allocator_traits<_Allocator> __traits; - __traits::construct(__alloc, __dest, std::move(*__orig)); - __traits::destroy(__alloc, std::__addressof(*__orig)); - } - - - - template - struct __is_bitwise_relocatable - : is_trivial<_Tp> { }; - - template - - inline _ForwardIterator - __relocate_a_1(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - noexcept(noexcept(std::__relocate_object_a(std::addressof(*__result), - std::addressof(*__first), - __alloc))) - { - typedef typename iterator_traits<_InputIterator>::value_type - _ValueType; - typedef typename iterator_traits<_ForwardIterator>::value_type - _ValueType2; - static_assert(std::is_same<_ValueType, _ValueType2>::value, - "relocation is only possible for values of the same type"); - _ForwardIterator __cur = __result; - for (; __first != __last; ++__first, (void)++__cur) - std::__relocate_object_a(std::__addressof(*__cur), - std::__addressof(*__first), __alloc); - return __cur; - } - - - template - - inline __enable_if_t::value, _Tp*> - __relocate_a_1(_Tp* __first, _Tp* __last, - _Tp* __result, - [[__maybe_unused__]] allocator<_Up>& __alloc) noexcept - { - ptrdiff_t __count = __last - __first; - if (__count > 0) - { -# 1132 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_uninitialized.h" 3 - __builtin_memmove(__result, __first, __count * sizeof(_Tp)); - } - return __result + __count; - } - - - template - - inline _ForwardIterator - __relocate_a(_InputIterator __first, _InputIterator __last, - _ForwardIterator __result, _Allocator& __alloc) - noexcept(noexcept(__relocate_a_1(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result), __alloc))) - { - return std::__relocate_a_1(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result), __alloc); - } - - - - - - - -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 1 3 -# 78 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template - struct _Vector_base - { - typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template - rebind<_Tp>::other _Tp_alloc_type; - typedef typename __gnu_cxx::__alloc_traits<_Tp_alloc_type>::pointer - pointer; - - struct _Vector_impl_data - { - pointer _M_start; - pointer _M_finish; - pointer _M_end_of_storage; - - - _Vector_impl_data() noexcept - : _M_start(), _M_finish(), _M_end_of_storage() - { } - - - - _Vector_impl_data(_Vector_impl_data&& __x) noexcept - : _M_start(__x._M_start), _M_finish(__x._M_finish), - _M_end_of_storage(__x._M_end_of_storage) - { __x._M_start = __x._M_finish = __x._M_end_of_storage = pointer(); } - - - - void - _M_copy_data(_Vector_impl_data const& __x) noexcept - { - _M_start = __x._M_start; - _M_finish = __x._M_finish; - _M_end_of_storage = __x._M_end_of_storage; - } - - - void - _M_swap_data(_Vector_impl_data& __x) noexcept - { - - - _Vector_impl_data __tmp; - __tmp._M_copy_data(*this); - _M_copy_data(__x); - __x._M_copy_data(__tmp); - } - }; - - struct _Vector_impl - : public _Tp_alloc_type, public _Vector_impl_data - { - - _Vector_impl() noexcept(is_nothrow_default_constructible<_Tp_alloc_type>::value) - - : _Tp_alloc_type() - { } - - - _Vector_impl(_Tp_alloc_type const& __a) noexcept - : _Tp_alloc_type(__a) - { } - - - - - - _Vector_impl(_Vector_impl&& __x) noexcept - : _Tp_alloc_type(std::move(__x)), _Vector_impl_data(std::move(__x)) - { } - - - _Vector_impl(_Tp_alloc_type&& __a) noexcept - : _Tp_alloc_type(std::move(__a)) - { } - - - _Vector_impl(_Tp_alloc_type&& __a, _Vector_impl&& __rv) noexcept - : _Tp_alloc_type(std::move(__a)), _Vector_impl_data(std::move(__rv)) - { } -# 291 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - }; - - public: - typedef _Alloc allocator_type; - - - _Tp_alloc_type& - _M_get_Tp_allocator() noexcept - { return this->_M_impl; } - - - const _Tp_alloc_type& - _M_get_Tp_allocator() const noexcept - { return this->_M_impl; } - - - allocator_type - get_allocator() const noexcept - { return allocator_type(_M_get_Tp_allocator()); } - - - _Vector_base() = default; - - - - - - _Vector_base(const allocator_type& __a) noexcept - : _M_impl(__a) { } - - - - - _Vector_base(size_t __n) - : _M_impl() - { _M_create_storage(__n); } - - - - _Vector_base(size_t __n, const allocator_type& __a) - : _M_impl(__a) - { _M_create_storage(__n); } - - - _Vector_base(_Vector_base&&) = default; - - - - - _Vector_base(_Tp_alloc_type&& __a) noexcept - : _M_impl(std::move(__a)) { } - - - _Vector_base(_Vector_base&& __x, const allocator_type& __a) - : _M_impl(__a) - { - if (__x.get_allocator() == __a) - this->_M_impl._M_swap_data(__x._M_impl); - else - { - size_t __n = __x._M_impl._M_finish - __x._M_impl._M_start; - _M_create_storage(__n); - } - } - - - - _Vector_base(const allocator_type& __a, _Vector_base&& __x) - : _M_impl(_Tp_alloc_type(__a), std::move(__x._M_impl)) - { } - - - - ~_Vector_base() noexcept - { - _M_deallocate(_M_impl._M_start, - _M_impl._M_end_of_storage - _M_impl._M_start); - } - - public: - _Vector_impl _M_impl; - - - pointer - _M_allocate(size_t __n) - { - typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; - return __n != 0 ? _Tr::allocate(_M_impl, __n) : pointer(); - } - - - void - _M_deallocate(pointer __p, size_t __n) - { - typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Tr; - if (__p) - _Tr::deallocate(_M_impl, __p, __n); - } - - protected: - - void - _M_create_storage(size_t __n) - { - this->_M_impl._M_start = this->_M_allocate(__n); - this->_M_impl._M_finish = this->_M_impl._M_start; - this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; - } - }; -# 424 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template > - class vector : protected _Vector_base<_Tp, _Alloc> - { -# 437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - static_assert(is_same::type, _Tp>::value, - "std::vector must have a non-const, non-volatile value_type"); - - static_assert(is_same::value, - "std::vector must have the same value_type as its allocator"); - - - - typedef _Vector_base<_Tp, _Alloc> _Base; - typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; - typedef __gnu_cxx::__alloc_traits<_Tp_alloc_type> _Alloc_traits; - - public: - typedef _Tp value_type; - typedef typename _Base::pointer pointer; - typedef typename _Alloc_traits::const_pointer const_pointer; - typedef typename _Alloc_traits::reference reference; - typedef typename _Alloc_traits::const_reference const_reference; - typedef __gnu_cxx::__normal_iterator iterator; - typedef __gnu_cxx::__normal_iterator - const_iterator; - typedef std::reverse_iterator const_reverse_iterator; - typedef std::reverse_iterator reverse_iterator; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Alloc allocator_type; - - private: - - static constexpr bool - _S_nothrow_relocate(true_type) - { - return noexcept(std::__relocate_a(std::declval(), - std::declval(), - std::declval(), - std::declval<_Tp_alloc_type&>())); - } - - static constexpr bool - _S_nothrow_relocate(false_type) - { return false; } - - static constexpr bool - _S_use_relocate() - { - - - - return _S_nothrow_relocate(__is_move_insertable<_Tp_alloc_type>{}); - } - - static pointer - _S_do_relocate(pointer __first, pointer __last, pointer __result, - _Tp_alloc_type& __alloc, true_type) noexcept - { - return std::__relocate_a(__first, __last, __result, __alloc); - } - - static pointer - _S_do_relocate(pointer, pointer, pointer __result, - _Tp_alloc_type&, false_type) noexcept - { return __result; } - - static pointer - _S_relocate(pointer __first, pointer __last, pointer __result, - _Tp_alloc_type& __alloc) noexcept - { - - - return std::__relocate_a(__first, __last, __result, __alloc); - - - - - } - - - protected: - using _Base::_M_allocate; - using _Base::_M_deallocate; - using _Base::_M_impl; - using _Base::_M_get_Tp_allocator; - - public: - - - - - - - - vector() = default; -# 537 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - explicit - - vector(const allocator_type& __a) noexcept - : _Base(__a) { } -# 551 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - explicit - - vector(size_type __n, const allocator_type& __a = allocator_type()) - : _Base(_S_check_init_len(__n, __a), __a) - { _M_default_initialize(__n); } -# 566 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector(size_type __n, const value_type& __value, - const allocator_type& __a = allocator_type()) - : _Base(_S_check_init_len(__n, __a), __a) - { _M_fill_initialize(__n, __value); } -# 598 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector(const vector& __x) - : _Base(__x.size(), - _Alloc_traits::_S_select_on_copy(__x._M_get_Tp_allocator())) - { - this->_M_impl._M_finish = - std::__uninitialized_copy_a(__x.begin(), __x.end(), - this->_M_impl._M_start, - _M_get_Tp_allocator()); - } -# 617 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector(vector&&) noexcept = default; - - - - vector(const vector& __x, const __type_identity_t& __a) - : _Base(__x.size(), __a) - { - this->_M_impl._M_finish = - std::__uninitialized_copy_a(__x.begin(), __x.end(), - this->_M_impl._M_start, - _M_get_Tp_allocator()); - } - - private: - - vector(vector&& __rv, const allocator_type& __m, true_type) noexcept - : _Base(__m, std::move(__rv)) - { } - - - vector(vector&& __rv, const allocator_type& __m, false_type) - : _Base(__m) - { - if (__rv.get_allocator() == __m) - this->_M_impl._M_swap_data(__rv._M_impl); - else if (!__rv.empty()) - { - this->_M_create_storage(__rv.size()); - this->_M_impl._M_finish = - std::__uninitialized_move_a(__rv.begin(), __rv.end(), - this->_M_impl._M_start, - _M_get_Tp_allocator()); - __rv.clear(); - } - } - - public: - - - vector(vector&& __rv, const __type_identity_t& __m) - noexcept( noexcept( - vector(std::declval(), std::declval(), - std::declval())) ) - : vector(std::move(__rv), __m, typename _Alloc_traits::is_always_equal{}) - { } -# 675 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector(initializer_list __l, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { - _M_range_initialize(__l.begin(), __l.end(), - random_access_iterator_tag()); - } -# 701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template> - - vector(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { - _M_range_initialize(__first, __last, - std::__iterator_category(__first)); - } -# 730 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - ~vector() noexcept - { - std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - ; - } -# 747 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector& - operator=(const vector& __x); -# 762 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector& - operator=(vector&& __x) noexcept(_Alloc_traits::_S_nothrow_move()) - { - constexpr bool __move_storage = - _Alloc_traits::_S_propagate_on_move_assign() - || _Alloc_traits::_S_always_equal(); - _M_move_assign(std::move(__x), __bool_constant<__move_storage>()); - return *this; - } -# 784 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - vector& - operator=(initializer_list __l) - { - this->_M_assign_aux(__l.begin(), __l.end(), - random_access_iterator_tag()); - return *this; - } -# 804 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - assign(size_type __n, const value_type& __val) - { _M_fill_assign(__n, __val); } -# 821 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template> - - void - assign(_InputIterator __first, _InputIterator __last) - { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } -# 851 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - assign(initializer_list __l) - { - this->_M_assign_aux(__l.begin(), __l.end(), - random_access_iterator_tag()); - } - - - - using _Base::get_allocator; - - - - - - - - [[__nodiscard__]] - iterator - begin() noexcept - { return iterator(this->_M_impl._M_start); } - - - - - - - [[__nodiscard__]] - const_iterator - begin() const noexcept - { return const_iterator(this->_M_impl._M_start); } - - - - - - - [[__nodiscard__]] - iterator - end() noexcept - { return iterator(this->_M_impl._M_finish); } - - - - - - - [[__nodiscard__]] - const_iterator - end() const noexcept - { return const_iterator(this->_M_impl._M_finish); } - - - - - - - [[__nodiscard__]] - reverse_iterator - rbegin() noexcept - { return reverse_iterator(end()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - rbegin() const noexcept - { return const_reverse_iterator(end()); } - - - - - - - [[__nodiscard__]] - reverse_iterator - rend() noexcept - { return reverse_iterator(begin()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - rend() const noexcept - { return const_reverse_iterator(begin()); } - - - - - - - - [[__nodiscard__]] - const_iterator - cbegin() const noexcept - { return const_iterator(this->_M_impl._M_start); } - - - - - - - [[__nodiscard__]] - const_iterator - cend() const noexcept - { return const_iterator(this->_M_impl._M_finish); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(end()); } - - - - - - - [[__nodiscard__]] - const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(begin()); } - - - - - [[__nodiscard__]] - size_type - size() const noexcept - { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } - - - [[__nodiscard__]] - size_type - max_size() const noexcept - { return _S_max_size(_M_get_Tp_allocator()); } -# 1009 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - resize(size_type __new_size) - { - if (__new_size > size()) - _M_default_append(__new_size - size()); - else if (__new_size < size()) - _M_erase_at_end(this->_M_impl._M_start + __new_size); - } -# 1030 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - resize(size_type __new_size, const value_type& __x) - { - if (__new_size > size()) - _M_fill_insert(end(), __new_size - size(), __x); - else if (__new_size < size()) - _M_erase_at_end(this->_M_impl._M_start + __new_size); - } -# 1064 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - shrink_to_fit() - { _M_shrink_to_fit(); } - - - - - - - [[__nodiscard__]] - size_type - capacity() const noexcept - { return size_type(this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); } - - - - - - [[__nodiscard__]] - bool - empty() const noexcept - { return begin() == end(); } -# 1106 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - reserve(size_type __n); -# 1121 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - [[__nodiscard__]] - reference - operator[](size_type __n) noexcept - { - ; - return *(this->_M_impl._M_start + __n); - } -# 1140 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - [[__nodiscard__]] - const_reference - operator[](size_type __n) const noexcept - { - ; - return *(this->_M_impl._M_start + __n); - } - - protected: - - - void - _M_range_check(size_type __n) const - { - if (__n >= this->size()) - __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"), - - - __n, this->size()); - } - - public: -# 1174 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - reference - at(size_type __n) - { - _M_range_check(__n); - return (*this)[__n]; - } -# 1193 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - const_reference - at(size_type __n) const - { - _M_range_check(__n); - return (*this)[__n]; - } - - - - - - [[__nodiscard__]] - reference - front() noexcept - { - ; - return *begin(); - } - - - - - - [[__nodiscard__]] - const_reference - front() const noexcept - { - ; - return *begin(); - } - - - - - - [[__nodiscard__]] - reference - back() noexcept - { - ; - return *(end() - 1); - } - - - - - - [[__nodiscard__]] - const_reference - back() const noexcept - { - ; - return *(end() - 1); - } -# 1255 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - [[__nodiscard__]] - _Tp* - data() noexcept - { return _M_data_ptr(this->_M_impl._M_start); } - - [[__nodiscard__]] - const _Tp* - data() const noexcept - { return _M_data_ptr(this->_M_impl._M_start); } -# 1277 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - push_back(const value_type& __x) - { - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - __x); - ++this->_M_impl._M_finish; - ; - } - else - _M_realloc_insert(end(), __x); - } - - - - void - push_back(value_type&& __x) - { emplace_back(std::move(__x)); } - - template - - - reference - - - - emplace_back(_Args&&... __args); -# 1318 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - pop_back() noexcept - { - ; - --this->_M_impl._M_finish; - _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); - ; - } -# 1340 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - - iterator - emplace(const_iterator __position, _Args&&... __args) - { return _M_emplace_aux(__position, std::forward<_Args>(__args)...); } -# 1358 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - insert(const_iterator __position, const value_type& __x); -# 1389 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - insert(const_iterator __position, value_type&& __x) - { return _M_insert_rval(__position, std::move(__x)); } -# 1407 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - insert(const_iterator __position, initializer_list __l) - { - auto __offset = __position - cbegin(); - _M_range_insert(begin() + __offset, __l.begin(), __l.end(), - std::random_access_iterator_tag()); - return begin() + __offset; - } -# 1433 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - insert(const_iterator __position, size_type __n, const value_type& __x) - { - difference_type __offset = __position - cbegin(); - _M_fill_insert(begin() + __offset, __n, __x); - return begin() + __offset; - } -# 1475 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template> - - iterator - insert(const_iterator __position, _InputIterator __first, - _InputIterator __last) - { - difference_type __offset = __position - cbegin(); - _M_range_insert(begin() + __offset, __first, __last, - std::__iterator_category(__first)); - return begin() + __offset; - } -# 1529 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - - erase(const_iterator __position) - { return _M_erase(begin() + (__position - cbegin())); } -# 1557 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - iterator - - erase(const_iterator __first, const_iterator __last) - { - const auto __beg = begin(); - const auto __cbeg = cbegin(); - return _M_erase(__beg + (__first - __cbeg), __beg + (__last - __cbeg)); - } -# 1582 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - swap(vector& __x) noexcept - { - - do { if (std::__is_constant_evaluated() && !bool(_Alloc_traits::propagate_on_container_swap::value || _M_get_Tp_allocator() == __x._M_get_Tp_allocator())) __builtin_unreachable(); } while (false); - - - this->_M_impl._M_swap_data(__x._M_impl); - _Alloc_traits::_S_on_swap(_M_get_Tp_allocator(), - __x._M_get_Tp_allocator()); - } -# 1601 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - void - clear() noexcept - { _M_erase_at_end(this->_M_impl._M_start); } - - protected: - - - - - template - - pointer - _M_allocate_and_copy(size_type __n, - _ForwardIterator __first, _ForwardIterator __last) - { - pointer __result = this->_M_allocate(__n); - try - { - std::__uninitialized_copy_a(__first, __last, __result, - _M_get_Tp_allocator()); - return __result; - } - catch(...) - { - _M_deallocate(__result, __n); - throw; - } - } -# 1661 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - - void - _M_range_initialize(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag) - { - try { - for (; __first != __last; ++__first) - - emplace_back(*__first); - - - - } catch(...) { - clear(); - throw; - } - } - - - template - - void - _M_range_initialize(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag) - { - const size_type __n = std::distance(__first, __last); - this->_M_impl._M_start - = this->_M_allocate(_S_check_init_len(__n, _M_get_Tp_allocator())); - this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; - this->_M_impl._M_finish = - std::__uninitialized_copy_a(__first, __last, - this->_M_impl._M_start, - _M_get_Tp_allocator()); - } - - - - - void - _M_fill_initialize(size_type __n, const value_type& __value) - { - this->_M_impl._M_finish = - std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, - _M_get_Tp_allocator()); - } - - - - - void - _M_default_initialize(size_type __n) - { - this->_M_impl._M_finish = - std::__uninitialized_default_n_a(this->_M_impl._M_start, __n, - _M_get_Tp_allocator()); - } -# 1727 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - - void - _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) - { _M_fill_assign(__n, __val); } - - - template - - void - _M_assign_dispatch(_InputIterator __first, _InputIterator __last, - __false_type) - { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } - - - template - - void - _M_assign_aux(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag); - - - template - - void - _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag); - - - - - void - _M_fill_assign(size_type __n, const value_type& __val); - - - - - - - - template - - void - _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, - __true_type) - { _M_fill_insert(__pos, __n, __val); } - - - template - - void - _M_insert_dispatch(iterator __pos, _InputIterator __first, - _InputIterator __last, __false_type) - { - _M_range_insert(__pos, __first, __last, - std::__iterator_category(__first)); - } - - - template - - void - _M_range_insert(iterator __pos, _InputIterator __first, - _InputIterator __last, std::input_iterator_tag); - - - template - - void - _M_range_insert(iterator __pos, _ForwardIterator __first, - _ForwardIterator __last, std::forward_iterator_tag); - - - - - void - _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); - - - - - void - _M_default_append(size_type __n); - - - bool - _M_shrink_to_fit(); -# 1826 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - struct _Temporary_value - { - template - explicit - _Temporary_value(vector* __vec, _Args&&... __args) : _M_this(__vec) - { - _Alloc_traits::construct(_M_this->_M_impl, _M_ptr(), - std::forward<_Args>(__args)...); - } - - - ~_Temporary_value() - { _Alloc_traits::destroy(_M_this->_M_impl, _M_ptr()); } - - value_type& - _M_val() noexcept { return _M_storage._M_val; } - - private: - _Tp* - _M_ptr() noexcept { return std::__addressof(_M_storage._M_val); } - - union _Storage - { - constexpr _Storage() : _M_byte() { } - ~_Storage() { } - _Storage& operator=(const _Storage&) = delete; - unsigned char _M_byte; - _Tp _M_val; - }; - - vector* _M_this; - _Storage _M_storage; - }; - - - - template - - void - _M_insert_aux(iterator __position, _Arg&& __arg); - - template - - void - _M_realloc_insert(iterator __position, _Args&&... __args); - - - - iterator - _M_insert_rval(const_iterator __position, value_type&& __v); - - - template - - iterator - _M_emplace_aux(const_iterator __position, _Args&&... __args); - - - - iterator - _M_emplace_aux(const_iterator __position, value_type&& __v) - { return _M_insert_rval(__position, std::move(__v)); } - - - - - size_type - _M_check_len(size_type __n, const char* __s) const - { - if (max_size() - size() < __n) - __throw_length_error((__s)); - - const size_type __len = size() + (std::max)(size(), __n); - return (__len < size() || __len > max_size()) ? max_size() : __len; - } - - - static size_type - _S_check_init_len(size_type __n, const allocator_type& __a) - { - if (__n > _S_max_size(_Tp_alloc_type(__a))) - __throw_length_error( - ("cannot create std::vector larger than max_size()")); - return __n; - } - - static size_type - _S_max_size(const _Tp_alloc_type& __a) noexcept - { - - - - const size_t __diffmax - = __gnu_cxx::__numeric_traits::__max / sizeof(_Tp); - const size_t __allocmax = _Alloc_traits::max_size(__a); - return (std::min)(__diffmax, __allocmax); - } - - - - - - - void - _M_erase_at_end(pointer __pos) noexcept - { - if (size_type __n = this->_M_impl._M_finish - __pos) - { - std::_Destroy(__pos, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish = __pos; - ; - } - } - - - iterator - _M_erase(iterator __position); - - - iterator - _M_erase(iterator __first, iterator __last); - - - private: - - - - - void - _M_move_assign(vector&& __x, true_type) noexcept - { - vector __tmp(get_allocator()); - this->_M_impl._M_swap_data(__x._M_impl); - __tmp._M_impl._M_swap_data(__x._M_impl); - std::__alloc_on_move(_M_get_Tp_allocator(), __x._M_get_Tp_allocator()); - } - - - - - void - _M_move_assign(vector&& __x, false_type) - { - if (__x._M_get_Tp_allocator() == this->_M_get_Tp_allocator()) - _M_move_assign(std::move(__x), true_type()); - else - { - - - this->_M_assign_aux(std::make_move_iterator(__x.begin()), - std::make_move_iterator(__x.end()), - std::random_access_iterator_tag()); - __x.clear(); - } - } - - - template - - _Up* - _M_data_ptr(_Up* __ptr) const noexcept - { return __ptr; } - - - template - - typename std::pointer_traits<_Ptr>::element_type* - _M_data_ptr(_Ptr __ptr) const - { return empty() ? nullptr : std::__to_address(__ptr); } -# 2012 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - }; - - - template::value_type, - typename _Allocator = allocator<_ValT>, - typename = _RequireInputIter<_InputIterator>, - typename = _RequireAllocator<_Allocator>> - vector(_InputIterator, _InputIterator, _Allocator = _Allocator()) - -> vector<_ValT, _Allocator>; -# 2034 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - - inline bool - operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return (__x.size() == __y.size() - && std::equal(__x.begin(), __x.end(), __y.begin())); } -# 2074 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_vector.h" 3 - template - inline bool - operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return std::lexicographical_compare(__x.begin(), __x.end(), - __y.begin(), __y.end()); } - - - template - inline bool - operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return !(__x == __y); } - - - template - inline bool - operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return __y < __x; } - - - template - inline bool - operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return !(__y < __x); } - - - template - inline bool - operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) - { return !(__x < __y); } - - - - template - - inline void - swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } - - - - - namespace __detail::__variant - { - template struct _Never_valueless_alt; - - - - template - struct _Never_valueless_alt> - : std::is_nothrow_move_assignable> - { }; - } - - - -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 1 3 -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/hash_bytes.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template - struct __hash_base - { - typedef _Result result_type [[__deprecated__]]; - typedef _Arg argument_type [[__deprecated__]]; - }; - - - template - struct hash; - - template - struct __poison_hash - { - static constexpr bool __enable_hash_call = false; - private: - - __poison_hash(__poison_hash&&); - ~__poison_hash(); - }; - - template - struct __poison_hash<_Tp, __void_t()(declval<_Tp>()))>> - { - static constexpr bool __enable_hash_call = true; - }; - - - template::value> - struct __hash_enum - { - private: - - __hash_enum(__hash_enum&&); - ~__hash_enum(); - }; - - - template - struct __hash_enum<_Tp, true> : public __hash_base - { - size_t - operator()(_Tp __val) const noexcept - { - using __type = typename underlying_type<_Tp>::type; - return hash<__type>{}(static_cast<__type>(__val)); - } - }; - - - - template - struct hash : __hash_enum<_Tp> - { }; - - - template - struct hash<_Tp*> : public __hash_base - { - size_t - operator()(_Tp* __p) const noexcept - { return reinterpret_cast(__p); } - }; -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template<> struct hash : public __hash_base { size_t operator()(bool __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(signed char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned char __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(wchar_t __val) const noexcept { return static_cast(__val); } }; - - - - - - - - template<> struct hash : public __hash_base { size_t operator()(char16_t __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(char32_t __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(short __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(int __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(long long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned short __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned int __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned long __val) const noexcept { return static_cast(__val); } }; - - - template<> struct hash : public __hash_base { size_t operator()(unsigned long long __val) const noexcept { return static_cast(__val); } }; -# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - struct _Hash_impl - { - static size_t - hash(const void* __ptr, size_t __clength, - size_t __seed = static_cast(0xc70f6907UL)) - { return _Hash_bytes(__ptr, __clength, __seed); } - - template - static size_t - hash(const _Tp& __val) - { return hash(&__val, sizeof(__val)); } - - template - static size_t - __hash_combine(const _Tp& __val, size_t __hash) - { return hash(&__val, sizeof(__val), __hash); } - }; - - - struct _Fnv_hash_impl - { - static size_t - hash(const void* __ptr, size_t __clength, - size_t __seed = static_cast(2166136261UL)) - { return _Fnv_hash_bytes(__ptr, __clength, __seed); } - - template - static size_t - hash(const _Tp& __val) - { return hash(&__val, sizeof(__val)); } - - template - static size_t - __hash_combine(const _Tp& __val, size_t __hash) - { return hash(&__val, sizeof(__val), __hash); } - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(float __val) const noexcept - { - - return __val != 0.0f ? std::_Hash_impl::hash(__val) : 0; - } - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(double __val) const noexcept - { - - return __val != 0.0 ? std::_Hash_impl::hash(__val) : 0; - } - }; - - - template<> - struct hash - : public __hash_base - { - __attribute__ ((__pure__)) size_t - operator()(long double __val) const noexcept; - }; - - - template<> - struct hash : public __hash_base - { - size_t - operator()(nullptr_t) const noexcept - { return 0; } - }; -# 294 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functional_hash.h" 3 - template - struct __is_fast_hash : public std::true_type - { }; - - template<> - struct __is_fast_hash> : public std::false_type - { }; - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - typedef unsigned long _Bit_type; - enum { _S_word_bit = int(8 * sizeof(_Bit_type)) }; - - __attribute__((__nonnull__)) - - void - __fill_bvector_n(_Bit_type*, size_t, bool) noexcept; - - - - struct _Bit_reference - { - _Bit_type * _M_p; - _Bit_type _M_mask; - - - _Bit_reference(_Bit_type * __x, _Bit_type __y) - : _M_p(__x), _M_mask(__y) { } - - - _Bit_reference() noexcept : _M_p(0), _M_mask(0) { } - - - _Bit_reference(const _Bit_reference&) = default; - - - [[__nodiscard__]] - operator bool() const noexcept - { return !!(*_M_p & _M_mask); } - - - _Bit_reference& - operator=(bool __x) noexcept - { - if (__x) - *_M_p |= _M_mask; - else - *_M_p &= ~_M_mask; - return *this; - } -# 122 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - _Bit_reference& - operator=(const _Bit_reference& __x) noexcept - { return *this = bool(__x); } - - [[__nodiscard__]] - bool - operator==(const _Bit_reference& __x) const - { return bool(*this) == bool(__x); } - - [[__nodiscard__]] - bool - operator<(const _Bit_reference& __x) const - { return !bool(*this) && bool(__x); } - - - void - flip() noexcept - { *_M_p ^= _M_mask; } - - - - friend void - swap(_Bit_reference __x, _Bit_reference __y) noexcept - { - bool __tmp = __x; - __x = __y; - __y = __tmp; - } - - - friend void - swap(_Bit_reference __x, bool& __y) noexcept - { - bool __tmp = __x; - __x = __y; - __y = __tmp; - } - - - friend void - swap(bool& __x, _Bit_reference __y) noexcept - { - bool __tmp = __x; - __x = __y; - __y = __tmp; - } - - }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - struct _Bit_iterator_base - : public std::iterator - { - _Bit_type * _M_p; - unsigned int _M_offset; - - - _Bit_iterator_base(_Bit_type * __x, unsigned int __y) - : _M_p(__x), _M_offset(__y) { } - - - void - _M_bump_up() - { - if (_M_offset++ == int(_S_word_bit) - 1) - { - _M_offset = 0; - ++_M_p; - } - } - - - void - _M_bump_down() - { - if (_M_offset-- == 0) - { - _M_offset = int(_S_word_bit) - 1; - --_M_p; - } - } - - - void - _M_incr(ptrdiff_t __i) - { - difference_type __n = __i + _M_offset; - _M_p += __n / int(_S_word_bit); - __n = __n % int(_S_word_bit); - if (__n < 0) - { - __n += int(_S_word_bit); - --_M_p; - } - _M_offset = static_cast(__n); - } - - [[__nodiscard__]] - friend bool - operator==(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return __x._M_p == __y._M_p && __x._M_offset == __y._M_offset; } -# 237 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - [[__nodiscard__]] - friend bool - operator<(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { - return __x._M_p < __y._M_p - || (__x._M_p == __y._M_p && __x._M_offset < __y._M_offset); - } - - [[__nodiscard__]] - friend bool - operator!=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return !(__x == __y); } - - [[__nodiscard__]] - friend bool - operator>(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return __y < __x; } - - [[__nodiscard__]] - friend bool - operator<=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return !(__y < __x); } - - [[__nodiscard__]] - friend bool - operator>=(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { return !(__x < __y); } - - - friend ptrdiff_t - operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) - { - return (int(_S_word_bit) * (__x._M_p - __y._M_p) - + __x._M_offset - __y._M_offset); - } - }; -#pragma GCC diagnostic pop - - struct _Bit_iterator : public _Bit_iterator_base - { - typedef _Bit_reference reference; - - - - typedef _Bit_reference* pointer; - - typedef _Bit_iterator iterator; - - - _Bit_iterator() : _Bit_iterator_base(0, 0) { } - - - _Bit_iterator(_Bit_type * __x, unsigned int __y) - : _Bit_iterator_base(__x, __y) { } - - - iterator - _M_const_cast() const - { return *this; } - - [[__nodiscard__]] - reference - operator*() const - { return reference(_M_p, 1UL << _M_offset); } - - - iterator& - operator++() - { - _M_bump_up(); - return *this; - } - - - iterator - operator++(int) - { - iterator __tmp = *this; - _M_bump_up(); - return __tmp; - } - - - iterator& - operator--() - { - _M_bump_down(); - return *this; - } - - - iterator - operator--(int) - { - iterator __tmp = *this; - _M_bump_down(); - return __tmp; - } - - - iterator& - operator+=(difference_type __i) - { - _M_incr(__i); - return *this; - } - - - iterator& - operator-=(difference_type __i) - { - *this += -__i; - return *this; - } - - [[__nodiscard__]] - reference - operator[](difference_type __i) const - { return *(*this + __i); } - - [[__nodiscard__]] - friend iterator - operator+(const iterator& __x, difference_type __n) - { - iterator __tmp = __x; - __tmp += __n; - return __tmp; - } - - [[__nodiscard__]] - friend iterator - operator+(difference_type __n, const iterator& __x) - { return __x + __n; } - - [[__nodiscard__]] - friend iterator - operator-(const iterator& __x, difference_type __n) - { - iterator __tmp = __x; - __tmp -= __n; - return __tmp; - } - }; - - struct _Bit_const_iterator : public _Bit_iterator_base - { - typedef bool reference; - typedef bool const_reference; - - - - typedef const bool* pointer; - - typedef _Bit_const_iterator const_iterator; - - - _Bit_const_iterator() : _Bit_iterator_base(0, 0) { } - - - _Bit_const_iterator(_Bit_type * __x, unsigned int __y) - : _Bit_iterator_base(__x, __y) { } - - - _Bit_const_iterator(const _Bit_iterator& __x) - : _Bit_iterator_base(__x._M_p, __x._M_offset) { } - - - _Bit_iterator - _M_const_cast() const - { return _Bit_iterator(_M_p, _M_offset); } - - [[__nodiscard__]] - const_reference - operator*() const - { return _Bit_reference(_M_p, 1UL << _M_offset); } - - - const_iterator& - operator++() - { - _M_bump_up(); - return *this; - } - - - const_iterator - operator++(int) - { - const_iterator __tmp = *this; - _M_bump_up(); - return __tmp; - } - - - const_iterator& - operator--() - { - _M_bump_down(); - return *this; - } - - - const_iterator - operator--(int) - { - const_iterator __tmp = *this; - _M_bump_down(); - return __tmp; - } - - - const_iterator& - operator+=(difference_type __i) - { - _M_incr(__i); - return *this; - } - - - const_iterator& - operator-=(difference_type __i) - { - *this += -__i; - return *this; - } - - [[__nodiscard__]] - const_reference - operator[](difference_type __i) const - { return *(*this + __i); } - - [[__nodiscard__]] - friend const_iterator - operator+(const const_iterator& __x, difference_type __n) - { - const_iterator __tmp = __x; - __tmp += __n; - return __tmp; - } - - [[__nodiscard__]] - friend const_iterator - operator-(const const_iterator& __x, difference_type __n) - { - const_iterator __tmp = __x; - __tmp -= __n; - return __tmp; - } - - [[__nodiscard__]] - friend const_iterator - operator+(difference_type __n, const const_iterator& __x) - { return __x + __n; } - }; - - template - struct _Bvector_base - { - typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template - rebind<_Bit_type>::other _Bit_alloc_type; - typedef typename __gnu_cxx::__alloc_traits<_Bit_alloc_type> - _Bit_alloc_traits; - typedef typename _Bit_alloc_traits::pointer _Bit_pointer; - - struct _Bvector_impl_data - { - - _Bit_iterator _M_start; -# 514 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - _Bit_iterator _M_finish; - _Bit_pointer _M_end_of_storage; - - - _Bvector_impl_data() noexcept - : _M_start(), _M_finish(), _M_end_of_storage() - { } - - - _Bvector_impl_data(const _Bvector_impl_data&) = default; - - _Bvector_impl_data& - operator=(const _Bvector_impl_data&) = default; - - - _Bvector_impl_data(_Bvector_impl_data&& __x) noexcept - : _Bvector_impl_data(__x) - { __x._M_reset(); } - - - void - _M_move_data(_Bvector_impl_data&& __x) noexcept - { - *this = __x; - __x._M_reset(); - } - - - - void - _M_reset() noexcept - { *this = _Bvector_impl_data(); } - - - void - _M_swap_data(_Bvector_impl_data& __x) noexcept - { - - - std::swap(*this, __x); - } - }; - - struct _Bvector_impl - : public _Bit_alloc_type, public _Bvector_impl_data - { - - _Bvector_impl() noexcept(is_nothrow_default_constructible<_Bit_alloc_type>::value) - - : _Bit_alloc_type() - { } - - - _Bvector_impl(const _Bit_alloc_type& __a) noexcept - : _Bit_alloc_type(__a) - { } - - - - - - _Bvector_impl(_Bvector_impl&& __x) noexcept - : _Bit_alloc_type(std::move(__x)), _Bvector_impl_data(std::move(__x)) - { } - - - _Bvector_impl(_Bit_alloc_type&& __a, _Bvector_impl&& __x) noexcept - : _Bit_alloc_type(std::move(__a)), _Bvector_impl_data(std::move(__x)) - { } - - - - _Bit_type* - _M_end_addr() const noexcept - { - if (this->_M_end_of_storage) - return std::__addressof(this->_M_end_of_storage[-1]) + 1; - return 0; - } - }; - - public: - typedef _Alloc allocator_type; - - - _Bit_alloc_type& - _M_get_Bit_allocator() noexcept - { return this->_M_impl; } - - - const _Bit_alloc_type& - _M_get_Bit_allocator() const noexcept - { return this->_M_impl; } - - - allocator_type - get_allocator() const noexcept - { return allocator_type(_M_get_Bit_allocator()); } - - - _Bvector_base() = default; - - - - - - _Bvector_base(const allocator_type& __a) - : _M_impl(__a) { } - - - _Bvector_base(_Bvector_base&&) = default; - - - _Bvector_base(_Bvector_base&& __x, const allocator_type& __a) noexcept - : _M_impl(_Bit_alloc_type(__a), std::move(__x._M_impl)) - { } - - - - ~_Bvector_base() - { this->_M_deallocate(); } - - protected: - _Bvector_impl _M_impl; - - - _Bit_pointer - _M_allocate(size_t __n) - { - _Bit_pointer __p = _Bit_alloc_traits::allocate(_M_impl, _S_nword(__n)); -# 652 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - return __p; - } - - - void - _M_deallocate() - { - if (_M_impl._M_start._M_p) - { - const size_t __n = _M_impl._M_end_addr() - _M_impl._M_start._M_p; - _Bit_alloc_traits::deallocate(_M_impl, - _M_impl._M_end_of_storage - __n, - __n); - _M_impl._M_reset(); - } - } - - - - void - _M_move_data(_Bvector_base&& __x) noexcept - { _M_impl._M_move_data(std::move(__x._M_impl)); } - - - constexpr - static size_t - _S_nword(size_t __n) - { return (__n + int(_S_word_bit) - 1) / int(_S_word_bit); } - }; -# 703 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - template - class vector : protected _Bvector_base<_Alloc> - { - typedef _Bvector_base<_Alloc> _Base; - typedef typename _Base::_Bit_pointer _Bit_pointer; - typedef typename _Base::_Bit_alloc_traits _Bit_alloc_traits; - - - friend struct std::hash; - - - public: - typedef bool value_type; - typedef size_t size_type; - typedef ptrdiff_t difference_type; - typedef _Bit_reference reference; - typedef bool const_reference; - typedef _Bit_reference* pointer; - typedef const bool* const_pointer; - typedef _Bit_iterator iterator; - typedef _Bit_const_iterator const_iterator; - typedef std::reverse_iterator const_reverse_iterator; - typedef std::reverse_iterator reverse_iterator; - typedef _Alloc allocator_type; - - - allocator_type - get_allocator() const - { return _Base::get_allocator(); } - - protected: - using _Base::_M_allocate; - using _Base::_M_deallocate; - using _Base::_S_nword; - using _Base::_M_get_Bit_allocator; - - public: - - vector() = default; - - - - - - explicit - vector(const allocator_type& __a) - : _Base(__a) { } - - - - explicit - vector(size_type __n, const allocator_type& __a = allocator_type()) - : vector(__n, false, __a) - { } - - - vector(size_type __n, const bool& __value, - const allocator_type& __a = allocator_type()) - - - - - - : _Base(__a) - { - _M_initialize(__n); - _M_initialize_value(__value); - } - - - vector(const vector& __x) - : _Base(_Bit_alloc_traits::_S_select_on_copy(__x._M_get_Bit_allocator())) - { - const_iterator __xbegin = __x.begin(), __xend = __x.end(); - _M_initialize(__x.size()); - _M_copy_aligned(__xbegin, __xend, begin()); - } - - - vector(vector&&) = default; - - private: - - vector(vector&& __x, const allocator_type& __a, true_type) noexcept - : _Base(std::move(__x), __a) - { } - - - vector(vector&& __x, const allocator_type& __a, false_type) - : _Base(__a) - { - if (__x.get_allocator() == __a) - this->_M_move_data(std::move(__x)); - else - { - _M_initialize(__x.size()); - _M_copy_aligned(__x.begin(), __x.end(), begin()); - __x.clear(); - } - } - - public: - - vector(vector&& __x, const __type_identity_t& __a) - noexcept(_Bit_alloc_traits::_S_always_equal()) - : vector(std::move(__x), __a, - typename _Bit_alloc_traits::is_always_equal{}) - { } - - - vector(const vector& __x, const __type_identity_t& __a) - : _Base(__a) - { - _M_initialize(__x.size()); - _M_copy_aligned(__x.begin(), __x.end(), begin()); - } - - - vector(initializer_list __l, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { - _M_initialize_range(__l.begin(), __l.end(), - random_access_iterator_tag()); - } - - - - template> - - vector(_InputIterator __first, _InputIterator __last, - const allocator_type& __a = allocator_type()) - : _Base(__a) - { - _M_initialize_range(__first, __last, - std::__iterator_category(__first)); - } -# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - ~vector() noexcept { } - - - vector& - operator=(const vector& __x) - { - if (&__x == this) - return *this; - - if (_Bit_alloc_traits::_S_propagate_on_copy_assign()) - { - if (this->_M_get_Bit_allocator() != __x._M_get_Bit_allocator()) - { - this->_M_deallocate(); - std::__alloc_on_copy(_M_get_Bit_allocator(), - __x._M_get_Bit_allocator()); - _M_initialize(__x.size()); - } - else - std::__alloc_on_copy(_M_get_Bit_allocator(), - __x._M_get_Bit_allocator()); - } - - if (__x.size() > capacity()) - { - this->_M_deallocate(); - _M_initialize(__x.size()); - } - this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), - begin()); - return *this; - } - - - - vector& - operator=(vector&& __x) noexcept(_Bit_alloc_traits::_S_nothrow_move()) - { - if (_Bit_alloc_traits::_S_propagate_on_move_assign() - || this->_M_get_Bit_allocator() == __x._M_get_Bit_allocator()) - { - this->_M_deallocate(); - this->_M_move_data(std::move(__x)); - std::__alloc_on_move(_M_get_Bit_allocator(), - __x._M_get_Bit_allocator()); - } - else - { - if (__x.size() > capacity()) - { - this->_M_deallocate(); - _M_initialize(__x.size()); - } - this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), - begin()); - __x.clear(); - } - return *this; - } - - - vector& - operator=(initializer_list __l) - { - this->assign(__l.begin(), __l.end()); - return *this; - } - - - - - - - - void - assign(size_type __n, const bool& __x) - { _M_fill_assign(__n, __x); } - - - template> - - void - assign(_InputIterator __first, _InputIterator __last) - { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } -# 952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - void - assign(initializer_list __l) - { _M_assign_aux(__l.begin(), __l.end(), random_access_iterator_tag()); } - - - [[__nodiscard__]] - iterator - begin() noexcept - { return iterator(this->_M_impl._M_start._M_p, 0); } - - [[__nodiscard__]] - const_iterator - begin() const noexcept - { return const_iterator(this->_M_impl._M_start._M_p, 0); } - - [[__nodiscard__]] - iterator - end() noexcept - { return this->_M_impl._M_finish; } - - [[__nodiscard__]] - const_iterator - end() const noexcept - { return this->_M_impl._M_finish; } - - [[__nodiscard__]] - reverse_iterator - rbegin() noexcept - { return reverse_iterator(end()); } - - [[__nodiscard__]] - const_reverse_iterator - rbegin() const noexcept - { return const_reverse_iterator(end()); } - - [[__nodiscard__]] - reverse_iterator - rend() noexcept - { return reverse_iterator(begin()); } - - [[__nodiscard__]] - const_reverse_iterator - rend() const noexcept - { return const_reverse_iterator(begin()); } - - - [[__nodiscard__]] - const_iterator - cbegin() const noexcept - { return const_iterator(this->_M_impl._M_start._M_p, 0); } - - [[__nodiscard__]] - const_iterator - cend() const noexcept - { return this->_M_impl._M_finish; } - - [[__nodiscard__]] - const_reverse_iterator - crbegin() const noexcept - { return const_reverse_iterator(end()); } - - [[__nodiscard__]] - const_reverse_iterator - crend() const noexcept - { return const_reverse_iterator(begin()); } - - - [[__nodiscard__]] - size_type - size() const noexcept - { return size_type(end() - begin()); } - - [[__nodiscard__]] - size_type - max_size() const noexcept - { - const size_type __isize = - __gnu_cxx::__numeric_traits::__max - - int(_S_word_bit) + 1; - const size_type __asize - = _Bit_alloc_traits::max_size(_M_get_Bit_allocator()); - return (__asize <= __isize / int(_S_word_bit) - ? __asize * int(_S_word_bit) : __isize); - } - - [[__nodiscard__]] - size_type - capacity() const noexcept - { return size_type(const_iterator(this->_M_impl._M_end_addr(), 0) - - begin()); } - - [[__nodiscard__]] - bool - empty() const noexcept - { return begin() == end(); } - - [[__nodiscard__]] - reference - operator[](size_type __n) - { return begin()[__n]; } - - [[__nodiscard__]] - const_reference - operator[](size_type __n) const - { return begin()[__n]; } - - protected: - - void - _M_range_check(size_type __n) const - { - if (__n >= this->size()) - __throw_out_of_range_fmt(("vector::_M_range_check: __n " "(which is %zu) >= this->size() " "(which is %zu)"), - - - __n, this->size()); - } - - public: - - reference - at(size_type __n) - { - _M_range_check(__n); - return (*this)[__n]; - } - - - const_reference - at(size_type __n) const - { - _M_range_check(__n); - return (*this)[__n]; - } - - - void - reserve(size_type __n) - { - if (__n > max_size()) - __throw_length_error(("vector::reserve")); - if (capacity() < __n) - _M_reallocate(__n); - } - - [[__nodiscard__]] - reference - front() - { return *begin(); } - - [[__nodiscard__]] - const_reference - front() const - { return *begin(); } - - [[__nodiscard__]] - reference - back() - { return *(end() - 1); } - - [[__nodiscard__]] - const_reference - back() const - { return *(end() - 1); } - - - void - push_back(bool __x) - { - if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) - *this->_M_impl._M_finish++ = __x; - else - _M_insert_aux(end(), __x); - } - - - void - swap(vector& __x) noexcept - { - - do { if (std::__is_constant_evaluated() && !bool(_Bit_alloc_traits::propagate_on_container_swap::value || _M_get_Bit_allocator() == __x._M_get_Bit_allocator())) __builtin_unreachable(); } while (false); - - - this->_M_impl._M_swap_data(__x._M_impl); - _Bit_alloc_traits::_S_on_swap(_M_get_Bit_allocator(), - __x._M_get_Bit_allocator()); - } - - - - static void - swap(reference __x, reference __y) noexcept - { - bool __tmp = __x; - __x = __y; - __y = __tmp; - } - - - iterator - - insert(const_iterator __position, const bool& __x) - - - - { - const difference_type __n = __position - begin(); - if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr() - && __position == end()) - *this->_M_impl._M_finish++ = __x; - else - _M_insert_aux(__position._M_const_cast(), __x); - return begin() + __n; - } - - - __attribute__ ((__deprecated__ ("use '" "insert(position, false)" "' instead"))) - iterator - insert(const_iterator __position) - { return this->insert(__position._M_const_cast(), false); } - - - - template> - - iterator - insert(const_iterator __position, - _InputIterator __first, _InputIterator __last) - { - difference_type __offset = __position - cbegin(); - _M_insert_range(__position._M_const_cast(), - __first, __last, - std::__iterator_category(__first)); - return begin() + __offset; - } -# 1202 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - iterator - insert(const_iterator __position, size_type __n, const bool& __x) - { - difference_type __offset = __position - cbegin(); - _M_fill_insert(__position._M_const_cast(), __n, __x); - return begin() + __offset; - } -# 1217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - iterator - insert(const_iterator __p, initializer_list __l) - { return this->insert(__p, __l.begin(), __l.end()); } - - - - void - pop_back() - { --this->_M_impl._M_finish; } - - - iterator - - erase(const_iterator __position) - - - - { return _M_erase(__position._M_const_cast()); } - - - iterator - - erase(const_iterator __first, const_iterator __last) - - - - { return _M_erase(__first._M_const_cast(), __last._M_const_cast()); } - - - void - resize(size_type __new_size, bool __x = bool()) - { - if (__new_size < size()) - _M_erase_at_end(begin() + difference_type(__new_size)); - else - insert(end(), __new_size - size(), __x); - } - - - - void - shrink_to_fit() - { _M_shrink_to_fit(); } - - - - void - flip() noexcept - { - _Bit_type * const __end = this->_M_impl._M_end_addr(); - for (_Bit_type * __p = this->_M_impl._M_start._M_p; __p != __end; ++__p) - *__p = ~*__p; - } - - - void - clear() noexcept - { _M_erase_at_end(begin()); } - - - template - - - reference - - - - emplace_back(_Args&&... __args) - { - push_back(bool(__args...)); - - return back(); - - } - - template - - iterator - emplace(const_iterator __pos, _Args&&... __args) - { return insert(__pos, bool(__args...)); } - - - protected: - - - iterator - _M_copy_aligned(const_iterator __first, const_iterator __last, - iterator __result) - { - _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p); - return std::copy(const_iterator(__last._M_p, 0), __last, - iterator(__q, 0)); - } - - - void - _M_initialize(size_type __n) - { - if (__n) - { - _Bit_pointer __q = this->_M_allocate(__n); - this->_M_impl._M_end_of_storage = __q + _S_nword(__n); - iterator __start = iterator(std::__addressof(*__q), 0); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __start + difference_type(__n); - } - } - - - void - _M_initialize_value(bool __x) noexcept - { - if (_Bit_type* __p = this->_M_impl._M_start._M_p) - __fill_bvector_n(__p, this->_M_impl._M_end_addr() - __p, __x); - } - - - void - _M_reallocate(size_type __n); - - - - bool - _M_shrink_to_fit(); -# 1362 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - template - - void - _M_initialize_range(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag) - { - for (; __first != __last; ++__first) - push_back(*__first); - } - - template - - void - _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag) - { - const size_type __n = std::distance(__first, __last); - _M_initialize(__n); - std::copy(__first, __last, begin()); - } -# 1399 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - void - _M_fill_assign(size_t __n, bool __x) - { - if (__n > size()) - { - _M_initialize_value(__x); - insert(end(), __n - size(), __x); - } - else - { - _M_erase_at_end(begin() + __n); - _M_initialize_value(__x); - } - } - - template - - void - _M_assign_aux(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag) - { - iterator __cur = begin(); - for (; __first != __last && __cur != end(); ++__cur, (void)++__first) - *__cur = *__first; - if (__first == __last) - _M_erase_at_end(__cur); - else - insert(end(), __first, __last); - } - - template - - void - _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag) - { - const size_type __len = std::distance(__first, __last); - if (__len < size()) - _M_erase_at_end(std::copy(__first, __last, begin())); - else - { - _ForwardIterator __mid = __first; - std::advance(__mid, size()); - std::copy(__first, __mid, begin()); - insert(end(), __mid, __last); - } - } -# 1466 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - void - _M_fill_insert(iterator __position, size_type __n, bool __x); - - template - - void - _M_insert_range(iterator __pos, _InputIterator __first, - _InputIterator __last, std::input_iterator_tag) - { - for (; __first != __last; ++__first) - { - __pos = insert(__pos, *__first); - ++__pos; - } - } - - template - - void - _M_insert_range(iterator __position, _ForwardIterator __first, - _ForwardIterator __last, std::forward_iterator_tag); - - - void - _M_insert_aux(iterator __position, bool __x); - - - size_type - _M_check_len(size_type __n, const char* __s) const - { - if (max_size() - size() < __n) - __throw_length_error((__s)); - - const size_type __len = size() + std::max(size(), __n); - return (__len < size() || __len > max_size()) ? max_size() : __len; - } - - - void - _M_erase_at_end(iterator __pos) - { this->_M_impl._M_finish = __pos; } - - - iterator - _M_erase(iterator __pos); - - - iterator - _M_erase(iterator __first, iterator __last); - - protected: - - - - - - - void data() = delete; - - - - }; - - - - - - inline void - __fill_bvector(_Bit_type* __v, unsigned int __first, unsigned int __last, - bool __x) noexcept - { - const _Bit_type __fmask = ~0ul << __first; - const _Bit_type __lmask = ~0ul >> (_S_word_bit - __last); - const _Bit_type __mask = __fmask & __lmask; - - if (__x) - *__v |= __mask; - else - *__v &= ~__mask; - } - - - __attribute__((__nonnull__)) - - inline void - __fill_bvector_n(_Bit_type* __p, size_t __n, bool __x) noexcept - { -# 1561 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_bvector.h" 3 - __builtin_memset(__p, __x ? ~0 : 0, __n * sizeof(_Bit_type)); - } - - - - inline void - __fill_a1(std::_Bit_iterator __first, - std::_Bit_iterator __last, const bool& __x) - { - if (__first._M_p != __last._M_p) - { - _Bit_type* __first_p = __first._M_p; - if (__first._M_offset != 0) - __fill_bvector(__first_p++, __first._M_offset, _S_word_bit, __x); - - __fill_bvector_n(__first_p, __last._M_p - __first_p, __x); - - if (__last._M_offset != 0) - __fill_bvector(__last._M_p, 0, __last._M_offset, __x); - } - else if (__first._M_offset != __last._M_offset) - __fill_bvector(__first._M_p, __first._M_offset, __last._M_offset, __x); - } - - - - - template - struct hash> - : public __hash_base> - { - size_t - operator()(const std::vector&) const noexcept; - }; - - - -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 - - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 53 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 - template::type> - constexpr _Up&& - __invfwd(typename remove_reference<_Tp>::type& __t) noexcept - { return static_cast<_Up&&>(__t); } - - template - constexpr _Res - __invoke_impl(__invoke_other, _Fn&& __f, _Args&&... __args) - { return std::forward<_Fn>(__f)(std::forward<_Args>(__args)...); } - - template - constexpr _Res - __invoke_impl(__invoke_memfun_ref, _MemFun&& __f, _Tp&& __t, - _Args&&... __args) - { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); } - - template - constexpr _Res - __invoke_impl(__invoke_memfun_deref, _MemFun&& __f, _Tp&& __t, - _Args&&... __args) - { - return ((*std::forward<_Tp>(__t)).*__f)(std::forward<_Args>(__args)...); - } - - template - constexpr _Res - __invoke_impl(__invoke_memobj_ref, _MemPtr&& __f, _Tp&& __t) - { return __invfwd<_Tp>(__t).*__f; } - - template - constexpr _Res - __invoke_impl(__invoke_memobj_deref, _MemPtr&& __f, _Tp&& __t) - { return (*std::forward<_Tp>(__t)).*__f; } - - - template - constexpr typename __invoke_result<_Callable, _Args...>::type - __invoke(_Callable&& __fn, _Args&&... __args) - noexcept(__is_nothrow_invocable<_Callable, _Args...>::value) - { - using __result = __invoke_result<_Callable, _Args...>; - using __type = typename __result::type; - using __tag = typename __result::__invoke_type; - return std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - } - - - - template - constexpr enable_if_t, _Res> - __invoke_r(_Callable&& __fn, _Args&&... __args) - noexcept(is_nothrow_invocable_r_v<_Res, _Callable, _Args...>) - { - using __result = __invoke_result<_Callable, _Args...>; - using __type = typename __result::type; - using __tag = typename __result::__invoke_type; - if constexpr (is_void_v<_Res>) - std::__invoke_impl<__type>(__tag{}, std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - else - return std::__invoke_impl<__type>(__tag{}, - std::forward<_Callable>(__fn), - std::forward<_Args>(__args)...); - } -# 156 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/invoke.h" 3 -} -# 39 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 116 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct unary_function - { - - typedef _Arg argument_type; - - - typedef _Result result_type; - } __attribute__ ((__deprecated__)); - - - - - - template - struct binary_function - { - - typedef _Arg1 first_argument_type; - - - typedef _Arg2 second_argument_type; - - - typedef _Result result_type; - } __attribute__ ((__deprecated__)); -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - struct __is_transparent; - - template - struct plus; - - template - struct minus; - - template - struct multiplies; - - template - struct divides; - - template - struct modulus; - - template - struct negate; - - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct plus : public binary_function<_Tp, _Tp, _Tp> - { - - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x + __y; } - }; - - - template - struct minus : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x - __y; } - }; - - - template - struct multiplies : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x * __y; } - }; - - - template - struct divides : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x / __y; } - }; - - - template - struct modulus : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x % __y; } - }; - - - template - struct negate : public unary_function<_Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x) const - { return -__x; } - }; -#pragma GCC diagnostic pop - - - - - - template<> - struct plus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct minus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct multiplies - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct divides - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct modulus - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct negate - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(-std::forward<_Tp>(__t))) - -> decltype(-std::forward<_Tp>(__t)) - { return -std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; -# 349 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct equal_to; - - template - struct not_equal_to; - - template - struct greater; - - template - struct less; - - template - struct greater_equal; - - template - struct less_equal; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct equal_to : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x == __y; } - }; - - - template - struct not_equal_to : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x != __y; } - }; - - - template - struct greater : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x > __y; } - }; - - - template - struct less : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x < __y; } - }; - - - template - struct greater_equal : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x >= __y; } - }; - - - template - struct less_equal : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x <= __y; } - }; - - - template - struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x > __y; - - return (long unsigned int)__x > (long unsigned int)__y; - } - }; - - - template - struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x < __y; - - return (long unsigned int)__x < (long unsigned int)__y; - } - }; - - - template - struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x >= __y; - - return (long unsigned int)__x >= (long unsigned int)__y; - } - }; - - - template - struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> - { - constexpr bool - operator()(_Tp* __x, _Tp* __y) const noexcept - { - - if (std::__is_constant_evaluated()) - return __x <= __y; - - return (long unsigned int)__x <= (long unsigned int)__y; - } - }; -#pragma GCC diagnostic pop - - - - template<> - struct equal_to - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct not_equal_to - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct greater - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return greater>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return greater{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct less - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return less>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return less{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct greater_equal - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return greater_equal>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return greater_equal{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; - - - template<> - struct less_equal - { - template - constexpr auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) - { - return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), - __ptr_cmp<_Tp, _Up>{}); - } - - template - constexpr bool - operator()(_Tp* __t, _Up* __u) const noexcept - { return less_equal>{}(__t, __u); } - - typedef __is_transparent is_transparent; - - private: - template - static constexpr decltype(auto) - _S_cmp(_Tp&& __t, _Up&& __u, false_type) - { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } - - template - static constexpr bool - _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept - { - return less_equal{}( - static_cast(std::forward<_Tp>(__t)), - static_cast(std::forward<_Up>(__u))); - } - - - template - struct __not_overloaded2 : true_type { }; - - - template - struct __not_overloaded2<_Tp, _Up, __void_t< - decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> - : false_type { }; - - - template - struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; - - - template - struct __not_overloaded<_Tp, _Up, __void_t< - decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> - : false_type { }; - - template - using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, - is_convertible<_Tp, const volatile void*>, - is_convertible<_Up, const volatile void*>>; - }; -# 781 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - struct logical_and; - - template - struct logical_or; - - template - struct logical_not; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct logical_and : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x && __y; } - }; - - - template - struct logical_or : public binary_function<_Tp, _Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x, const _Tp& __y) const - { return __x || __y; } - }; - - - template - struct logical_not : public unary_function<_Tp, bool> - { - constexpr - bool - operator()(const _Tp& __x) const - { return !__x; } - }; -#pragma GCC diagnostic pop - - - - template<> - struct logical_and - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct logical_or - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - - template<> - struct logical_not - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(!std::forward<_Tp>(__t))) - -> decltype(!std::forward<_Tp>(__t)) - { return !std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; - - - - - template - struct bit_and; - - template - struct bit_or; - - template - struct bit_xor; - - template - struct bit_not; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - - template - struct bit_and : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x & __y; } - }; - - template - struct bit_or : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x | __y; } - }; - - template - struct bit_xor : public binary_function<_Tp, _Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x, const _Tp& __y) const - { return __x ^ __y; } - }; - - template - struct bit_not : public unary_function<_Tp, _Tp> - { - constexpr - _Tp - operator()(const _Tp& __x) const - { return ~__x; } - }; -#pragma GCC diagnostic pop - - - template <> - struct bit_and - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_or - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_xor - { - template - constexpr - auto - operator()(_Tp&& __t, _Up&& __u) const - noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) - -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) - { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } - - typedef __is_transparent is_transparent; - }; - - template <> - struct bit_not - { - template - constexpr - auto - operator()(_Tp&& __t) const - noexcept(noexcept(~std::forward<_Tp>(__t))) - -> decltype(~std::forward<_Tp>(__t)) - { return ~std::forward<_Tp>(__t); } - - typedef __is_transparent is_transparent; - }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class [[__deprecated__]] unary_negate - : public unary_function - { - protected: - _Predicate _M_pred; - - public: - constexpr - explicit - unary_negate(const _Predicate& __x) : _M_pred(__x) { } - - constexpr - bool - operator()(const typename _Predicate::argument_type& __x) const - { return !_M_pred(__x); } - }; - - - template - __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) - constexpr - inline unary_negate<_Predicate> - not1(const _Predicate& __pred) - { return unary_negate<_Predicate>(__pred); } - - - template - class [[__deprecated__]] binary_negate - : public binary_function - { - protected: - _Predicate _M_pred; - - public: - constexpr - explicit - binary_negate(const _Predicate& __x) : _M_pred(__x) { } - - constexpr - bool - operator()(const typename _Predicate::first_argument_type& __x, - const typename _Predicate::second_argument_type& __y) const - { return !_M_pred(__x, __y); } - }; - - - template - __attribute__ ((__deprecated__ ("use '" "std::not_fn" "' instead"))) - constexpr - inline binary_negate<_Predicate> - not2(const _Predicate& __pred) - { return binary_negate<_Predicate>(__pred); } -# 1104 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class pointer_to_unary_function : public unary_function<_Arg, _Result> - { - protected: - _Result (*_M_ptr)(_Arg); - - public: - pointer_to_unary_function() { } - - explicit - pointer_to_unary_function(_Result (*__x)(_Arg)) - : _M_ptr(__x) { } - - _Result - operator()(_Arg __x) const - { return _M_ptr(__x); } - } __attribute__ ((__deprecated__)); - - - template - __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) - inline pointer_to_unary_function<_Arg, _Result> - ptr_fun(_Result (*__x)(_Arg)) - { return pointer_to_unary_function<_Arg, _Result>(__x); } - - - template - class pointer_to_binary_function - : public binary_function<_Arg1, _Arg2, _Result> - { - protected: - _Result (*_M_ptr)(_Arg1, _Arg2); - - public: - pointer_to_binary_function() { } - - explicit - pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) - : _M_ptr(__x) { } - - _Result - operator()(_Arg1 __x, _Arg2 __y) const - { return _M_ptr(__x, __y); } - } __attribute__ ((__deprecated__)); - - - template - __attribute__ ((__deprecated__ ("use '" "std::function" "' instead"))) - inline pointer_to_binary_function<_Arg1, _Arg2, _Result> - ptr_fun(_Result (*__x)(_Arg1, _Arg2)) - { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } - - - template - struct _Identity - : public unary_function<_Tp, _Tp> - { - _Tp& - operator()(_Tp& __x) const - { return __x; } - - const _Tp& - operator()(const _Tp& __x) const - { return __x; } - }; - - - template struct _Identity : _Identity<_Tp> { }; - - template - struct _Select1st - : public unary_function<_Pair, typename _Pair::first_type> - { - typename _Pair::first_type& - operator()(_Pair& __x) const - { return __x.first; } - - const typename _Pair::first_type& - operator()(const _Pair& __x) const - { return __x.first; } - - - template - typename _Pair2::first_type& - operator()(_Pair2& __x) const - { return __x.first; } - - template - const typename _Pair2::first_type& - operator()(const _Pair2& __x) const - { return __x.first; } - - }; - - template - struct _Select2nd - : public unary_function<_Pair, typename _Pair::second_type> - { - typename _Pair::second_type& - operator()(_Pair& __x) const - { return __x.second; } - - const typename _Pair::second_type& - operator()(const _Pair& __x) const - { return __x.second; } - }; -# 1231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 3 - template - class mem_fun_t : public unary_function<_Tp*, _Ret> - { - public: - explicit - mem_fun_t(_Ret (_Tp::*__pf)()) - : _M_f(__pf) { } - - _Ret - operator()(_Tp* __p) const - { return (__p->*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)(); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun_t : public unary_function - { - public: - explicit - const_mem_fun_t(_Ret (_Tp::*__pf)() const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp* __p) const - { return (__p->*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)() const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun_ref_t : public unary_function<_Tp, _Ret> - { - public: - explicit - mem_fun_ref_t(_Ret (_Tp::*__pf)()) - : _M_f(__pf) { } - - _Ret - operator()(_Tp& __r) const - { return (__r.*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)(); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> - { - public: - explicit - const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp& __r) const - { return (__r.*_M_f)(); } - - private: - _Ret (_Tp::*_M_f)() const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> - { - public: - explicit - mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) - : _M_f(__pf) { } - - _Ret - operator()(_Tp* __p, _Arg __x) const - { return (__p->*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun1_t : public binary_function - { - public: - explicit - const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp* __p, _Arg __x) const - { return (__p->*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg) const; - } __attribute__ ((__deprecated__)); - - - template - class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> - { - public: - explicit - mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) - : _M_f(__pf) { } - - _Ret - operator()(_Tp& __r, _Arg __x) const - { return (__r.*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg); - } __attribute__ ((__deprecated__)); - - - template - class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> - { - public: - explicit - const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) - : _M_f(__pf) { } - - _Ret - operator()(const _Tp& __r, _Arg __x) const - { return (__r.*_M_f)(__x); } - - private: - _Ret (_Tp::*_M_f)(_Arg) const; - } __attribute__ ((__deprecated__)); - - - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun_t<_Ret, _Tp> - mem_fun(_Ret (_Tp::*__f)()) - { return mem_fun_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun_t<_Ret, _Tp> - mem_fun(_Ret (_Tp::*__f)() const) - { return const_mem_fun_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun_ref_t<_Ret, _Tp> - mem_fun_ref(_Ret (_Tp::*__f)()) - { return mem_fun_ref_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun_ref_t<_Ret, _Tp> - mem_fun_ref(_Ret (_Tp::*__f)() const) - { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun1_t<_Ret, _Tp, _Arg> - mem_fun(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun1_t<_Ret, _Tp, _Arg> - mem_fun(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline mem_fun1_ref_t<_Ret, _Tp, _Arg> - mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } - - template - __attribute__ ((__deprecated__ ("use '" "std::mem_fn" "' instead"))) - inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> - mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } -#pragma GCC diagnostic pop - - - - - template> - struct __has_is_transparent - { }; - - template - struct __has_is_transparent<_Func, _SfinaeType, - __void_t> - { typedef void type; }; - - template - using __has_is_transparent_t - = typename __has_is_transparent<_Func, _SfinaeType>::type; - - - -} - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 1 3 -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 107 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/backward/binders.h" 3 - template - class binder1st - : public unary_function - { - protected: - _Operation op; - typename _Operation::first_argument_type value; - - public: - binder1st(const _Operation& __x, - const typename _Operation::first_argument_type& __y) - : op(__x), value(__y) { } - - typename _Operation::result_type - operator()(const typename _Operation::second_argument_type& __x) const - { return op(value, __x); } - - - - typename _Operation::result_type - operator()(typename _Operation::second_argument_type& __x) const - { return op(value, __x); } - } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); - - - template - __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) - inline binder1st<_Operation> - bind1st(const _Operation& __fn, const _Tp& __x) - { - typedef typename _Operation::first_argument_type _Arg1_type; - return binder1st<_Operation>(__fn, _Arg1_type(__x)); - } - - - template - class binder2nd - : public unary_function - { - protected: - _Operation op; - typename _Operation::second_argument_type value; - - public: - binder2nd(const _Operation& __x, - const typename _Operation::second_argument_type& __y) - : op(__x), value(__y) { } - - typename _Operation::result_type - operator()(const typename _Operation::first_argument_type& __x) const - { return op(__x, value); } - - - - typename _Operation::result_type - operator()(typename _Operation::first_argument_type& __x) const - { return op(__x, value); } - } __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))); - - - template - __attribute__ ((__deprecated__ ("use '" "std::bind" "' instead"))) - inline binder2nd<_Operation> - bind2nd(const _Operation& __fn, const _Tp& __x) - { - typedef typename _Operation::second_argument_type _Arg2_type; - return binder2nd<_Operation>(__fn, _Arg2_type(__x)); - } - - - -} - -#pragma GCC diagnostic pop -# 1439 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_function.h" 2 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 52 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 - template - struct _Maybe_unary_or_binary_function { }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct _Maybe_unary_or_binary_function<_Res, _T1> - : std::unary_function<_T1, _Res> { }; - - - template - struct _Maybe_unary_or_binary_function<_Res, _T1, _T2> - : std::binary_function<_T1, _T2, _Res> { }; - -#pragma GCC diagnostic pop - - template - struct _Mem_fn_traits; - - template - struct _Mem_fn_traits_base - { - using __result_type = _Res; - using __maybe_type - = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>; - using __arity = integral_constant; - }; -# 103 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/refwrap.h" 3 -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) > : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const > : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile > : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile > : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) &&> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const &&> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile &&> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile &&> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; - - -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) & noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const & noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile & noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile & noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; -template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) && noexcept> : _Mem_fn_traits_base<_Res, _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const && noexcept> : _Mem_fn_traits_base<_Res, const _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) volatile && noexcept> : _Mem_fn_traits_base<_Res, volatile _Class, _ArgTypes...> { using __vararg = true_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = false_type; }; template struct _Mem_fn_traits<_Res (_Class::*)(_ArgTypes... ...) const volatile && noexcept> : _Mem_fn_traits_base<_Res, const volatile _Class, _ArgTypes...> { using __vararg = true_type; }; - - - - - - - template> - struct _Maybe_get_result_type - { }; - - template - struct _Maybe_get_result_type<_Functor, - __void_t> - { typedef typename _Functor::result_type result_type; }; - - - - - - template - struct _Weak_result_type_impl - : _Maybe_get_result_type<_Functor> - { }; - - - template - struct _Weak_result_type_impl<_Res(_ArgTypes...) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct _Weak_result_type_impl<_Res(_ArgTypes......) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct _Weak_result_type_impl<_Res(*)(_ArgTypes...) noexcept (_NE)> - { typedef _Res result_type; }; - - - template - struct - _Weak_result_type_impl<_Res(*)(_ArgTypes......) noexcept (_NE)> - { typedef _Res result_type; }; - - - template::value> - struct _Weak_result_type_memfun - : _Weak_result_type_impl<_Functor> - { }; - - - template - struct _Weak_result_type_memfun<_MemFunPtr, true> - { - using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; - }; - - - template - struct _Weak_result_type_memfun<_Func _Class::*, false> - { }; - - - - - - template - struct _Weak_result_type - : _Weak_result_type_memfun::type> - { }; - - - - template> - struct _Refwrap_base_arg1 - { }; - - - template - struct _Refwrap_base_arg1<_Tp, - __void_t> - { - typedef typename _Tp::argument_type argument_type; - }; - - - template> - struct _Refwrap_base_arg2 - { }; - - - template - struct _Refwrap_base_arg2<_Tp, - __void_t> - { - typedef typename _Tp::first_argument_type first_argument_type; - typedef typename _Tp::second_argument_type second_argument_type; - }; - - - - - - - - template - struct _Reference_wrapper_base - : _Weak_result_type<_Tp>, _Refwrap_base_arg1<_Tp>, _Refwrap_base_arg2<_Tp> - { }; - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - - template - struct _Reference_wrapper_base<_Res(_T1) noexcept (_NE)> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) volatile> - : unary_function<_T1, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1) const volatile> - : unary_function<_T1, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) noexcept (_NE)> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> - : binary_function<_T1, _T2, _Res> - { }; - - template - struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> - : binary_function<_T1, _T2, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(*)(_T1) noexcept (_NE)> - : unary_function<_T1, _Res> - { }; - - - template - struct _Reference_wrapper_base<_Res(*)(_T1, _T2) noexcept (_NE)> - : binary_function<_T1, _T2, _Res> - { }; - - template::value> - struct _Reference_wrapper_base_memfun - : _Reference_wrapper_base<_Tp> - { }; - - template - struct _Reference_wrapper_base_memfun<_MemFunPtr, true> - : _Mem_fn_traits<_MemFunPtr>::__maybe_type - { - using result_type = typename _Mem_fn_traits<_MemFunPtr>::__result_type; - }; -#pragma GCC diagnostic pop - - - - - - - - - template - class reference_wrapper - - - - : public _Reference_wrapper_base_memfun::type> - - { - _Tp* _M_data; - - - static _Tp* _S_fun(_Tp& __r) noexcept { return std::__addressof(__r); } - - static void _S_fun(_Tp&&) = delete; - - template> - using __not_same - = typename enable_if::value>::type; - - public: - typedef _Tp type; - - - - - template, typename - = decltype(reference_wrapper::_S_fun(std::declval<_Up>()))> - - reference_wrapper(_Up&& __uref) - noexcept(noexcept(reference_wrapper::_S_fun(std::declval<_Up>()))) - : _M_data(reference_wrapper::_S_fun(std::forward<_Up>(__uref))) - { } - - reference_wrapper(const reference_wrapper&) = default; - - reference_wrapper& - operator=(const reference_wrapper&) = default; - - - operator _Tp&() const noexcept - { return this->get(); } - - - _Tp& - get() const noexcept - { return *_M_data; } - - template - - typename __invoke_result<_Tp&, _Args...>::type - operator()(_Args&&... __args) const - noexcept(__is_nothrow_invocable<_Tp&, _Args...>::value) - { - - - - - return std::__invoke(get(), std::forward<_Args>(__args)...); - } - }; - - - template - reference_wrapper(_Tp&) -> reference_wrapper<_Tp>; - - - - - - template - - inline reference_wrapper<_Tp> - ref(_Tp& __t) noexcept - { return reference_wrapper<_Tp>(__t); } - - - template - - inline reference_wrapper - cref(const _Tp& __t) noexcept - { return reference_wrapper(__t); } - - template - void ref(const _Tp&&) = delete; - - template - void cref(const _Tp&&) = delete; - - - template - - inline reference_wrapper<_Tp> - ref(reference_wrapper<_Tp> __t) noexcept - { return __t; } - - - template - - inline reference_wrapper - cref(reference_wrapper<_Tp> __t) noexcept - { return { __t.get() }; } - - - - -} -# 69 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/vector.tcc" 1 3 -# 59 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/vector.tcc" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - - void - vector<_Tp, _Alloc>:: - reserve(size_type __n) - { - if (__n > this->max_size()) - __throw_length_error(("vector::reserve")); - if (this->capacity() < __n) - { - const size_type __old_size = size(); - pointer __tmp; - - if constexpr (_S_use_relocate()) - { - __tmp = this->_M_allocate(__n); - _S_relocate(this->_M_impl._M_start, this->_M_impl._M_finish, - __tmp, _M_get_Tp_allocator()); - } - else - - { - __tmp = _M_allocate_and_copy(__n, - std::__make_move_if_noexcept_iterator(this->_M_impl._M_start), - std::__make_move_if_noexcept_iterator(this->_M_impl._M_finish)); - std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - } - ; - _M_deallocate(this->_M_impl._M_start, - this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); - this->_M_impl._M_start = __tmp; - this->_M_impl._M_finish = __tmp + __old_size; - this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; - } - } - - - template - template - - - typename vector<_Tp, _Alloc>::reference - - - - vector<_Tp, _Alloc>:: - emplace_back(_Args&&... __args) - { - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - std::forward<_Args>(__args)...); - ++this->_M_impl._M_finish; - ; - } - else - _M_realloc_insert(end(), std::forward<_Args>(__args)...); - - return back(); - - } - - - template - - typename vector<_Tp, _Alloc>::iterator - vector<_Tp, _Alloc>:: - - insert(const_iterator __position, const value_type& __x) - - - - { - const size_type __n = __position - begin(); - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - { - do { if (std::__is_constant_evaluated() && !bool(__position != const_iterator())) __builtin_unreachable(); } while (false); - if (!(__position != const_iterator())) - __builtin_unreachable(); - - if (__position == end()) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - __x); - ++this->_M_impl._M_finish; - ; - } - else - { - - const auto __pos = begin() + (__position - cbegin()); - - - _Temporary_value __x_copy(this, __x); - _M_insert_aux(__pos, std::move(__x_copy._M_val())); - - - - } - } - else - - _M_realloc_insert(begin() + (__position - cbegin()), __x); - - - - - return iterator(this->_M_impl._M_start + __n); - } - - template - - typename vector<_Tp, _Alloc>::iterator - vector<_Tp, _Alloc>:: - _M_erase(iterator __position) - { - if (__position + 1 != end()) - std::move(__position + 1, end(), __position); - --this->_M_impl._M_finish; - _Alloc_traits::destroy(this->_M_impl, this->_M_impl._M_finish); - ; - return __position; - } - - template - - typename vector<_Tp, _Alloc>::iterator - vector<_Tp, _Alloc>:: - _M_erase(iterator __first, iterator __last) - { - if (__first != __last) - { - if (__last != end()) - std::move(__last, end(), __first); - _M_erase_at_end(__first.base() + (end() - __last)); - } - return __first; - } - - template - - vector<_Tp, _Alloc>& - vector<_Tp, _Alloc>:: - operator=(const vector<_Tp, _Alloc>& __x) - { - if (std::__addressof(__x) != this) - { - ; - - if (_Alloc_traits::_S_propagate_on_copy_assign()) - { - if (!_Alloc_traits::_S_always_equal() - && _M_get_Tp_allocator() != __x._M_get_Tp_allocator()) - { - - this->clear(); - _M_deallocate(this->_M_impl._M_start, - this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); - this->_M_impl._M_start = nullptr; - this->_M_impl._M_finish = nullptr; - this->_M_impl._M_end_of_storage = nullptr; - } - std::__alloc_on_copy(_M_get_Tp_allocator(), - __x._M_get_Tp_allocator()); - } - - const size_type __xlen = __x.size(); - if (__xlen > capacity()) - { - pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), - __x.end()); - std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - _M_deallocate(this->_M_impl._M_start, - this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); - this->_M_impl._M_start = __tmp; - this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen; - } - else if (size() >= __xlen) - { - std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), - end(), _M_get_Tp_allocator()); - } - else - { - std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(), - this->_M_impl._M_start); - std::__uninitialized_copy_a(__x._M_impl._M_start + size(), - __x._M_impl._M_finish, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - } - this->_M_impl._M_finish = this->_M_impl._M_start + __xlen; - } - return *this; - } - - template - - void - vector<_Tp, _Alloc>:: - _M_fill_assign(size_t __n, const value_type& __val) - { - if (__n > capacity()) - { - vector __tmp(__n, __val, _M_get_Tp_allocator()); - __tmp._M_impl._M_swap_data(this->_M_impl); - } - else if (__n > size()) - { - std::fill(begin(), end(), __val); - const size_type __add = __n - size(); - ; - this->_M_impl._M_finish = - std::__uninitialized_fill_n_a(this->_M_impl._M_finish, - __add, __val, _M_get_Tp_allocator()); - ; - } - else - _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val)); - } - - template - template - - void - vector<_Tp, _Alloc>:: - _M_assign_aux(_InputIterator __first, _InputIterator __last, - std::input_iterator_tag) - { - pointer __cur(this->_M_impl._M_start); - for (; __first != __last && __cur != this->_M_impl._M_finish; - ++__cur, (void)++__first) - *__cur = *__first; - if (__first == __last) - _M_erase_at_end(__cur); - else - _M_range_insert(end(), __first, __last, - std::__iterator_category(__first)); - } - - template - template - - void - vector<_Tp, _Alloc>:: - _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, - std::forward_iterator_tag) - { - const size_type __len = std::distance(__first, __last); - - if (__len > capacity()) - { - _S_check_init_len(__len, _M_get_Tp_allocator()); - pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); - std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, - _M_get_Tp_allocator()); - ; - _M_deallocate(this->_M_impl._M_start, - this->_M_impl._M_end_of_storage - - this->_M_impl._M_start); - this->_M_impl._M_start = __tmp; - this->_M_impl._M_finish = this->_M_impl._M_start + __len; - this->_M_impl._M_end_of_storage = this->_M_impl._M_finish; - } - else if (size() >= __len) - _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); - else - { - _ForwardIterator __mid = __first; - std::advance(__mid, size()); - std::copy(__first, __mid, this->_M_impl._M_start); - const size_type __attribute__((__unused__)) __n = __len - size(); - ; - this->_M_impl._M_finish = - std::__uninitialized_copy_a(__mid, __last, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - ; - } - } - - - template - - auto - vector<_Tp, _Alloc>:: - _M_insert_rval(const_iterator __position, value_type&& __v) -> iterator - { - const auto __n = __position - cbegin(); - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - if (__position == cend()) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - std::move(__v)); - ++this->_M_impl._M_finish; - ; - } - else - _M_insert_aux(begin() + __n, std::move(__v)); - else - _M_realloc_insert(begin() + __n, std::move(__v)); - - return iterator(this->_M_impl._M_start + __n); - } - - template - template - - auto - vector<_Tp, _Alloc>:: - _M_emplace_aux(const_iterator __position, _Args&&... __args) - -> iterator - { - const auto __n = __position - cbegin(); - if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) - if (__position == cend()) - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - std::forward<_Args>(__args)...); - ++this->_M_impl._M_finish; - ; - } - else - { - - - - _Temporary_value __tmp(this, std::forward<_Args>(__args)...); - _M_insert_aux(begin() + __n, std::move(__tmp._M_val())); - } - else - _M_realloc_insert(begin() + __n, std::forward<_Args>(__args)...); - - return iterator(this->_M_impl._M_start + __n); - } - - template - template - - void - vector<_Tp, _Alloc>:: - _M_insert_aux(iterator __position, _Arg&& __arg) - - - - - - - { - ; - _Alloc_traits::construct(this->_M_impl, this->_M_impl._M_finish, - std::move(*(this->_M_impl._M_finish - 1))); - ++this->_M_impl._M_finish; - ; - - - - std::move_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1); - - - - - - *__position = std::forward<_Arg>(__arg); - - } - - - template - template - - void - vector<_Tp, _Alloc>:: - _M_realloc_insert(iterator __position, _Args&&... __args) - - - - - - - { - const size_type __len = - _M_check_len(size_type(1), "vector::_M_realloc_insert"); - pointer __old_start = this->_M_impl._M_start; - pointer __old_finish = this->_M_impl._M_finish; - const size_type __elems_before = __position - begin(); - pointer __new_start(this->_M_allocate(__len)); - pointer __new_finish(__new_start); - try - { - - - - - - _Alloc_traits::construct(this->_M_impl, - __new_start + __elems_before, - - std::forward<_Args>(__args)...); - - - - __new_finish = pointer(); - - - if constexpr (_S_use_relocate()) - { - __new_finish = _S_relocate(__old_start, __position.base(), - __new_start, _M_get_Tp_allocator()); - - ++__new_finish; - - __new_finish = _S_relocate(__position.base(), __old_finish, - __new_finish, _M_get_Tp_allocator()); - } - else - - { - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__old_start, __position.base(), - __new_start, _M_get_Tp_allocator()); - - ++__new_finish; - - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__position.base(), __old_finish, - __new_finish, _M_get_Tp_allocator()); - } - } - catch(...) - { - if (!__new_finish) - _Alloc_traits::destroy(this->_M_impl, - __new_start + __elems_before); - else - std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); - _M_deallocate(__new_start, __len); - throw; - } - - if constexpr (!_S_use_relocate()) - - std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); - ; - _M_deallocate(__old_start, - this->_M_impl._M_end_of_storage - __old_start); - this->_M_impl._M_start = __new_start; - this->_M_impl._M_finish = __new_finish; - this->_M_impl._M_end_of_storage = __new_start + __len; - } - - template - - void - vector<_Tp, _Alloc>:: - _M_fill_insert(iterator __position, size_type __n, const value_type& __x) - { - if (__n != 0) - { - if (size_type(this->_M_impl._M_end_of_storage - - this->_M_impl._M_finish) >= __n) - { - - - - _Temporary_value __tmp(this, __x); - value_type& __x_copy = __tmp._M_val(); - - const size_type __elems_after = end() - __position; - pointer __old_finish(this->_M_impl._M_finish); - if (__elems_after > __n) - { - ; - std::__uninitialized_move_a(__old_finish - __n, - __old_finish, - __old_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __n; - ; - std::move_backward(__position.base(), __old_finish - __n, __old_finish); - - std::fill(__position.base(), __position.base() + __n, - __x_copy); - } - else - { - ; - this->_M_impl._M_finish = - std::__uninitialized_fill_n_a(__old_finish, - __n - __elems_after, - __x_copy, - _M_get_Tp_allocator()); - ; - std::__uninitialized_move_a(__position.base(), __old_finish, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __elems_after; - ; - std::fill(__position.base(), __old_finish, __x_copy); - } - } - else - { - - - pointer __old_start = this->_M_impl._M_start; - pointer __old_finish = this->_M_impl._M_finish; - const pointer __pos = __position.base(); - - const size_type __len = - _M_check_len(__n, "vector::_M_fill_insert"); - const size_type __elems_before = __pos - __old_start; - pointer __new_start(this->_M_allocate(__len)); - pointer __new_finish(__new_start); - try - { - - std::__uninitialized_fill_n_a(__new_start + __elems_before, - __n, __x, - _M_get_Tp_allocator()); - __new_finish = pointer(); - - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__old_start, __pos, __new_start, _M_get_Tp_allocator()); - - __new_finish += __n; - - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__pos, __old_finish, __new_finish, _M_get_Tp_allocator()); - } - catch(...) - { - if (!__new_finish) - std::_Destroy(__new_start + __elems_before, - __new_start + __elems_before + __n, - _M_get_Tp_allocator()); - else - std::_Destroy(__new_start, __new_finish, - _M_get_Tp_allocator()); - _M_deallocate(__new_start, __len); - throw; - } - std::_Destroy(__old_start, __old_finish, _M_get_Tp_allocator()); - ; - _M_deallocate(__old_start, - this->_M_impl._M_end_of_storage - __old_start); - this->_M_impl._M_start = __new_start; - this->_M_impl._M_finish = __new_finish; - this->_M_impl._M_end_of_storage = __new_start + __len; - } - } - } - - - template - - void - vector<_Tp, _Alloc>:: - _M_default_append(size_type __n) - { - if (__n != 0) - { - const size_type __size = size(); - size_type __navail = size_type(this->_M_impl._M_end_of_storage - - this->_M_impl._M_finish); - - if (__size > max_size() || __navail > max_size() - __size) - __builtin_unreachable(); - - if (__navail >= __n) - { - ; - this->_M_impl._M_finish = - std::__uninitialized_default_n_a(this->_M_impl._M_finish, - __n, _M_get_Tp_allocator()); - ; - } - else - { - - - pointer __old_start = this->_M_impl._M_start; - pointer __old_finish = this->_M_impl._M_finish; - - const size_type __len = - _M_check_len(__n, "vector::_M_default_append"); - pointer __new_start(this->_M_allocate(__len)); - if constexpr (_S_use_relocate()) - { - try - { - std::__uninitialized_default_n_a(__new_start + __size, - __n, _M_get_Tp_allocator()); - } - catch(...) - { - _M_deallocate(__new_start, __len); - throw; - } - _S_relocate(__old_start, __old_finish, - __new_start, _M_get_Tp_allocator()); - } - else - { - pointer __destroy_from = pointer(); - try - { - std::__uninitialized_default_n_a(__new_start + __size, - __n, _M_get_Tp_allocator()); - __destroy_from = __new_start + __size; - std::__uninitialized_move_if_noexcept_a( - __old_start, __old_finish, - __new_start, _M_get_Tp_allocator()); - } - catch(...) - { - if (__destroy_from) - std::_Destroy(__destroy_from, __destroy_from + __n, - _M_get_Tp_allocator()); - _M_deallocate(__new_start, __len); - throw; - } - std::_Destroy(__old_start, __old_finish, - _M_get_Tp_allocator()); - } - ; - _M_deallocate(__old_start, - this->_M_impl._M_end_of_storage - __old_start); - this->_M_impl._M_start = __new_start; - this->_M_impl._M_finish = __new_start + __size + __n; - this->_M_impl._M_end_of_storage = __new_start + __len; - } - } - } - - template - - bool - vector<_Tp, _Alloc>:: - _M_shrink_to_fit() - { - if (capacity() == size()) - return false; - ; - return std::__shrink_to_fit_aux::_S_do_it(*this); - } - - - template - template - - void - vector<_Tp, _Alloc>:: - _M_range_insert(iterator __pos, _InputIterator __first, - _InputIterator __last, std::input_iterator_tag) - { - if (__pos == end()) - { - for (; __first != __last; ++__first) - insert(end(), *__first); - } - else if (__first != __last) - { - vector __tmp(__first, __last, _M_get_Tp_allocator()); - insert(__pos, - std::make_move_iterator(__tmp.begin()), - std::make_move_iterator(__tmp.end())); - } - } - - template - template - - void - vector<_Tp, _Alloc>:: - _M_range_insert(iterator __position, _ForwardIterator __first, - _ForwardIterator __last, std::forward_iterator_tag) - { - if (__first != __last) - { - const size_type __n = std::distance(__first, __last); - if (size_type(this->_M_impl._M_end_of_storage - - this->_M_impl._M_finish) >= __n) - { - const size_type __elems_after = end() - __position; - pointer __old_finish(this->_M_impl._M_finish); - if (__elems_after > __n) - { - ; - std::__uninitialized_move_a(this->_M_impl._M_finish - __n, - this->_M_impl._M_finish, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __n; - ; - std::move_backward(__position.base(), __old_finish - __n, __old_finish); - - std::copy(__first, __last, __position); - } - else - { - _ForwardIterator __mid = __first; - std::advance(__mid, __elems_after); - ; - std::__uninitialized_copy_a(__mid, __last, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __n - __elems_after; - ; - std::__uninitialized_move_a(__position.base(), - __old_finish, - this->_M_impl._M_finish, - _M_get_Tp_allocator()); - this->_M_impl._M_finish += __elems_after; - ; - std::copy(__first, __mid, __position); - } - } - else - { - - - - pointer __old_start = this->_M_impl._M_start; - pointer __old_finish = this->_M_impl._M_finish; - - const size_type __len = - _M_check_len(__n, "vector::_M_range_insert"); - pointer __new_start(this->_M_allocate(__len)); - pointer __new_finish(__new_start); - try - { - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__old_start, __position.base(), - __new_start, _M_get_Tp_allocator()); - __new_finish - = std::__uninitialized_copy_a(__first, __last, - __new_finish, - _M_get_Tp_allocator()); - __new_finish - = std::__uninitialized_move_if_noexcept_a - (__position.base(), __old_finish, - __new_finish, _M_get_Tp_allocator()); - } - catch(...) - { - std::_Destroy(__new_start, __new_finish, - _M_get_Tp_allocator()); - _M_deallocate(__new_start, __len); - throw; - } - std::_Destroy(__old_start, __old_finish, - _M_get_Tp_allocator()); - ; - _M_deallocate(__old_start, - this->_M_impl._M_end_of_storage - __old_start); - this->_M_impl._M_start = __new_start; - this->_M_impl._M_finish = __new_finish; - this->_M_impl._M_end_of_storage = __new_start + __len; - } - } - } - - - - template - - void - vector:: - _M_reallocate(size_type __n) - { - _Bit_pointer __q = this->_M_allocate(__n); - iterator __start(std::__addressof(*__q), 0); - iterator __finish(_M_copy_aligned(begin(), end(), __start)); - this->_M_deallocate(); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __finish; - this->_M_impl._M_end_of_storage = __q + _S_nword(__n); - } - - template - - void - vector:: - _M_fill_insert(iterator __position, size_type __n, bool __x) - { - if (__n == 0) - return; - if (capacity() - size() >= __n) - { - std::copy_backward(__position, end(), - this->_M_impl._M_finish + difference_type(__n)); - std::fill(__position, __position + difference_type(__n), __x); - this->_M_impl._M_finish += difference_type(__n); - } - else - { - const size_type __len = - _M_check_len(__n, "vector::_M_fill_insert"); - _Bit_pointer __q = this->_M_allocate(__len); - iterator __start(std::__addressof(*__q), 0); - iterator __i = _M_copy_aligned(begin(), __position, __start); - std::fill(__i, __i + difference_type(__n), __x); - iterator __finish = std::copy(__position, end(), - __i + difference_type(__n)); - this->_M_deallocate(); - this->_M_impl._M_end_of_storage = __q + _S_nword(__len); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __finish; - } - } - - template - template - - void - vector:: - _M_insert_range(iterator __position, _ForwardIterator __first, - _ForwardIterator __last, std::forward_iterator_tag) - { - if (__first != __last) - { - size_type __n = std::distance(__first, __last); - if (capacity() - size() >= __n) - { - std::copy_backward(__position, end(), - this->_M_impl._M_finish - + difference_type(__n)); - std::copy(__first, __last, __position); - this->_M_impl._M_finish += difference_type(__n); - } - else - { - const size_type __len = - _M_check_len(__n, "vector::_M_insert_range"); - const iterator __begin = begin(), __end = end(); - _Bit_pointer __q = this->_M_allocate(__len); - iterator __start(std::__addressof(*__q), 0); - iterator __i = _M_copy_aligned(__begin, __position, __start); - __i = std::copy(__first, __last, __i); - iterator __finish = std::copy(__position, __end, __i); - this->_M_deallocate(); - this->_M_impl._M_end_of_storage = __q + _S_nword(__len); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __finish; - } - } - } - - template - - void - vector:: - _M_insert_aux(iterator __position, bool __x) - { - if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_addr()) - { - std::copy_backward(__position, this->_M_impl._M_finish, - this->_M_impl._M_finish + 1); - *__position = __x; - ++this->_M_impl._M_finish; - } - else - { - const size_type __len = - _M_check_len(size_type(1), "vector::_M_insert_aux"); - _Bit_pointer __q = this->_M_allocate(__len); - iterator __start(std::__addressof(*__q), 0); - iterator __i = _M_copy_aligned(begin(), __position, __start); - *__i++ = __x; - iterator __finish = std::copy(__position, end(), __i); - this->_M_deallocate(); - this->_M_impl._M_end_of_storage = __q + _S_nword(__len); - this->_M_impl._M_start = __start; - this->_M_impl._M_finish = __finish; - } - } - - template - - typename vector::iterator - vector:: - _M_erase(iterator __position) - { - if (__position + 1 != end()) - std::copy(__position + 1, end(), __position); - --this->_M_impl._M_finish; - return __position; - } - - template - - typename vector::iterator - vector:: - _M_erase(iterator __first, iterator __last) - { - if (__first != __last) - _M_erase_at_end(std::copy(__last, end(), __first)); - return __first; - } - - - template - - bool - vector:: - _M_shrink_to_fit() - { - if (capacity() - size() < int(_S_word_bit)) - return false; - try - { - if (size_type __n = size()) - _M_reallocate(__n); - else - { - this->_M_deallocate(); - this->_M_impl._M_reset(); - } - return true; - } - catch(...) - { return false; } - } - - - - -} - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - size_t - hash>:: - operator()(const std::vector& __b) const noexcept - { - size_t __hash = 0; - const size_t __words = __b.size() / _S_word_bit; - if (__words) - { - const size_t __clength = __words * sizeof(_Bit_type); - __hash = std::_Hash_impl::hash(__b._M_impl._M_start._M_p, __clength); - } - - const size_t __extrabits = __b.size() % _S_word_bit; - if (__extrabits) - { - _Bit_type __hiword = *__b._M_impl._M_finish._M_p; - __hiword &= ~((~static_cast<_Bit_type>(0)) << __extrabits); - - const size_t __clength - = (__extrabits + 8 - 1) / 8; - if (__words) - __hash = std::_Hash_impl::hash(&__hiword, __clength, __hash); - else - __hash = std::_Hash_impl::hash(&__hiword, __clength); - } - - return __hash; - } - - -} -# 73 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/vector" 2 3 - - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 3 - - - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/uses_allocator.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - struct __erased_type { }; - - - - - template - using __is_erased_or_convertible - = __or_, is_same<_Tp, __erased_type>>; - - - struct allocator_arg_t { explicit allocator_arg_t() = default; }; - - inline constexpr allocator_arg_t allocator_arg = - allocator_arg_t(); - - template> - struct __uses_allocator_helper - : false_type { }; - - template - struct __uses_allocator_helper<_Tp, _Alloc, - __void_t> - : __is_erased_or_convertible<_Alloc, typename _Tp::allocator_type>::type - { }; - - - template - struct uses_allocator - : __uses_allocator_helper<_Tp, _Alloc>::type - { }; - - struct __uses_alloc_base { }; - - struct __uses_alloc0 : __uses_alloc_base - { - struct _Sink { void operator=(const void*) { } } _M_a; - }; - - template - struct __uses_alloc1 : __uses_alloc_base { const _Alloc* _M_a; }; - - template - struct __uses_alloc2 : __uses_alloc_base { const _Alloc* _M_a; }; - - template - struct __uses_alloc; - - template - struct __uses_alloc - : __conditional_t< - is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>::value, - __uses_alloc1<_Alloc>, - __uses_alloc2<_Alloc>> - { - - - static_assert(__or_< - is_constructible<_Tp, allocator_arg_t, const _Alloc&, _Args...>, - is_constructible<_Tp, _Args..., const _Alloc&>>::value, - "construction with an allocator must be possible" - " if uses_allocator is true"); - }; - - template - struct __uses_alloc - : __uses_alloc0 { }; - - template - using __uses_alloc_t = - __uses_alloc::value, _Tp, _Alloc, _Args...>; - - template - - inline __uses_alloc_t<_Tp, _Alloc, _Args...> - __use_alloc(const _Alloc& __a) - { - __uses_alloc_t<_Tp, _Alloc, _Args...> __ret; - __ret._M_a = std::__addressof(__a); - return __ret; - } - - template - void - __use_alloc(const _Alloc&&) = delete; - - - template - inline constexpr bool uses_allocator_v = - uses_allocator<_Tp, _Alloc>::value; - - - template class _Predicate, - typename _Tp, typename _Alloc, typename... _Args> - struct __is_uses_allocator_predicate - : __conditional_t::value, - __or_<_Predicate<_Tp, allocator_arg_t, _Alloc, _Args...>, - _Predicate<_Tp, _Args..., _Alloc>>, - _Predicate<_Tp, _Args...>> { }; - - template - struct __is_uses_allocator_constructible - : __is_uses_allocator_predicate - { }; - - - template - inline constexpr bool __is_uses_allocator_constructible_v = - __is_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; - - - template - struct __is_nothrow_uses_allocator_constructible - : __is_uses_allocator_predicate - { }; - - - - template - inline constexpr bool - __is_nothrow_uses_allocator_constructible_v = - __is_nothrow_uses_allocator_constructible<_Tp, _Alloc, _Args...>::value; - - - template - void __uses_allocator_construct_impl(__uses_alloc0 __a, _Tp* __ptr, - _Args&&... __args) - { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)...); } - - template - void __uses_allocator_construct_impl(__uses_alloc1<_Alloc> __a, _Tp* __ptr, - _Args&&... __args) - { - ::new ((void*)__ptr) _Tp(allocator_arg, *__a._M_a, - std::forward<_Args>(__args)...); - } - - template - void __uses_allocator_construct_impl(__uses_alloc2<_Alloc> __a, _Tp* __ptr, - _Args&&... __args) - { ::new ((void*)__ptr) _Tp(std::forward<_Args>(__args)..., *__a._M_a); } - - template - void __uses_allocator_construct(const _Alloc& __a, _Tp* __ptr, - _Args&&... __args) - { - std::__uses_allocator_construct_impl( - std::__use_alloc<_Tp, _Alloc, _Args...>(__a), __ptr, - std::forward<_Args>(__args)...); - } - - - -} -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/memory_resource.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2 \ No newline at end of file diff --git a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/swapchain/__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp b/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/swapchain/__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp deleted file mode 100644 index 3cc788a..0000000 --- a/objs/xmake/linux_x86_64/libmlx/linux/x86_64/release/src/renderer/swapchain/__cpp_vk_swapchain.cpp-ea9c7bae.cpp.tmp +++ /dev/null @@ -1,18406 +0,0 @@ -# 1 "src/renderer/swapchain/vk_swapchain.cpp" -# 1 "" 1 -# 1 "" 3 -# 433 "" 3 -# 1 "" 1 -# 1 "" 2 -# 1 "src/renderer/swapchain/vk_swapchain.cpp" 2 -# 16 "src/renderer/swapchain/vk_swapchain.cpp" -# 1 "/usr/include/SDL2/SDL_vulkan.h" 1 3 4 -# 31 "/usr/include/SDL2/SDL_vulkan.h" 3 4 -# 1 "/usr/include/SDL2/SDL_video.h" 1 3 4 -# 31 "/usr/include/SDL2/SDL_video.h" 3 4 -# 1 "/usr/include/SDL2/SDL_stdinc.h" 1 3 4 -# 31 "/usr/include/SDL2/SDL_stdinc.h" 3 4 -# 1 "/usr/include/SDL2/SDL_config.h" 1 3 4 -# 32 "/usr/include/SDL2/SDL_config.h" 3 4 -# 1 "/usr/include/SDL2/SDL_platform.h" 1 3 4 -# 229 "/usr/include/SDL2/SDL_platform.h" 3 4 -# 1 "/usr/include/SDL2/begin_code.h" 1 3 4 -# 230 "/usr/include/SDL2/SDL_platform.h" 2 3 4 - - -extern "C" { -# 251 "/usr/include/SDL2/SDL_platform.h" 3 4 -extern __attribute__ ((visibility("default"))) const char * SDL_GetPlatform (void); - - - -} - -# 1 "/usr/include/SDL2/close_code.h" 1 3 4 -# 258 "/usr/include/SDL2/SDL_platform.h" 2 3 4 -# 33 "/usr/include/SDL2/SDL_config.h" 2 3 4 -# 32 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - -# 1 "/usr/include/sys/types.h" 1 3 4 -# 25 "/usr/include/sys/types.h" 3 4 -# 1 "/usr/include/features.h" 1 3 4 -# 394 "/usr/include/features.h" 3 4 -# 1 "/usr/include/features-time64.h" 1 3 4 -# 20 "/usr/include/features-time64.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 21 "/usr/include/features-time64.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 22 "/usr/include/features-time64.h" 2 3 4 -# 395 "/usr/include/features.h" 2 3 4 -# 481 "/usr/include/features.h" 3 4 -# 1 "/usr/include/stdc-predef.h" 1 3 4 -# 482 "/usr/include/features.h" 2 3 4 -# 503 "/usr/include/features.h" 3 4 -# 1 "/usr/include/sys/cdefs.h" 1 3 4 -# 576 "/usr/include/sys/cdefs.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 577 "/usr/include/sys/cdefs.h" 2 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 578 "/usr/include/sys/cdefs.h" 2 3 4 -# 504 "/usr/include/features.h" 2 3 4 -# 527 "/usr/include/features.h" 3 4 -# 1 "/usr/include/gnu/stubs.h" 1 3 4 -# 10 "/usr/include/gnu/stubs.h" 3 4 -# 1 "/usr/include/gnu/stubs-64.h" 1 3 4 -# 11 "/usr/include/gnu/stubs.h" 2 3 4 -# 528 "/usr/include/features.h" 2 3 4 -# 26 "/usr/include/sys/types.h" 2 3 4 - -extern "C" { - -# 1 "/usr/include/bits/types.h" 1 3 4 -# 27 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 28 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/timesize.h" 1 3 4 -# 19 "/usr/include/bits/timesize.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 20 "/usr/include/bits/timesize.h" 2 3 4 -# 29 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned char __u_char; -typedef unsigned short int __u_short; -typedef unsigned int __u_int; -typedef unsigned long int __u_long; - - -typedef signed char __int8_t; -typedef unsigned char __uint8_t; -typedef signed short int __int16_t; -typedef unsigned short int __uint16_t; -typedef signed int __int32_t; -typedef unsigned int __uint32_t; - -typedef signed long int __int64_t; -typedef unsigned long int __uint64_t; - - - - - - -typedef __int8_t __int_least8_t; -typedef __uint8_t __uint_least8_t; -typedef __int16_t __int_least16_t; -typedef __uint16_t __uint_least16_t; -typedef __int32_t __int_least32_t; -typedef __uint32_t __uint_least32_t; -typedef __int64_t __int_least64_t; -typedef __uint64_t __uint_least64_t; - - - -typedef long int __quad_t; -typedef unsigned long int __u_quad_t; - - - - - - - -typedef long int __intmax_t; -typedef unsigned long int __uintmax_t; -# 141 "/usr/include/bits/types.h" 3 4 -# 1 "/usr/include/bits/typesizes.h" 1 3 4 -# 142 "/usr/include/bits/types.h" 2 3 4 -# 1 "/usr/include/bits/time64.h" 1 3 4 -# 143 "/usr/include/bits/types.h" 2 3 4 - - -typedef unsigned long int __dev_t; -typedef unsigned int __uid_t; -typedef unsigned int __gid_t; -typedef unsigned long int __ino_t; -typedef unsigned long int __ino64_t; -typedef unsigned int __mode_t; -typedef unsigned long int __nlink_t; -typedef long int __off_t; -typedef long int __off64_t; -typedef int __pid_t; -typedef struct { int __val[2]; } __fsid_t; -typedef long int __clock_t; -typedef unsigned long int __rlim_t; -typedef unsigned long int __rlim64_t; -typedef unsigned int __id_t; -typedef long int __time_t; -typedef unsigned int __useconds_t; -typedef long int __suseconds_t; -typedef long int __suseconds64_t; - -typedef int __daddr_t; -typedef int __key_t; - - -typedef int __clockid_t; - - -typedef void * __timer_t; - - -typedef long int __blksize_t; - - - - -typedef long int __blkcnt_t; -typedef long int __blkcnt64_t; - - -typedef unsigned long int __fsblkcnt_t; -typedef unsigned long int __fsblkcnt64_t; - - -typedef unsigned long int __fsfilcnt_t; -typedef unsigned long int __fsfilcnt64_t; - - -typedef long int __fsword_t; - -typedef long int __ssize_t; - - -typedef long int __syscall_slong_t; - -typedef unsigned long int __syscall_ulong_t; - - - -typedef __off64_t __loff_t; -typedef char *__caddr_t; - - -typedef long int __intptr_t; - - -typedef unsigned int __socklen_t; - - - - -typedef int __sig_atomic_t; -# 30 "/usr/include/sys/types.h" 2 3 4 - - - -typedef __u_char u_char; -typedef __u_short u_short; -typedef __u_int u_int; -typedef __u_long u_long; -typedef __quad_t quad_t; -typedef __u_quad_t u_quad_t; -typedef __fsid_t fsid_t; - - -typedef __loff_t loff_t; - - - - -typedef __ino_t ino_t; - - - - - - -typedef __ino64_t ino64_t; - - - - -typedef __dev_t dev_t; - - - - -typedef __gid_t gid_t; - - - - -typedef __mode_t mode_t; - - - - -typedef __nlink_t nlink_t; - - - - -typedef __uid_t uid_t; - - - - - -typedef __off_t off_t; - - - - - - -typedef __off64_t off64_t; - - - - -typedef __pid_t pid_t; - - - - - -typedef __id_t id_t; - - - - -typedef __ssize_t ssize_t; - - - - - -typedef __daddr_t daddr_t; -typedef __caddr_t caddr_t; - - - - - -typedef __key_t key_t; - - - - -# 1 "/usr/include/bits/types/clock_t.h" 1 3 4 - - - - - - -typedef __clock_t clock_t; -# 127 "/usr/include/sys/types.h" 2 3 4 - -# 1 "/usr/include/bits/types/clockid_t.h" 1 3 4 - - - - - - -typedef __clockid_t clockid_t; -# 129 "/usr/include/sys/types.h" 2 3 4 -# 1 "/usr/include/bits/types/time_t.h" 1 3 4 -# 10 "/usr/include/bits/types/time_t.h" 3 4 -typedef __time_t time_t; -# 130 "/usr/include/sys/types.h" 2 3 4 -# 1 "/usr/include/bits/types/timer_t.h" 1 3 4 - - - - - - -typedef __timer_t timer_t; -# 131 "/usr/include/sys/types.h" 2 3 4 - - - -typedef __useconds_t useconds_t; - - - -typedef __suseconds_t suseconds_t; - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 46 "/usr/lib/clang/16/include/stddef.h" 3 4 -typedef long unsigned int size_t; -# 145 "/usr/include/sys/types.h" 2 3 4 - - - -typedef unsigned long int ulong; -typedef unsigned short int ushort; -typedef unsigned int uint; - - - - -# 1 "/usr/include/bits/stdint-intn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-intn.h" 3 4 -typedef __int8_t int8_t; -typedef __int16_t int16_t; -typedef __int32_t int32_t; -typedef __int64_t int64_t; -# 156 "/usr/include/sys/types.h" 2 3 4 - - -typedef __uint8_t u_int8_t; -typedef __uint16_t u_int16_t; -typedef __uint32_t u_int32_t; -typedef __uint64_t u_int64_t; - - -typedef int register_t __attribute__ ((__mode__ (__word__))); -# 176 "/usr/include/sys/types.h" 3 4 -# 1 "/usr/include/endian.h" 1 3 4 -# 24 "/usr/include/endian.h" 3 4 -# 1 "/usr/include/bits/endian.h" 1 3 4 -# 35 "/usr/include/bits/endian.h" 3 4 -# 1 "/usr/include/bits/endianness.h" 1 3 4 -# 36 "/usr/include/bits/endian.h" 2 3 4 -# 25 "/usr/include/endian.h" 2 3 4 -# 35 "/usr/include/endian.h" 3 4 -# 1 "/usr/include/bits/byteswap.h" 1 3 4 -# 33 "/usr/include/bits/byteswap.h" 3 4 -static __inline __uint16_t -__bswap_16 (__uint16_t __bsx) -{ - - - - return ((__uint16_t) ((((__bsx) >> 8) & 0xff) | (((__bsx) & 0xff) << 8))); - -} - - - - - - -static __inline __uint32_t -__bswap_32 (__uint32_t __bsx) -{ - - - - return ((((__bsx) & 0xff000000u) >> 24) | (((__bsx) & 0x00ff0000u) >> 8) | (((__bsx) & 0x0000ff00u) << 8) | (((__bsx) & 0x000000ffu) << 24)); - -} -# 69 "/usr/include/bits/byteswap.h" 3 4 -__extension__ static __inline __uint64_t -__bswap_64 (__uint64_t __bsx) -{ - - - - return ((((__bsx) & 0xff00000000000000ull) >> 56) | (((__bsx) & 0x00ff000000000000ull) >> 40) | (((__bsx) & 0x0000ff0000000000ull) >> 24) | (((__bsx) & 0x000000ff00000000ull) >> 8) | (((__bsx) & 0x00000000ff000000ull) << 8) | (((__bsx) & 0x0000000000ff0000ull) << 24) | (((__bsx) & 0x000000000000ff00ull) << 40) | (((__bsx) & 0x00000000000000ffull) << 56)); - -} -# 36 "/usr/include/endian.h" 2 3 4 -# 1 "/usr/include/bits/uintn-identity.h" 1 3 4 -# 32 "/usr/include/bits/uintn-identity.h" 3 4 -static __inline __uint16_t -__uint16_identity (__uint16_t __x) -{ - return __x; -} - -static __inline __uint32_t -__uint32_identity (__uint32_t __x) -{ - return __x; -} - -static __inline __uint64_t -__uint64_identity (__uint64_t __x) -{ - return __x; -} -# 37 "/usr/include/endian.h" 2 3 4 -# 177 "/usr/include/sys/types.h" 2 3 4 - - -# 1 "/usr/include/sys/select.h" 1 3 4 -# 30 "/usr/include/sys/select.h" 3 4 -# 1 "/usr/include/bits/select.h" 1 3 4 -# 31 "/usr/include/sys/select.h" 2 3 4 - - -# 1 "/usr/include/bits/types/sigset_t.h" 1 3 4 - - - -# 1 "/usr/include/bits/types/__sigset_t.h" 1 3 4 - - - - -typedef struct -{ - unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; -} __sigset_t; -# 5 "/usr/include/bits/types/sigset_t.h" 2 3 4 - - -typedef __sigset_t sigset_t; -# 34 "/usr/include/sys/select.h" 2 3 4 - - - -# 1 "/usr/include/bits/types/struct_timeval.h" 1 3 4 - - - - - - - -struct timeval -{ - - - - - __time_t tv_sec; - __suseconds_t tv_usec; - -}; -# 38 "/usr/include/sys/select.h" 2 3 4 - -# 1 "/usr/include/bits/types/struct_timespec.h" 1 3 4 -# 11 "/usr/include/bits/types/struct_timespec.h" 3 4 -struct timespec -{ - - - - __time_t tv_sec; - - - - - __syscall_slong_t tv_nsec; -# 31 "/usr/include/bits/types/struct_timespec.h" 3 4 -}; -# 40 "/usr/include/sys/select.h" 2 3 4 -# 49 "/usr/include/sys/select.h" 3 4 -typedef long int __fd_mask; -# 59 "/usr/include/sys/select.h" 3 4 -typedef struct - { - - - - __fd_mask fds_bits[1024 / (8 * (int) sizeof (__fd_mask))]; - - - - - - } fd_set; - - - - - - -typedef __fd_mask fd_mask; -# 91 "/usr/include/sys/select.h" 3 4 -extern "C" { -# 102 "/usr/include/sys/select.h" 3 4 -extern int select (int __nfds, fd_set *__restrict __readfds, - fd_set *__restrict __writefds, - fd_set *__restrict __exceptfds, - struct timeval *__restrict __timeout); -# 127 "/usr/include/sys/select.h" 3 4 -extern int pselect (int __nfds, fd_set *__restrict __readfds, - fd_set *__restrict __writefds, - fd_set *__restrict __exceptfds, - const struct timespec *__restrict __timeout, - const __sigset_t *__restrict __sigmask); -# 153 "/usr/include/sys/select.h" 3 4 -} -# 180 "/usr/include/sys/types.h" 2 3 4 - - - - - -typedef __blksize_t blksize_t; - - - - - - -typedef __blkcnt_t blkcnt_t; - - - -typedef __fsblkcnt_t fsblkcnt_t; - - - -typedef __fsfilcnt_t fsfilcnt_t; -# 219 "/usr/include/sys/types.h" 3 4 -typedef __blkcnt64_t blkcnt64_t; -typedef __fsblkcnt64_t fsblkcnt64_t; -typedef __fsfilcnt64_t fsfilcnt64_t; - - - - - -# 1 "/usr/include/bits/pthreadtypes.h" 1 3 4 -# 23 "/usr/include/bits/pthreadtypes.h" 3 4 -# 1 "/usr/include/bits/thread-shared-types.h" 1 3 4 -# 44 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/pthreadtypes-arch.h" 1 3 4 -# 21 "/usr/include/bits/pthreadtypes-arch.h" 3 4 -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 22 "/usr/include/bits/pthreadtypes-arch.h" 2 3 4 -# 45 "/usr/include/bits/thread-shared-types.h" 2 3 4 - -# 1 "/usr/include/bits/atomic_wide_counter.h" 1 3 4 -# 25 "/usr/include/bits/atomic_wide_counter.h" 3 4 -typedef union -{ - __extension__ unsigned long long int __value64; - struct - { - unsigned int __low; - unsigned int __high; - } __value32; -} __atomic_wide_counter; -# 47 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -typedef struct __pthread_internal_list -{ - struct __pthread_internal_list *__prev; - struct __pthread_internal_list *__next; -} __pthread_list_t; - -typedef struct __pthread_internal_slist -{ - struct __pthread_internal_slist *__next; -} __pthread_slist_t; -# 76 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_mutex.h" 1 3 4 -# 22 "/usr/include/bits/struct_mutex.h" 3 4 -struct __pthread_mutex_s -{ - int __lock; - unsigned int __count; - int __owner; - - unsigned int __nusers; - - - - int __kind; - - short __spins; - short __elision; - __pthread_list_t __list; -# 53 "/usr/include/bits/struct_mutex.h" 3 4 -}; -# 77 "/usr/include/bits/thread-shared-types.h" 2 3 4 -# 89 "/usr/include/bits/thread-shared-types.h" 3 4 -# 1 "/usr/include/bits/struct_rwlock.h" 1 3 4 -# 23 "/usr/include/bits/struct_rwlock.h" 3 4 -struct __pthread_rwlock_arch_t -{ - unsigned int __readers; - unsigned int __writers; - unsigned int __wrphase_futex; - unsigned int __writers_futex; - unsigned int __pad3; - unsigned int __pad4; - - int __cur_writer; - int __shared; - signed char __rwelision; - - - - - unsigned char __pad1[7]; - - - unsigned long int __pad2; - - - unsigned int __flags; -# 55 "/usr/include/bits/struct_rwlock.h" 3 4 -}; -# 90 "/usr/include/bits/thread-shared-types.h" 2 3 4 - - - - -struct __pthread_cond_s -{ - __atomic_wide_counter __wseq; - __atomic_wide_counter __g1_start; - unsigned int __g_refs[2] ; - unsigned int __g_size[2]; - unsigned int __g1_orig_size; - unsigned int __wrefs; - unsigned int __g_signals[2]; -}; - -typedef unsigned int __tss_t; -typedef unsigned long int __thrd_t; - -typedef struct -{ - int __data ; -} __once_flag; -# 24 "/usr/include/bits/pthreadtypes.h" 2 3 4 - - - -typedef unsigned long int pthread_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_mutexattr_t; - - - - -typedef union -{ - char __size[4]; - int __align; -} pthread_condattr_t; - - - -typedef unsigned int pthread_key_t; - - - -typedef int pthread_once_t; - - -union pthread_attr_t -{ - char __size[56]; - long int __align; -}; - -typedef union pthread_attr_t pthread_attr_t; - - - - -typedef union -{ - struct __pthread_mutex_s __data; - char __size[40]; - long int __align; -} pthread_mutex_t; - - -typedef union -{ - struct __pthread_cond_s __data; - char __size[48]; - __extension__ long long int __align; -} pthread_cond_t; - - - - - -typedef union -{ - struct __pthread_rwlock_arch_t __data; - char __size[56]; - long int __align; -} pthread_rwlock_t; - -typedef union -{ - char __size[8]; - long int __align; -} pthread_rwlockattr_t; - - - - - -typedef volatile int pthread_spinlock_t; - - - - -typedef union -{ - char __size[32]; - long int __align; -} pthread_barrier_t; - -typedef union -{ - char __size[4]; - int __align; -} pthread_barrierattr_t; -# 228 "/usr/include/sys/types.h" 2 3 4 - - -} -# 35 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - -# 1 "/usr/include/stdio.h" 1 3 4 -# 27 "/usr/include/stdio.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/stdio.h" 2 3 4 - -extern "C" { - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 34 "/usr/include/stdio.h" 2 3 4 - - -# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 -# 14 "/usr/lib/clang/16/include/stdarg.h" 3 4 -typedef __builtin_va_list __gnuc_va_list; -# 37 "/usr/include/stdio.h" 2 3 4 - - -# 1 "/usr/include/bits/types/__fpos_t.h" 1 3 4 - - - - -# 1 "/usr/include/bits/types/__mbstate_t.h" 1 3 4 -# 13 "/usr/include/bits/types/__mbstate_t.h" 3 4 -typedef struct -{ - int __count; - union - { - unsigned int __wch; - char __wchb[4]; - } __value; -} __mbstate_t; -# 6 "/usr/include/bits/types/__fpos_t.h" 2 3 4 - - - - -typedef struct _G_fpos_t -{ - __off_t __pos; - __mbstate_t __state; -} __fpos_t; -# 40 "/usr/include/stdio.h" 2 3 4 -# 1 "/usr/include/bits/types/__fpos64_t.h" 1 3 4 -# 10 "/usr/include/bits/types/__fpos64_t.h" 3 4 -typedef struct _G_fpos64_t -{ - __off64_t __pos; - __mbstate_t __state; -} __fpos64_t; -# 41 "/usr/include/stdio.h" 2 3 4 -# 1 "/usr/include/bits/types/__FILE.h" 1 3 4 - - - -struct _IO_FILE; -typedef struct _IO_FILE __FILE; -# 42 "/usr/include/stdio.h" 2 3 4 -# 1 "/usr/include/bits/types/FILE.h" 1 3 4 - - - -struct _IO_FILE; - - -typedef struct _IO_FILE FILE; -# 43 "/usr/include/stdio.h" 2 3 4 -# 1 "/usr/include/bits/types/struct_FILE.h" 1 3 4 -# 35 "/usr/include/bits/types/struct_FILE.h" 3 4 -struct _IO_FILE; -struct _IO_marker; -struct _IO_codecvt; -struct _IO_wide_data; - - - - -typedef void _IO_lock_t; - - - - - -struct _IO_FILE -{ - int _flags; - - - char *_IO_read_ptr; - char *_IO_read_end; - char *_IO_read_base; - char *_IO_write_base; - char *_IO_write_ptr; - char *_IO_write_end; - char *_IO_buf_base; - char *_IO_buf_end; - - - char *_IO_save_base; - char *_IO_backup_base; - char *_IO_save_end; - - struct _IO_marker *_markers; - - struct _IO_FILE *_chain; - - int _fileno; - int _flags2; - __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/bits/types/cookie_io_functions_t.h" 1 3 4 -# 27 "/usr/include/bits/types/cookie_io_functions_t.h" 3 4 -typedef __ssize_t cookie_read_function_t (void *__cookie, char *__buf, - size_t __nbytes); - - - - - - - -typedef __ssize_t cookie_write_function_t (void *__cookie, const char *__buf, - size_t __nbytes); - - - - - - - -typedef int cookie_seek_function_t (void *__cookie, __off64_t *__pos, int __w); - - -typedef int cookie_close_function_t (void *__cookie); - - - - - - -typedef struct _IO_cookie_io_functions_t -{ - cookie_read_function_t *read; - cookie_write_function_t *write; - cookie_seek_function_t *seek; - cookie_close_function_t *close; -} cookie_io_functions_t; -# 47 "/usr/include/stdio.h" 2 3 4 - - - - - -typedef __gnuc_va_list va_list; -# 84 "/usr/include/stdio.h" 3 4 -typedef __fpos_t fpos_t; - - - - -typedef __fpos64_t fpos64_t; -# 128 "/usr/include/stdio.h" 3 4 -# 1 "/usr/include/bits/stdio_lim.h" 1 3 4 -# 129 "/usr/include/stdio.h" 2 3 4 -# 148 "/usr/include/stdio.h" 3 4 -extern FILE *stdin; -extern FILE *stdout; -extern FILE *stderr; - - - - - - -extern int remove (const char *__filename) noexcept (true); - -extern int rename (const char *__old, const char *__new) noexcept (true); - - - -extern int renameat (int __oldfd, const char *__old, int __newfd, - const char *__new) noexcept (true); -# 175 "/usr/include/stdio.h" 3 4 -extern int renameat2 (int __oldfd, const char *__old, int __newfd, - const char *__new, unsigned int __flags) noexcept (true); - - - - - - -extern int fclose (FILE *__stream) __attribute__ ((__nonnull__ (1))); -# 193 "/usr/include/stdio.h" 3 4 -extern FILE *tmpfile (void) - __attribute__ ((__malloc__)) ; -# 205 "/usr/include/stdio.h" 3 4 -extern FILE *tmpfile64 (void) - __attribute__ ((__malloc__)) ; - - - -extern char *tmpnam (char[20]) noexcept (true) ; - - - - -extern char *tmpnam_r (char __s[20]) noexcept (true) ; -# 227 "/usr/include/stdio.h" 3 4 -extern char *tempnam (const char *__dir, const char *__pfx) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - - - -extern int fflush (FILE *__stream); -# 244 "/usr/include/stdio.h" 3 4 -extern int fflush_unlocked (FILE *__stream); -# 254 "/usr/include/stdio.h" 3 4 -extern int fcloseall (void); -# 263 "/usr/include/stdio.h" 3 4 -extern FILE *fopen (const char *__restrict __filename, - const char *__restrict __modes) - __attribute__ ((__malloc__)) ; - - - - -extern FILE *freopen (const char *__restrict __filename, - const char *__restrict __modes, - FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); -# 288 "/usr/include/stdio.h" 3 4 -extern FILE *fopen64 (const char *__restrict __filename, - const char *__restrict __modes) - __attribute__ ((__malloc__)) ; -extern FILE *freopen64 (const char *__restrict __filename, - const char *__restrict __modes, - FILE *__restrict __stream) __attribute__ ((__nonnull__ (3))); - - - - -extern FILE *fdopen (int __fd, const char *__modes) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern FILE *fopencookie (void *__restrict __magic_cookie, - const char *__restrict __modes, - cookie_io_functions_t __io_funcs) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - -extern FILE *fmemopen (void *__s, size_t __len, const char *__modes) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - -extern FILE *open_memstream (char **__bufloc, size_t *__sizeloc) noexcept (true) - __attribute__ ((__malloc__)) ; -# 333 "/usr/include/stdio.h" 3 4 -extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) noexcept (true); - - - -extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, - int __modes, size_t __n) noexcept (true); - - - - -extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, - size_t __size) noexcept (true); - - -extern void setlinebuf (FILE *__stream) noexcept (true); - - - - - - - -extern int fprintf (FILE *__restrict __stream, - const char *__restrict __format, ...); - - - - -extern int printf (const char *__restrict __format, ...); - -extern int sprintf (char *__restrict __s, - const char *__restrict __format, ...) noexcept (true); - - - - - -extern int vfprintf (FILE *__restrict __s, const char *__restrict __format, - __gnuc_va_list __arg); - - - - -extern int vprintf (const char *__restrict __format, __gnuc_va_list __arg); - -extern int vsprintf (char *__restrict __s, const char *__restrict __format, - __gnuc_va_list __arg) noexcept (true); - - - -extern int snprintf (char *__restrict __s, size_t __maxlen, - const char *__restrict __format, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 3, 4))); - -extern int vsnprintf (char *__restrict __s, size_t __maxlen, - const char *__restrict __format, __gnuc_va_list __arg) - noexcept (true) __attribute__ ((__format__ (__printf__, 3, 0))); - - - - - -extern int vasprintf (char **__restrict __ptr, const char *__restrict __f, - __gnuc_va_list __arg) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))) ; -extern int __asprintf (char **__restrict __ptr, - const char *__restrict __fmt, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; -extern int asprintf (char **__restrict __ptr, - const char *__restrict __fmt, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))) ; - - - - -extern int vdprintf (int __fd, const char *__restrict __fmt, - __gnuc_va_list __arg) - __attribute__ ((__format__ (__printf__, 2, 0))); -extern int dprintf (int __fd, const char *__restrict __fmt, ...) - __attribute__ ((__format__ (__printf__, 2, 3))); - - - - - - - -extern int fscanf (FILE *__restrict __stream, - const char *__restrict __format, ...) ; - - - - -extern int scanf (const char *__restrict __format, ...) ; - -extern int sscanf (const char *__restrict __s, - const char *__restrict __format, ...) noexcept (true); - - - - - -# 1 "/usr/include/bits/floatn.h" 1 3 4 -# 119 "/usr/include/bits/floatn.h" 3 4 -# 1 "/usr/include/bits/floatn-common.h" 1 3 4 -# 24 "/usr/include/bits/floatn-common.h" 3 4 -# 1 "/usr/include/bits/long-double.h" 1 3 4 -# 25 "/usr/include/bits/floatn-common.h" 2 3 4 -# 214 "/usr/include/bits/floatn-common.h" 3 4 -typedef float _Float32; -# 251 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float64; -# 268 "/usr/include/bits/floatn-common.h" 3 4 -typedef double _Float32x; -# 285 "/usr/include/bits/floatn-common.h" 3 4 -typedef long double _Float64x; -# 120 "/usr/include/bits/floatn.h" 2 3 4 -# 436 "/usr/include/stdio.h" 2 3 4 - - - - -extern int fscanf (FILE *__restrict __stream, const char *__restrict __format, ...) __asm__ ("" "__isoc23_fscanf") ; - - -extern int scanf (const char *__restrict __format, ...) __asm__ ("" "__isoc23_scanf") ; - -extern int sscanf (const char *__restrict __s, const char *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_sscanf"); -# 486 "/usr/include/stdio.h" 3 4 -extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, - __gnuc_va_list __arg) - __attribute__ ((__format__ (__scanf__, 2, 0))) ; - - - - - -extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) - __attribute__ ((__format__ (__scanf__, 1, 0))) ; - - -extern int vsscanf (const char *__restrict __s, - const char *__restrict __format, __gnuc_va_list __arg) - noexcept (true) __attribute__ ((__format__ (__scanf__, 2, 0))); - - - - - - -extern int vfscanf (FILE *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfscanf") - - - - __attribute__ ((__format__ (__scanf__, 2, 0))) ; -extern int vscanf (const char *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vscanf") - - __attribute__ ((__format__ (__scanf__, 1, 0))) ; -extern int vsscanf (const char *__restrict __s, const char *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vsscanf") - - - - __attribute__ ((__format__ (__scanf__, 2, 0))); -# 571 "/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); -# 596 "/usr/include/stdio.h" 3 4 -extern int fgetc_unlocked (FILE *__stream); -# 607 "/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); -# 623 "/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) - ; -# 673 "/usr/include/stdio.h" 3 4 -extern char *fgets_unlocked (char *__restrict __s, int __n, - FILE *__restrict __stream) - ; -# 690 "/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); -# 749 "/usr/include/stdio.h" 3 4 -extern int fputs_unlocked (const char *__restrict __s, - FILE *__restrict __stream); -# 760 "/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); -# 794 "/usr/include/stdio.h" 3 4 -extern int fseeko (FILE *__stream, __off_t __off, int __whence); - - - - -extern __off_t ftello (FILE *__stream) ; -# 818 "/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); -# 837 "/usr/include/stdio.h" 3 4 -extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); -extern __off64_t ftello64 (FILE *__stream) ; -extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); -extern int fsetpos64 (FILE *__stream, const fpos64_t *__pos); - - - -extern void clearerr (FILE *__stream) noexcept (true); - -extern int feof (FILE *__stream) noexcept (true) ; - -extern int ferror (FILE *__stream) noexcept (true) ; - - - -extern void clearerr_unlocked (FILE *__stream) noexcept (true); -extern int feof_unlocked (FILE *__stream) noexcept (true) ; -extern int ferror_unlocked (FILE *__stream) noexcept (true) ; - - - - - - - -extern void perror (const char *__s) __attribute__ ((__cold__)); - - - - -extern int fileno (FILE *__stream) noexcept (true) ; - - - - -extern int fileno_unlocked (FILE *__stream) noexcept (true) ; -# 881 "/usr/include/stdio.h" 3 4 -extern int pclose (FILE *__stream); - - - - - -extern FILE *popen (const char *__command, const char *__modes) - __attribute__ ((__malloc__)) ; - - - - - - -extern char *ctermid (char *__s) noexcept (true) - ; - - - - - -extern char *cuserid (char *__s) - ; - - - - -struct obstack; - - -extern int obstack_printf (struct obstack *__restrict __obstack, - const char *__restrict __format, ...) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 3))); -extern int obstack_vprintf (struct obstack *__restrict __obstack, - const char *__restrict __format, - __gnuc_va_list __args) - noexcept (true) __attribute__ ((__format__ (__printf__, 2, 0))); - - - - - - - -extern void flockfile (FILE *__stream) noexcept (true); - - - -extern int ftrylockfile (FILE *__stream) noexcept (true) ; - - -extern void funlockfile (FILE *__stream) noexcept (true); -# 943 "/usr/include/stdio.h" 3 4 -extern int __uflow (FILE *); -extern int __overflow (FILE *, int); -# 960 "/usr/include/stdio.h" 3 4 -# 1 "/usr/include/bits/stdio.h" 1 3 4 -# 38 "/usr/include/bits/stdio.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) int -vprintf (const char *__restrict __fmt, __gnuc_va_list __arg) -{ - return vfprintf (stdout, __fmt, __arg); -} - - - -extern __inline __attribute__ ((__gnu_inline__)) int -getchar (void) -{ - return getc (stdin); -} - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -fgetc_unlocked (FILE *__fp) -{ - return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -getc_unlocked (FILE *__fp) -{ - return (__builtin_expect (((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end), 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++); -} - - -extern __inline __attribute__ ((__gnu_inline__)) int -getchar_unlocked (void) -{ - return (__builtin_expect (((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end), 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++); -} - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -putchar (int __c) -{ - return putc (__c, stdout); -} - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -fputc_unlocked (int __c, FILE *__stream) -{ - return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) int -putc_unlocked (int __c, FILE *__stream) -{ - return (__builtin_expect (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end), 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c))); -} - - -extern __inline __attribute__ ((__gnu_inline__)) int -putchar_unlocked (int __c) -{ - return (__builtin_expect (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end), 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c))); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) __ssize_t -getline (char **__lineptr, size_t *__n, FILE *__stream) -{ - return __getdelim (__lineptr, __n, '\n', __stream); -} - - - - - -extern __inline __attribute__ ((__gnu_inline__)) int - feof_unlocked (FILE *__stream) noexcept (true) -{ - return (((__stream)->_flags & 0x0010) != 0); -} - - -extern __inline __attribute__ ((__gnu_inline__)) int - ferror_unlocked (FILE *__stream) noexcept (true) -{ - return (((__stream)->_flags & 0x0020) != 0); -} -# 961 "/usr/include/stdio.h" 2 3 4 - - - - - - -} -# 38 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 1 3 4 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 3 4 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 1 3 4 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3 -# 306 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - typedef long unsigned int size_t; - typedef long int ptrdiff_t; - - - typedef decltype(nullptr) nullptr_t; - - -#pragma GCC visibility push(default) - - - extern "C++" __attribute__ ((__noreturn__, __always_inline__)) - inline void __terminate() noexcept - { - void terminate() noexcept __attribute__ ((__noreturn__)); - terminate(); - } -#pragma GCC visibility pop -} -# 339 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -namespace __gnu_cxx -{ - inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { } -} -# 532 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -namespace std -{ -#pragma GCC visibility push(default) - - - - - constexpr inline bool - __is_constant_evaluated() noexcept - { - - - - - - return __builtin_is_constant_evaluated(); - - - - } -#pragma GCC visibility pop -} -# 679 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3 -# 680 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3 -# 683 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 882 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/pstl/pstl_config.h" 1 3 -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 -# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 -# 1 "/usr/include/stdlib.h" 1 3 4 -# 26 "/usr/include/stdlib.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/stdlib.h" 2 3 4 - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 33 "/usr/include/stdlib.h" 2 3 4 - -extern "C" { - - - - - -# 1 "/usr/include/bits/waitflags.h" 1 3 4 -# 41 "/usr/include/stdlib.h" 2 3 4 -# 1 "/usr/include/bits/waitstatus.h" 1 3 4 -# 42 "/usr/include/stdlib.h" 2 3 4 -# 59 "/usr/include/stdlib.h" 3 4 -typedef struct - { - int quot; - int rem; - } div_t; - - - -typedef struct - { - long int quot; - long int rem; - } ldiv_t; - - - - - -__extension__ typedef struct - { - long long int quot; - long long int rem; - } lldiv_t; -# 98 "/usr/include/stdlib.h" 3 4 -extern size_t __ctype_get_mb_cur_max (void) noexcept (true) ; - - - -extern double atof (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - -extern int atoi (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - -extern long int atol (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - -__extension__ extern long long int atoll (const char *__nptr) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; - - - -extern double strtod (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern float strtof (const char *__restrict __nptr, - char **__restrict __endptr) noexcept (true) __attribute__ ((__nonnull__ (1))); - -extern long double strtold (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 141 "/usr/include/stdlib.h" 3 4 -extern _Float32 strtof32 (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern _Float64 strtof64 (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 159 "/usr/include/stdlib.h" 3 4 -extern _Float32x strtof32x (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern _Float64x strtof64x (const char *__restrict __nptr, - char **__restrict __endptr) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 177 "/usr/include/stdlib.h" 3 4 -extern long int strtol (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -extern unsigned long int strtoul (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -__extension__ -extern long long int strtoq (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -__extension__ -extern unsigned long long int strtouq (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -__extension__ -extern long long int strtoll (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - -__extension__ -extern unsigned long long int strtoull (const char *__restrict __nptr, - char **__restrict __endptr, int __base) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern long int strtol (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtol") - - - __attribute__ ((__nonnull__ (1))); -extern unsigned long int strtoul (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoul") - - - - __attribute__ ((__nonnull__ (1))); - -__extension__ -extern long long int strtoq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") - - - __attribute__ ((__nonnull__ (1))); -__extension__ -extern unsigned long long int strtouq (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") - - - - __attribute__ ((__nonnull__ (1))); - -__extension__ -extern long long int strtoll (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoll") - - - __attribute__ ((__nonnull__ (1))); -__extension__ -extern unsigned long long int strtoull (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoull") - - - - __attribute__ ((__nonnull__ (1))); -# 278 "/usr/include/stdlib.h" 3 4 -extern int strfromd (char *__dest, size_t __size, const char *__format, - double __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - -extern int strfromf (char *__dest, size_t __size, const char *__format, - float __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - -extern int strfroml (char *__dest, size_t __size, const char *__format, - long double __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 298 "/usr/include/stdlib.h" 3 4 -extern int strfromf32 (char *__dest, size_t __size, const char * __format, - _Float32 __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - - -extern int strfromf64 (char *__dest, size_t __size, const char * __format, - _Float64 __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 316 "/usr/include/stdlib.h" 3 4 -extern int strfromf32x (char *__dest, size_t __size, const char * __format, - _Float32x __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); - - - -extern int strfromf64x (char *__dest, size_t __size, const char * __format, - _Float64x __f) - noexcept (true) __attribute__ ((__nonnull__ (3))); -# 338 "/usr/include/stdlib.h" 3 4 -# 1 "/usr/include/bits/types/locale_t.h" 1 3 4 -# 22 "/usr/include/bits/types/locale_t.h" 3 4 -# 1 "/usr/include/bits/types/__locale_t.h" 1 3 4 -# 27 "/usr/include/bits/types/__locale_t.h" 3 4 -struct __locale_struct -{ - - struct __locale_data *__locales[13]; - - - const unsigned short int *__ctype_b; - const int *__ctype_tolower; - const int *__ctype_toupper; - - - const char *__names[13]; -}; - -typedef struct __locale_struct *__locale_t; -# 23 "/usr/include/bits/types/locale_t.h" 2 3 4 - -typedef __locale_t locale_t; -# 339 "/usr/include/stdlib.h" 2 3 4 - -extern long int strtol_l (const char *__restrict __nptr, - char **__restrict __endptr, int __base, - locale_t __loc) noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -extern unsigned long int strtoul_l (const char *__restrict __nptr, - char **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -__extension__ -extern long long int strtoll_l (const char *__restrict __nptr, - char **__restrict __endptr, int __base, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - -__extension__ -extern unsigned long long int strtoull_l (const char *__restrict __nptr, - char **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 4))); - - - - - -extern long int strtol_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtol_l") - - - - __attribute__ ((__nonnull__ (1, 4))); -extern unsigned long int strtoul_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoul_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -__extension__ -extern long long int strtoll_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoll_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -__extension__ -extern unsigned long long int strtoull_l (const char *__restrict __nptr, char **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_strtoull_l") - - - - - __attribute__ ((__nonnull__ (1, 4))); -# 415 "/usr/include/stdlib.h" 3 4 -extern double strtod_l (const char *__restrict __nptr, - char **__restrict __endptr, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - -extern float strtof_l (const char *__restrict __nptr, - char **__restrict __endptr, locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - -extern long double strtold_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 436 "/usr/include/stdlib.h" 3 4 -extern _Float32 strtof32_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern _Float64 strtof64_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 457 "/usr/include/stdlib.h" 3 4 -extern _Float32x strtof32x_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); - - - -extern _Float64x strtof64x_l (const char *__restrict __nptr, - char **__restrict __endptr, - locale_t __loc) - noexcept (true) __attribute__ ((__nonnull__ (1, 3))); -# 480 "/usr/include/stdlib.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) int - atoi (const char *__nptr) noexcept (true) -{ - return (int) strtol (__nptr, (char **) __null, 10); -} -extern __inline __attribute__ ((__gnu_inline__)) long int - atol (const char *__nptr) noexcept (true) -{ - return strtol (__nptr, (char **) __null, 10); -} - - -__extension__ extern __inline __attribute__ ((__gnu_inline__)) long long int - atoll (const char *__nptr) noexcept (true) -{ - return strtoll (__nptr, (char **) __null, 10); -} -# 505 "/usr/include/stdlib.h" 3 4 -extern char *l64a (long int __n) noexcept (true) ; - - -extern long int a64l (const char *__s) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; -# 521 "/usr/include/stdlib.h" 3 4 -extern long int random (void) noexcept (true); - - -extern void srandom (unsigned int __seed) noexcept (true); - - - - - -extern char *initstate (unsigned int __seed, char *__statebuf, - size_t __statelen) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - -extern char *setstate (char *__statebuf) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - - -struct random_data - { - int32_t *fptr; - int32_t *rptr; - int32_t *state; - int rand_type; - int rand_deg; - int rand_sep; - int32_t *end_ptr; - }; - -extern int random_r (struct random_data *__restrict __buf, - int32_t *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern int srandom_r (unsigned int __seed, struct random_data *__buf) - noexcept (true) __attribute__ ((__nonnull__ (2))); - -extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, - size_t __statelen, - struct random_data *__restrict __buf) - noexcept (true) __attribute__ ((__nonnull__ (2, 4))); - -extern int setstate_r (char *__restrict __statebuf, - struct random_data *__restrict __buf) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - - -extern int rand (void) noexcept (true); - -extern void srand (unsigned int __seed) noexcept (true); - - - -extern int rand_r (unsigned int *__seed) noexcept (true); - - - - - - - -extern double drand48 (void) noexcept (true); -extern double erand48 (unsigned short int __xsubi[3]) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern long int lrand48 (void) noexcept (true); -extern long int nrand48 (unsigned short int __xsubi[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern long int mrand48 (void) noexcept (true); -extern long int jrand48 (unsigned short int __xsubi[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern void srand48 (long int __seedval) noexcept (true); -extern unsigned short int *seed48 (unsigned short int __seed16v[3]) - noexcept (true) __attribute__ ((__nonnull__ (1))); -extern void lcong48 (unsigned short int __param[7]) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -struct drand48_data - { - unsigned short int __x[3]; - unsigned short int __old_x[3]; - unsigned short int __c; - unsigned short int __init; - __extension__ unsigned long long int __a; - - }; - - -extern int drand48_r (struct drand48_data *__restrict __buffer, - double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int erand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - double *__restrict __result) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int lrand48_r (struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int nrand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int mrand48_r (struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern int jrand48_r (unsigned short int __xsubi[3], - struct drand48_data *__restrict __buffer, - long int *__restrict __result) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int srand48_r (long int __seedval, struct drand48_data *__buffer) - noexcept (true) __attribute__ ((__nonnull__ (2))); - -extern int seed48_r (unsigned short int __seed16v[3], - struct drand48_data *__buffer) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern int lcong48_r (unsigned short int __param[7], - struct drand48_data *__buffer) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern __uint32_t arc4random (void) - noexcept (true) ; - - -extern void arc4random_buf (void *__buf, size_t __size) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - -extern __uint32_t arc4random_uniform (__uint32_t __upper_bound) - noexcept (true) ; - - - - -extern void *malloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) - ; - -extern void *calloc (size_t __nmemb, size_t __size) - noexcept (true) __attribute__ ((__malloc__)) ; - - - - - - -extern void *realloc (void *__ptr, size_t __size) - noexcept (true) __attribute__ ((__warn_unused_result__)) ; - - -extern void free (void *__ptr) noexcept (true); - - - - - - - -extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) - noexcept (true) __attribute__ ((__warn_unused_result__)) - - ; - - -extern void *reallocarray (void *__ptr, size_t __nmemb, size_t __size) - noexcept (true) ; - - - -# 1 "/usr/include/alloca.h" 1 3 4 -# 24 "/usr/include/alloca.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 25 "/usr/include/alloca.h" 2 3 4 - -extern "C" { - - - - - -extern void *alloca (size_t __size) noexcept (true); - - - - - -} -# 707 "/usr/include/stdlib.h" 2 3 4 - - - - - -extern void *valloc (size_t __size) noexcept (true) __attribute__ ((__malloc__)) - ; - - - - -extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) - noexcept (true) __attribute__ ((__nonnull__ (1))) ; - - - - -extern void *aligned_alloc (size_t __alignment, size_t __size) - noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__alloc_align__ (1))) - ; - - - -extern void abort (void) noexcept (true) __attribute__ ((__noreturn__)); - - - -extern int atexit (void (*__func) (void)) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - -extern "C++" int at_quick_exit (void (*__func) (void)) - noexcept (true) __asm ("at_quick_exit") __attribute__ ((__nonnull__ (1))); -# 749 "/usr/include/stdlib.h" 3 4 -extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) - noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern void exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); - - - - - -extern void quick_exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); - - - - - -extern void _Exit (int __status) noexcept (true) __attribute__ ((__noreturn__)); - - - - -extern char *getenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))) ; - - - - -extern char *secure_getenv (const char *__name) - noexcept (true) __attribute__ ((__nonnull__ (1))) ; - - - - - - -extern int putenv (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - -extern int setenv (const char *__name, const char *__value, int __replace) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - -extern int unsetenv (const char *__name) noexcept (true) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int clearenv (void) noexcept (true); -# 814 "/usr/include/stdlib.h" 3 4 -extern char *mktemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))); -# 827 "/usr/include/stdlib.h" 3 4 -extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; -# 837 "/usr/include/stdlib.h" 3 4 -extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; -# 849 "/usr/include/stdlib.h" 3 4 -extern int mkstemps (char *__template, int __suffixlen) __attribute__ ((__nonnull__ (1))) ; -# 859 "/usr/include/stdlib.h" 3 4 -extern int mkstemps64 (char *__template, int __suffixlen) - __attribute__ ((__nonnull__ (1))) ; -# 870 "/usr/include/stdlib.h" 3 4 -extern char *mkdtemp (char *__template) noexcept (true) __attribute__ ((__nonnull__ (1))) ; -# 881 "/usr/include/stdlib.h" 3 4 -extern int mkostemp (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; -# 891 "/usr/include/stdlib.h" 3 4 -extern int mkostemp64 (char *__template, int __flags) __attribute__ ((__nonnull__ (1))) ; -# 901 "/usr/include/stdlib.h" 3 4 -extern int mkostemps (char *__template, int __suffixlen, int __flags) - __attribute__ ((__nonnull__ (1))) ; -# 913 "/usr/include/stdlib.h" 3 4 -extern int mkostemps64 (char *__template, int __suffixlen, int __flags) - __attribute__ ((__nonnull__ (1))) ; -# 923 "/usr/include/stdlib.h" 3 4 -extern int system (const char *__command) ; - - - - - -extern char *canonicalize_file_name (const char *__name) - noexcept (true) __attribute__ ((__nonnull__ (1))) __attribute__ ((__malloc__)) - ; -# 940 "/usr/include/stdlib.h" 3 4 -extern char *realpath (const char *__restrict __name, - char *__restrict __resolved) noexcept (true) ; - - - - - - -typedef int (*__compar_fn_t) (const void *, const void *); - - -typedef __compar_fn_t comparison_fn_t; - - - -typedef int (*__compar_d_fn_t) (const void *, const void *, void *); - - - - -extern void *bsearch (const void *__key, const void *__base, - size_t __nmemb, size_t __size, __compar_fn_t __compar) - __attribute__ ((__nonnull__ (1, 2, 5))) ; - - -# 1 "/usr/include/bits/stdlib-bsearch.h" 1 3 4 -# 19 "/usr/include/bits/stdlib-bsearch.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) void * -bsearch (const void *__key, const void *__base, size_t __nmemb, size_t __size, - __compar_fn_t __compar) -{ - size_t __l, __u, __idx; - const void *__p; - int __comparison; - - __l = 0; - __u = __nmemb; - while (__l < __u) - { - __idx = (__l + __u) / 2; - __p = (const void *) (((const char *) __base) + (__idx * __size)); - __comparison = (*__compar) (__key, __p); - if (__comparison < 0) - __u = __idx; - else if (__comparison > 0) - __l = __idx + 1; - else - { - - - - - return (void *) __p; - - - - } - } - - return __null; -} -# 966 "/usr/include/stdlib.h" 2 3 4 - - - - -extern void qsort (void *__base, size_t __nmemb, size_t __size, - __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); - -extern void qsort_r (void *__base, size_t __nmemb, size_t __size, - __compar_d_fn_t __compar, void *__arg) - __attribute__ ((__nonnull__ (1, 4))); - - - - -extern int abs (int __x) noexcept (true) __attribute__ ((__const__)) ; -extern long int labs (long int __x) noexcept (true) __attribute__ ((__const__)) ; - - -__extension__ extern long long int llabs (long long int __x) - noexcept (true) __attribute__ ((__const__)) ; - - - - - - -extern div_t div (int __numer, int __denom) - noexcept (true) __attribute__ ((__const__)) ; -extern ldiv_t ldiv (long int __numer, long int __denom) - noexcept (true) __attribute__ ((__const__)) ; - - -__extension__ extern lldiv_t lldiv (long long int __numer, - long long int __denom) - noexcept (true) __attribute__ ((__const__)) ; -# 1012 "/usr/include/stdlib.h" 3 4 -extern char *ecvt (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; - - - - -extern char *fcvt (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign) noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; - - - - -extern char *gcvt (double __value, int __ndigit, char *__buf) - noexcept (true) __attribute__ ((__nonnull__ (3))) ; - - - - -extern char *qecvt (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign) - noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; -extern char *qfcvt (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign) - noexcept (true) __attribute__ ((__nonnull__ (3, 4))) ; -extern char *qgcvt (long double __value, int __ndigit, char *__buf) - noexcept (true) __attribute__ ((__nonnull__ (3))) ; - - - - -extern int ecvt_r (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign, char *__restrict __buf, - size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); -extern int fcvt_r (double __value, int __ndigit, int *__restrict __decpt, - int *__restrict __sign, char *__restrict __buf, - size_t __len) noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); - -extern int qecvt_r (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign, - char *__restrict __buf, size_t __len) - noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); -extern int qfcvt_r (long double __value, int __ndigit, - int *__restrict __decpt, int *__restrict __sign, - char *__restrict __buf, size_t __len) - noexcept (true) __attribute__ ((__nonnull__ (3, 4, 5))); - - - - - -extern int mblen (const char *__s, size_t __n) noexcept (true); - - -extern int mbtowc (wchar_t *__restrict __pwc, - const char *__restrict __s, size_t __n) noexcept (true); - - -extern int wctomb (char *__s, wchar_t __wchar) noexcept (true); - - - -extern size_t mbstowcs (wchar_t *__restrict __pwcs, - const char *__restrict __s, size_t __n) noexcept (true) - ; - -extern size_t wcstombs (char *__restrict __s, - const wchar_t *__restrict __pwcs, size_t __n) - noexcept (true) - - ; - - - - - - -extern int rpmatch (const char *__response) noexcept (true) __attribute__ ((__nonnull__ (1))) ; -# 1099 "/usr/include/stdlib.h" 3 4 -extern int getsubopt (char **__restrict __optionp, - char *const *__restrict __tokens, - char **__restrict __valuep) - noexcept (true) __attribute__ ((__nonnull__ (1, 2, 3))) ; - - - - - - - -extern int posix_openpt (int __oflag) ; - - - - - - - -extern int grantpt (int __fd) noexcept (true); - - - -extern int unlockpt (int __fd) noexcept (true); - - - - -extern char *ptsname (int __fd) noexcept (true) ; - - - - - - -extern int ptsname_r (int __fd, char *__buf, size_t __buflen) - noexcept (true) __attribute__ ((__nonnull__ (2))) ; - - -extern int getpt (void); - - - - - - -extern int getloadavg (double __loadavg[], int __nelem) - noexcept (true) __attribute__ ((__nonnull__ (1))); -# 1155 "/usr/include/stdlib.h" 3 4 -# 1 "/usr/include/bits/stdlib-float.h" 1 3 4 -# 24 "/usr/include/bits/stdlib-float.h" 3 4 -extern __inline __attribute__ ((__gnu_inline__)) double - atof (const char *__nptr) noexcept (true) -{ - return strtod (__nptr, (char **) __null); -} -# 1156 "/usr/include/stdlib.h" 2 3 4 -# 1167 "/usr/include/stdlib.h" 3 4 -} -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::abs; - - - inline long - abs(long __i) { return __builtin_labs(__i); } - - - - inline long long - abs(long long __x) { return __builtin_llabs (__x); } -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 - inline constexpr double - abs(double __x) - { return __builtin_fabs(__x); } - - inline constexpr float - abs(float __x) - { return __builtin_fabsf(__x); } - - inline constexpr long double - abs(long double __x) - { return __builtin_fabsl(__x); } -# 151 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/std_abs.h" 3 -} -} -# 82 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 2 3 -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cstdlib" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::div_t; - using ::ldiv_t; - - using ::abort; - - using ::aligned_alloc; - - using ::atexit; - - - using ::at_quick_exit; - - - using ::atof; - using ::atoi; - using ::atol; - using ::bsearch; - using ::calloc; - using ::div; - using ::exit; - using ::free; - using ::getenv; - using ::labs; - using ::ldiv; - using ::malloc; - - using ::mblen; - using ::mbstowcs; - using ::mbtowc; - - using ::qsort; - - - using ::quick_exit; - - - using ::rand; - using ::realloc; - using ::srand; - using ::strtod; - using ::strtol; - using ::strtoul; - using ::system; - - using ::wcstombs; - using ::wctomb; - - - - inline ldiv_t - div(long __i, long __j) noexcept { return ldiv(__i, __j); } - - - - -} -# 199 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -# 231 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/stdlib.h" 2 3 4 - -using std::abort; -using std::atexit; -using std::exit; - - - using std::at_quick_exit; - - - using std::quick_exit; - - - using std::_Exit; - - - - -using std::div_t; -using std::ldiv_t; - -using std::abs; -using std::atof; -using std::atoi; -using std::atol; -using std::bsearch; -using std::calloc; -using std::div; -using std::free; -using std::getenv; -using std::labs; -using std::ldiv; -using std::malloc; - -using std::mblen; -using std::mbstowcs; -using std::mbtowc; - -using std::qsort; -using std::rand; -using std::realloc; -using std::srand; -using std::strtod; -using std::strtol; -using std::strtoul; -using std::system; - -using std::wcstombs; -using std::wctomb; -# 41 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 35 "/usr/lib/clang/16/include/stddef.h" 3 4 -typedef long int ptrdiff_t; -# 109 "/usr/lib/clang/16/include/stddef.h" 3 4 -# 1 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 1 3 4 -# 19 "/usr/lib/clang/16/include/__stddef_max_align_t.h" 3 4 -typedef struct { - long long __clang_max_align_nonce1 - __attribute__((__aligned__(__alignof__(long long)))); - long double __clang_max_align_nonce2 - __attribute__((__aligned__(__alignof__(long double)))); -} max_align_t; -# 110 "/usr/lib/clang/16/include/stddef.h" 2 3 4 -# 42 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 -# 1 "/usr/lib/clang/16/include/stdarg.h" 1 3 4 -# 22 "/usr/lib/clang/16/include/stdarg.h" 3 4 -typedef __builtin_va_list va_list; -# 43 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 -# 60 "/usr/include/SDL2/SDL_stdinc.h" 3 4 -# 1 "/usr/include/string.h" 1 3 4 -# 26 "/usr/include/string.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/string.h" 2 3 4 - -extern "C" { - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 34 "/usr/include/string.h" 2 3 4 -# 43 "/usr/include/string.h" 3 4 -extern void *memcpy (void *__restrict __dest, const void *__restrict __src, - size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern void *memmove (void *__dest, const void *__src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - - -extern void *memccpy (void *__restrict __dest, const void *__restrict __src, - int __c, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - - -extern void *memset (void *__s, int __c, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern int memcmp (const void *__s1, const void *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -# 80 "/usr/include/string.h" 3 4 -extern int __memcmpeq (const void *__s1, const void *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - - -extern "C++" -{ -extern void *memchr (void *__s, int __c, size_t __n) - noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern const void *memchr (const void *__s, int __c, size_t __n) - noexcept (true) __asm ("memchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) void * -memchr (void *__s, int __c, size_t __n) noexcept (true) -{ - return __builtin_memchr (__s, __c, __n); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const void * -memchr (const void *__s, int __c, size_t __n) noexcept (true) -{ - return __builtin_memchr (__s, __c, __n); -} - -} -# 115 "/usr/include/string.h" 3 4 -extern "C++" void *rawmemchr (void *__s, int __c) - noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern "C++" const void *rawmemchr (const void *__s, int __c) - noexcept (true) __asm ("rawmemchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - - - - - - -extern "C++" void *memrchr (void *__s, int __c, size_t __n) - noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) - ; -extern "C++" const void *memrchr (const void *__s, int __c, size_t __n) - noexcept (true) __asm ("memrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) - ; -# 141 "/usr/include/string.h" 3 4 -extern char *strcpy (char *__restrict __dest, const char *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern char *strncpy (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern char *strcat (char *__restrict __dest, const char *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern char *strncat (char *__restrict __dest, const char *__restrict __src, - size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int strcmp (const char *__s1, const char *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - -extern int strncmp (const char *__s1, const char *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern int strcoll (const char *__s1, const char *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - -extern size_t strxfrm (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (2))) ; - - - - - - -extern int strcoll_l (const char *__s1, const char *__s2, locale_t __l) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); - - -extern size_t strxfrm_l (char *__dest, const char *__src, size_t __n, - locale_t __l) noexcept (true) __attribute__ ((__nonnull__ (2, 4))) - ; - - - - - -extern char *strdup (const char *__s) - noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); - - - - - - -extern char *strndup (const char *__string, size_t __n) - noexcept (true) __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); -# 224 "/usr/include/string.h" 3 4 -extern "C++" -{ -extern char *strchr (char *__s, int __c) - noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern const char *strchr (const char *__s, int __c) - noexcept (true) __asm ("strchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * -strchr (char *__s, int __c) noexcept (true) -{ - return __builtin_strchr (__s, __c); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * -strchr (const char *__s, int __c) noexcept (true) -{ - return __builtin_strchr (__s, __c); -} - -} - - - - - - -extern "C++" -{ -extern char *strrchr (char *__s, int __c) - noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern const char *strrchr (const char *__s, int __c) - noexcept (true) __asm ("strrchr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * -strrchr (char *__s, int __c) noexcept (true) -{ - return __builtin_strrchr (__s, __c); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * -strrchr (const char *__s, int __c) noexcept (true) -{ - return __builtin_strrchr (__s, __c); -} - -} -# 281 "/usr/include/string.h" 3 4 -extern "C++" char *strchrnul (char *__s, int __c) - noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -extern "C++" const char *strchrnul (const char *__s, int __c) - noexcept (true) __asm ("strchrnul") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -# 293 "/usr/include/string.h" 3 4 -extern size_t strcspn (const char *__s, const char *__reject) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern size_t strspn (const char *__s, const char *__accept) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern "C++" -{ -extern char *strpbrk (char *__s, const char *__accept) - noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -extern const char *strpbrk (const char *__s, const char *__accept) - noexcept (true) __asm ("strpbrk") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * -strpbrk (char *__s, const char *__accept) noexcept (true) -{ - return __builtin_strpbrk (__s, __accept); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * -strpbrk (const char *__s, const char *__accept) noexcept (true) -{ - return __builtin_strpbrk (__s, __accept); -} - -} - - - - - - -extern "C++" -{ -extern char *strstr (char *__haystack, const char *__needle) - noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -extern const char *strstr (const char *__haystack, const char *__needle) - noexcept (true) __asm ("strstr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) char * -strstr (char *__haystack, const char *__needle) noexcept (true) -{ - return __builtin_strstr (__haystack, __needle); -} - -extern __inline __attribute__ ((__always_inline__)) __attribute__ ((__gnu_inline__)) const char * -strstr (const char *__haystack, const char *__needle) noexcept (true) -{ - return __builtin_strstr (__haystack, __needle); -} - -} - - - - - - - -extern char *strtok (char *__restrict __s, const char *__restrict __delim) - noexcept (true) __attribute__ ((__nonnull__ (2))); - - - -extern char *__strtok_r (char *__restrict __s, - const char *__restrict __delim, - char **__restrict __save_ptr) - noexcept (true) __attribute__ ((__nonnull__ (2, 3))); - -extern char *strtok_r (char *__restrict __s, const char *__restrict __delim, - char **__restrict __save_ptr) - noexcept (true) __attribute__ ((__nonnull__ (2, 3))); - - - - - -extern "C++" char *strcasestr (char *__haystack, const char *__needle) - noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -extern "C++" const char *strcasestr (const char *__haystack, - const char *__needle) - noexcept (true) __asm ("strcasestr") __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); -# 389 "/usr/include/string.h" 3 4 -extern void *memmem (const void *__haystack, size_t __haystacklen, - const void *__needle, size_t __needlelen) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))) - - ; - - - -extern void *__mempcpy (void *__restrict __dest, - const void *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern void *mempcpy (void *__restrict __dest, - const void *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern size_t strlen (const char *__s) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - - - -extern size_t strnlen (const char *__string, size_t __maxlen) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - - - -extern char *strerror (int __errnum) noexcept (true); -# 444 "/usr/include/string.h" 3 4 -extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) - noexcept (true) __attribute__ ((__nonnull__ (2))) ; - - - - -extern const char *strerrordesc_np (int __err) noexcept (true); - -extern const char *strerrorname_np (int __err) noexcept (true); - - - - - -extern char *strerror_l (int __errnum, locale_t __l) noexcept (true); - - - -# 1 "/usr/include/strings.h" 1 3 4 -# 23 "/usr/include/strings.h" 3 4 -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 24 "/usr/include/strings.h" 2 3 4 - - - - - - -extern "C" { - - - -extern int bcmp (const void *__s1, const void *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern void bcopy (const void *__src, void *__dest, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern void bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))); -# 68 "/usr/include/strings.h" 3 4 -extern char *index (const char *__s, int __c) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); -# 96 "/usr/include/strings.h" 3 4 -extern char *rindex (const char *__s, int __c) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); - - - - - - -extern int ffs (int __i) noexcept (true) __attribute__ ((__const__)); - - - - - -extern int ffsl (long int __l) noexcept (true) __attribute__ ((__const__)); -__extension__ extern int ffsll (long long int __ll) - noexcept (true) __attribute__ ((__const__)); - - - -extern int strcasecmp (const char *__s1, const char *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern int strncasecmp (const char *__s1, const char *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - - - - - -extern int strcasecmp_l (const char *__s1, const char *__s2, locale_t __loc) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 3))); - - - -extern int strncasecmp_l (const char *__s1, const char *__s2, - size_t __n, locale_t __loc) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2, 4))); - - -} -# 463 "/usr/include/string.h" 2 3 4 - - - -extern void explicit_bzero (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) - ; - - - -extern char *strsep (char **__restrict __stringp, - const char *__restrict __delim) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern char *strsignal (int __sig) noexcept (true); - - - -extern const char *sigabbrev_np (int __sig) noexcept (true); - - -extern const char *sigdescr_np (int __sig) noexcept (true); - - - -extern char *__stpcpy (char *__restrict __dest, const char *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern char *stpcpy (char *__restrict __dest, const char *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern char *__stpncpy (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); -extern char *stpncpy (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - - -extern size_t strlcpy (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern size_t strlcat (char *__restrict __dest, - const char *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - - -extern int strverscmp (const char *__s1, const char *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - -extern char *strfry (char *__string) noexcept (true) __attribute__ ((__nonnull__ (1))); - - -extern void *memfrob (void *__s, size_t __n) noexcept (true) __attribute__ ((__nonnull__ (1))) - ; - - - - - - - -extern "C++" char *basename (char *__filename) - noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); -extern "C++" const char *basename (const char *__filename) - noexcept (true) __asm ("basename") __attribute__ ((__nonnull__ (1))); -# 552 "/usr/include/string.h" 3 4 -} -# 61 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - - - - -# 1 "/usr/include/wchar.h" 1 3 4 -# 27 "/usr/include/wchar.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/wchar.h" 2 3 4 - - - - - - - -# 1 "/usr/lib/clang/16/include/stddef.h" 1 3 4 -# 36 "/usr/include/wchar.h" 2 3 4 -# 51 "/usr/include/wchar.h" 3 4 -# 1 "/usr/include/bits/wchar.h" 1 3 4 -# 52 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/wint_t.h" 1 3 4 -# 20 "/usr/include/bits/types/wint_t.h" 3 4 -typedef unsigned int wint_t; -# 53 "/usr/include/wchar.h" 2 3 4 -# 1 "/usr/include/bits/types/mbstate_t.h" 1 3 4 - - - - - -typedef __mbstate_t mbstate_t; -# 54 "/usr/include/wchar.h" 2 3 4 -# 90 "/usr/include/wchar.h" 3 4 -extern "C" { - - - -struct tm; - - - -extern wchar_t *wcscpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern wchar_t *wcsncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - - -extern size_t wcslcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern size_t wcslcat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))) ; - - - -extern wchar_t *wcscat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - -extern wchar_t *wcsncat (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true) __attribute__ ((__nonnull__ (1, 2))); - - -extern int wcscmp (const wchar_t *__s1, const wchar_t *__s2) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - -extern int wcsncmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); - - - -extern int wcscasecmp (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - -extern int wcsncasecmp (const wchar_t *__s1, const wchar_t *__s2, - size_t __n) noexcept (true); - - - -extern int wcscasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - -extern int wcsncasecmp_l (const wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - - - -extern int wcscoll (const wchar_t *__s1, const wchar_t *__s2) noexcept (true); - - - -extern size_t wcsxfrm (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - - - - - -extern int wcscoll_l (const wchar_t *__s1, const wchar_t *__s2, - locale_t __loc) noexcept (true); - - - - -extern size_t wcsxfrm_l (wchar_t *__s1, const wchar_t *__s2, - size_t __n, locale_t __loc) noexcept (true); - - -extern wchar_t *wcsdup (const wchar_t *__s) noexcept (true) - __attribute__ ((__malloc__)) ; -# 189 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcschr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); -# 199 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsrchr (const wchar_t *__wcs, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern wchar_t *wcschrnul (const wchar_t *__s, wchar_t __wc) - noexcept (true) __attribute__ ((__pure__)); - - - - -extern size_t wcscspn (const wchar_t *__wcs, const wchar_t *__reject) - noexcept (true) __attribute__ ((__pure__)); - - -extern size_t wcsspn (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 226 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcspbrk (const wchar_t *__wcs, const wchar_t *__accept) - noexcept (true) __attribute__ ((__pure__)); -# 237 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcsstr (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - -extern wchar_t *wcstok (wchar_t *__restrict __s, - const wchar_t *__restrict __delim, - wchar_t **__restrict __ptr) noexcept (true); - - -extern size_t wcslen (const wchar_t *__s) noexcept (true) __attribute__ ((__pure__)); -# 258 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcswcs (const wchar_t *__haystack, const wchar_t *__needle) - noexcept (true) __attribute__ ((__pure__)); - - - - - -extern size_t wcsnlen (const wchar_t *__s, size_t __maxlen) - noexcept (true) __attribute__ ((__pure__)); -# 278 "/usr/include/wchar.h" 3 4 -extern wchar_t *wmemchr (const wchar_t *__s, wchar_t __c, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - - -extern int wmemcmp (const wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true) __attribute__ ((__pure__)); - - -extern wchar_t *wmemcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) noexcept (true); - - - -extern wchar_t *wmemmove (wchar_t *__s1, const wchar_t *__s2, size_t __n) - noexcept (true); - - -extern wchar_t *wmemset (wchar_t *__s, wchar_t __c, size_t __n) noexcept (true); - - - - -extern wchar_t *wmempcpy (wchar_t *__restrict __s1, - const wchar_t *__restrict __s2, size_t __n) - noexcept (true); - - - - - -extern wint_t btowc (int __c) noexcept (true); - - - -extern int wctob (wint_t __c) noexcept (true); - - - -extern int mbsinit (const mbstate_t *__ps) noexcept (true) __attribute__ ((__pure__)); - - - -extern size_t mbrtowc (wchar_t *__restrict __pwc, - const char *__restrict __s, size_t __n, - mbstate_t *__restrict __p) noexcept (true); - - -extern size_t wcrtomb (char *__restrict __s, wchar_t __wc, - mbstate_t *__restrict __ps) noexcept (true); - - -extern size_t __mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); -extern size_t mbrlen (const char *__restrict __s, size_t __n, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - - -extern wint_t __btowc_alias (int __c) __asm ("btowc"); -extern __inline __attribute__ ((__gnu_inline__)) wint_t - btowc (int __c) noexcept (true) -{ return (__builtin_constant_p (__c) && __c >= '\0' && __c <= '\x7f' - ? (wint_t) __c : __btowc_alias (__c)); } - -extern int __wctob_alias (wint_t __c) __asm ("wctob"); -extern __inline __attribute__ ((__gnu_inline__)) int - wctob (wint_t __wc) noexcept (true) -{ return (__builtin_constant_p (__wc) && __wc >= L'\0' && __wc <= L'\x7f' - ? (int) __wc : __wctob_alias (__wc)); } - -extern __inline __attribute__ ((__gnu_inline__)) size_t - mbrlen (const char *__restrict __s, size_t __n, mbstate_t *__restrict __ps) noexcept (true) - -{ return (__ps != __null - ? mbrtowc (__null, __s, __n, __ps) : __mbrlen (__s, __n, __null)); } - - - - -extern size_t mbsrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - -extern size_t mbsnrtowcs (wchar_t *__restrict __dst, - const char **__restrict __src, size_t __nmc, - size_t __len, mbstate_t *__restrict __ps) noexcept (true); - - - -extern size_t wcsnrtombs (char *__restrict __dst, - const wchar_t **__restrict __src, - size_t __nwc, size_t __len, - mbstate_t *__restrict __ps) noexcept (true); - - - - - - -extern int wcwidth (wchar_t __c) noexcept (true); - - - -extern int wcswidth (const wchar_t *__s, size_t __n) noexcept (true); - - - - - -extern double wcstod (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern float wcstof (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -extern long double wcstold (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 422 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64 wcstof64 (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 437 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); - - - -extern _Float64x wcstof64x (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr) noexcept (true); -# 455 "/usr/include/wchar.h" 3 4 -extern long int wcstol (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) noexcept (true); - - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base) noexcept (true); - - - - - - -extern long int wcstol (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstol"); - - -extern unsigned long int wcstoul (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoul"); - - - -__extension__ -extern long long int wcstoll (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - - -__extension__ -extern unsigned long long int wcstoull (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); - - - - -__extension__ -extern long long int wcstoq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoll"); - - -__extension__ -extern unsigned long long int wcstouq (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoull"); -# 561 "/usr/include/wchar.h" 3 4 -extern long int wcstol_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base, - locale_t __loc) noexcept (true); - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) noexcept (true); - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - int __base, locale_t __loc) - noexcept (true); - - - - - -extern long int wcstol_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstol_l"); - - - -extern unsigned long int wcstoul_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoul_l"); - - - - -__extension__ -extern long long int wcstoll_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoll_l"); - - - - -__extension__ -extern unsigned long long int wcstoull_l (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base, locale_t __loc) noexcept (true) __asm__ ("" "__isoc23_wcstoull_l"); -# 630 "/usr/include/wchar.h" 3 4 -extern double wcstod_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern float wcstof_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, locale_t __loc) - noexcept (true); - -extern long double wcstold_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 649 "/usr/include/wchar.h" 3 4 -extern _Float32 wcstof32_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64 wcstof64_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 667 "/usr/include/wchar.h" 3 4 -extern _Float32x wcstof32x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); - - - -extern _Float64x wcstof64x_l (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, - locale_t __loc) noexcept (true); -# 689 "/usr/include/wchar.h" 3 4 -extern wchar_t *wcpcpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src) noexcept (true); - - - -extern wchar_t *wcpncpy (wchar_t *__restrict __dest, - const wchar_t *__restrict __src, size_t __n) - noexcept (true); -# 718 "/usr/include/wchar.h" 3 4 -extern __FILE *open_wmemstream (wchar_t **__bufloc, size_t *__sizeloc) noexcept (true) - __attribute__ ((__malloc__)) ; - - - - - -extern int fwide (__FILE *__fp, int __mode) noexcept (true); - - - - - - -extern int fwprintf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wprintf (const wchar_t *__restrict __format, ...) - ; - -extern int swprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, ...) - noexcept (true) ; - - - - - -extern int vfwprintf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwprintf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - -extern int vswprintf (wchar_t *__restrict __s, size_t __n, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; - - - - - - -extern int fwscanf (__FILE *__restrict __stream, - const wchar_t *__restrict __format, ...) - ; - - - - -extern int wscanf (const wchar_t *__restrict __format, ...) - ; - -extern int swscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, ...) - noexcept (true) ; -# 795 "/usr/include/wchar.h" 3 4 -extern int fwscanf (__FILE *__restrict __stream, const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_fwscanf") - - - ; -extern int wscanf (const wchar_t *__restrict __format, ...) __asm__ ("" "__isoc23_wscanf") - - ; -extern int swscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, ...) noexcept (true) __asm__ ("" "__isoc23_swscanf") - - - ; -# 851 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - - - - -extern int vwscanf (const wchar_t *__restrict __format, - __gnuc_va_list __arg) - ; - -extern int vswscanf (const wchar_t *__restrict __s, - const wchar_t *__restrict __format, - __gnuc_va_list __arg) - noexcept (true) ; -# 875 "/usr/include/wchar.h" 3 4 -extern int vfwscanf (__FILE *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vfwscanf") - - - ; -extern int vwscanf (const wchar_t *__restrict __format, __gnuc_va_list __arg) __asm__ ("" "__isoc23_vwscanf") - - ; -extern int vswscanf (const wchar_t *__restrict __s, const wchar_t *__restrict __format, __gnuc_va_list __arg) noexcept (true) __asm__ ("" "__isoc23_vswscanf") - - - ; -# 935 "/usr/include/wchar.h" 3 4 -extern wint_t fgetwc (__FILE *__stream); -extern wint_t getwc (__FILE *__stream); - - - - - -extern wint_t getwchar (void); - - - - - - -extern wint_t fputwc (wchar_t __wc, __FILE *__stream); -extern wint_t putwc (wchar_t __wc, __FILE *__stream); - - - - - -extern wint_t putwchar (wchar_t __wc); - - - - - - - -extern wchar_t *fgetws (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - -extern int fputws (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern wint_t ungetwc (wint_t __wc, __FILE *__stream); -# 990 "/usr/include/wchar.h" 3 4 -extern wint_t getwc_unlocked (__FILE *__stream); -extern wint_t getwchar_unlocked (void); - - - - - - - -extern wint_t fgetwc_unlocked (__FILE *__stream); - - - - - - - -extern wint_t fputwc_unlocked (wchar_t __wc, __FILE *__stream); -# 1016 "/usr/include/wchar.h" 3 4 -extern wint_t putwc_unlocked (wchar_t __wc, __FILE *__stream); -extern wint_t putwchar_unlocked (wchar_t __wc); -# 1026 "/usr/include/wchar.h" 3 4 -extern wchar_t *fgetws_unlocked (wchar_t *__restrict __ws, int __n, - __FILE *__restrict __stream); - - - - - - - -extern int fputws_unlocked (const wchar_t *__restrict __ws, - __FILE *__restrict __stream); - - - - - - -extern size_t wcsftime (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp) noexcept (true); - - - - -extern size_t wcsftime_l (wchar_t *__restrict __s, size_t __maxsize, - const wchar_t *__restrict __format, - const struct tm *__restrict __tp, - locale_t __loc) noexcept (true); -# 1073 "/usr/include/wchar.h" 3 4 -} -# 67 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - -# 1 "/usr/lib/clang/16/include/inttypes.h" 1 3 4 -# 21 "/usr/lib/clang/16/include/inttypes.h" 3 4 -# 1 "/usr/include/inttypes.h" 1 3 4 -# 27 "/usr/include/inttypes.h" 3 4 -# 1 "/usr/lib/clang/16/include/stdint.h" 1 3 4 -# 52 "/usr/lib/clang/16/include/stdint.h" 3 4 -# 1 "/usr/include/stdint.h" 1 3 4 -# 26 "/usr/include/stdint.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 27 "/usr/include/stdint.h" 2 3 4 - - -# 1 "/usr/include/bits/wordsize.h" 1 3 4 -# 30 "/usr/include/stdint.h" 2 3 4 - - - - - - - -# 1 "/usr/include/bits/stdint-uintn.h" 1 3 4 -# 24 "/usr/include/bits/stdint-uintn.h" 3 4 -typedef __uint8_t uint8_t; -typedef __uint16_t uint16_t; -typedef __uint32_t uint32_t; -typedef __uint64_t uint64_t; -# 38 "/usr/include/stdint.h" 2 3 4 - - - - - -typedef __int_least8_t int_least8_t; -typedef __int_least16_t int_least16_t; -typedef __int_least32_t int_least32_t; -typedef __int_least64_t int_least64_t; - - -typedef __uint_least8_t uint_least8_t; -typedef __uint_least16_t uint_least16_t; -typedef __uint_least32_t uint_least32_t; -typedef __uint_least64_t uint_least64_t; - - - - - -typedef signed char int_fast8_t; - -typedef long int int_fast16_t; -typedef long int int_fast32_t; -typedef long int int_fast64_t; -# 71 "/usr/include/stdint.h" 3 4 -typedef unsigned char uint_fast8_t; - -typedef unsigned long int uint_fast16_t; -typedef unsigned long int uint_fast32_t; -typedef unsigned long int uint_fast64_t; -# 87 "/usr/include/stdint.h" 3 4 -typedef long int intptr_t; - - -typedef unsigned long int uintptr_t; -# 101 "/usr/include/stdint.h" 3 4 -typedef __intmax_t intmax_t; -typedef __uintmax_t uintmax_t; -# 53 "/usr/lib/clang/16/include/stdint.h" 2 3 4 -# 28 "/usr/include/inttypes.h" 2 3 4 -# 327 "/usr/include/inttypes.h" 3 4 -extern "C" { - - - - -typedef struct - { - long int quot; - long int rem; - } imaxdiv_t; -# 351 "/usr/include/inttypes.h" 3 4 -extern intmax_t imaxabs (intmax_t __n) noexcept (true) __attribute__ ((__const__)); - - -extern imaxdiv_t imaxdiv (intmax_t __numer, intmax_t __denom) - noexcept (true) __attribute__ ((__const__)); - - -extern intmax_t strtoimax (const char *__restrict __nptr, - char **__restrict __endptr, int __base) noexcept (true); - - -extern uintmax_t strtoumax (const char *__restrict __nptr, - char ** __restrict __endptr, int __base) noexcept (true); - - -extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, - wchar_t **__restrict __endptr, int __base) - noexcept (true); - - -extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, - wchar_t ** __restrict __endptr, int __base) - noexcept (true); - - - - - -extern intmax_t strtoimax (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoimax"); - - -extern uintmax_t strtoumax (const char *__restrict __nptr, char **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_strtoumax"); - - -extern intmax_t wcstoimax (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoimax"); - - - -extern uintmax_t wcstoumax (const wchar_t *__restrict __nptr, wchar_t **__restrict __endptr, int __base) noexcept (true) __asm__ ("" "__isoc23_wcstoumax"); -# 415 "/usr/include/inttypes.h" 3 4 -} -# 22 "/usr/lib/clang/16/include/inttypes.h" 2 3 4 -# 70 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 - - - - -# 1 "/usr/include/ctype.h" 1 3 4 -# 28 "/usr/include/ctype.h" 3 4 -extern "C" { -# 46 "/usr/include/ctype.h" 3 4 -enum -{ - _ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)), - _ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)), - _ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)), - _ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)), - _ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)), - _ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)), - _ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)), - _ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)), - _ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)), - _IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)), - _ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)), - _ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8)) -}; -# 79 "/usr/include/ctype.h" 3 4 -extern const unsigned short int **__ctype_b_loc (void) - noexcept (true) __attribute__ ((__const__)); -extern const __int32_t **__ctype_tolower_loc (void) - noexcept (true) __attribute__ ((__const__)); -extern const __int32_t **__ctype_toupper_loc (void) - noexcept (true) __attribute__ ((__const__)); -# 108 "/usr/include/ctype.h" 3 4 -extern int isalnum (int) noexcept (true); -extern int isalpha (int) noexcept (true); -extern int iscntrl (int) noexcept (true); -extern int isdigit (int) noexcept (true); -extern int islower (int) noexcept (true); -extern int isgraph (int) noexcept (true); -extern int isprint (int) noexcept (true); -extern int ispunct (int) noexcept (true); -extern int isspace (int) noexcept (true); -extern int isupper (int) noexcept (true); -extern int isxdigit (int) noexcept (true); - - - -extern int tolower (int __c) noexcept (true); - - -extern int toupper (int __c) noexcept (true); - - - - -extern int isblank (int) noexcept (true); - - - - -extern int isctype (int __c, int __mask) noexcept (true); - - - - - - -extern int isascii (int __c) noexcept (true); - - - -extern int toascii (int __c) noexcept (true); - - - -extern int _toupper (int) noexcept (true); -extern int _tolower (int) noexcept (true); -# 251 "/usr/include/ctype.h" 3 4 -extern int isalnum_l (int, locale_t) noexcept (true); -extern int isalpha_l (int, locale_t) noexcept (true); -extern int iscntrl_l (int, locale_t) noexcept (true); -extern int isdigit_l (int, locale_t) noexcept (true); -extern int islower_l (int, locale_t) noexcept (true); -extern int isgraph_l (int, locale_t) noexcept (true); -extern int isprint_l (int, locale_t) noexcept (true); -extern int ispunct_l (int, locale_t) noexcept (true); -extern int isspace_l (int, locale_t) noexcept (true); -extern int isupper_l (int, locale_t) noexcept (true); -extern int isxdigit_l (int, locale_t) noexcept (true); - -extern int isblank_l (int, locale_t) noexcept (true); - - - -extern int __tolower_l (int __c, locale_t __l) noexcept (true); -extern int tolower_l (int __c, locale_t __l) noexcept (true); - - -extern int __toupper_l (int __c, locale_t __l) noexcept (true); -extern int toupper_l (int __c, locale_t __l) noexcept (true); -# 327 "/usr/include/ctype.h" 3 4 -} -# 75 "/usr/include/SDL2/SDL_stdinc.h" 2 3 4 -# 86 "/usr/include/SDL2/SDL_stdinc.h" 3 4 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/math.h" 1 3 4 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/math.h" 3 4 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 1 3 4 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/requires_hosted.h" 1 3 -# 42 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 1 3 -# 36 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 -extern "C++" { - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - struct __true_type { }; - struct __false_type { }; - - template - struct __truth_type - { typedef __false_type __type; }; - - template<> - struct __truth_type - { typedef __true_type __type; }; - - - - template - struct __traitor - { - enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; - typedef typename __truth_type<__value>::__type __type; - }; - - - template - struct __are_same - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __are_same<_Tp, _Tp> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_void - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_void - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_integer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 184 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_integer - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 289 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; - }; -# 366 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template - struct __is_pointer - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template - struct __is_pointer<_Tp*> - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - - - template - struct __is_arithmetic - : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > - { }; - - - - - template - struct __is_scalar - : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > - { }; - - - - - template - struct __is_char - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template<> - struct __is_char - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - template - struct __is_byte - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - - enum class byte : unsigned char; - - template<> - struct __is_byte - { - enum { __value = 1 }; - typedef __true_type __type; - }; -# 470 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template struct iterator_traits; - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = __is_trivially_copyable(_Tp) }; - }; - - - - - template - struct __is_nonvolatile_trivially_copyable - { - enum { __value = 0 }; - }; - - - template - struct __memcpyable - { - enum { __value = 0 }; - }; - - template - struct __memcpyable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcpyable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - template - struct __memcmpable - { - enum { __value = 0 }; - }; - - - template - struct __memcmpable<_Tp*, _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - template - struct __memcmpable<_Tp*, const _Tp*> - : __is_nonvolatile_trivially_copyable<_Tp> - { }; - - - - - - - - template::__value - - > - struct __is_memcmp_ordered - { - static const bool __value = _Tp(-1) > _Tp(1); - }; - - template - struct __is_memcmp_ordered<_Tp, false> - { - static const bool __value = false; - }; - - - template - struct __is_memcmp_ordered_with - { - static const bool __value = __is_memcmp_ordered<_Tp>::__value - && __is_memcmp_ordered<_Up>::__value; - }; - - template - struct __is_memcmp_ordered_with<_Tp, _Up, false> - { - static const bool __value = false; - }; -# 579 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/cpp_type_traits.h" 3 - template<> - struct __is_memcmp_ordered_with - { static constexpr bool __value = true; }; - - template - struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize> - { static constexpr bool __value = false; }; - - template - struct __is_memcmp_ordered_with - { static constexpr bool __value = false; }; - - - - - - template - struct __is_move_iterator - { - enum { __value = 0 }; - typedef __false_type __type; - }; - - - - template - - inline _Iterator - __miter_base(_Iterator __it) - { return __it; } - - -} -} -# 45 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - - - - -extern "C++" { - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct __enable_if - { }; - - template - struct __enable_if - { typedef _Tp __type; }; - - - - template - struct __conditional_type - { typedef _Iftrue __type; }; - - template - struct __conditional_type - { typedef _Iffalse __type; }; - - - - template - struct __add_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned char __type; }; - - template<> - struct __add_unsigned - { typedef unsigned short __type; }; - - template<> - struct __add_unsigned - { typedef unsigned int __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long __type; }; - - template<> - struct __add_unsigned - { typedef unsigned long long __type; }; - - - template<> - struct __add_unsigned; - - template<> - struct __add_unsigned; - - - - template - struct __remove_unsigned - { - private: - typedef __enable_if::__value, _Tp> __if_type; - - public: - typedef typename __if_type::__type __type; - }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef signed char __type; }; - - template<> - struct __remove_unsigned - { typedef short __type; }; - - template<> - struct __remove_unsigned - { typedef int __type; }; - - template<> - struct __remove_unsigned - { typedef long __type; }; - - template<> - struct __remove_unsigned - { typedef long long __type; }; - - - template<> - struct __remove_unsigned; - - template<> - struct __remove_unsigned; - - - - template - constexpr - inline bool - __is_null_pointer(_Type* __ptr) - { return __ptr == 0; } - - template - constexpr - inline bool - __is_null_pointer(_Type) - { return false; } - - - constexpr bool - __is_null_pointer(std::nullptr_t) - { return true; } - - - - - template::__value> - struct __promote - { typedef double __type; }; - - - - - template - struct __promote<_Tp, false> - { }; - - template<> - struct __promote - { typedef long double __type; }; - - template<> - struct __promote - { typedef double __type; }; - - template<> - struct __promote - { typedef float __type; }; -# 225 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 - template - using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...)); - - - - template - using __promote_2 = __promote<__promoted_t<_Tp, _Up>>; - - template - using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>; - - template - using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/type_traits.h" 3 -} -} -# 46 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 - -# 1 "/usr/include/math.h" 1 3 4 -# 27 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/libc-header-start.h" 1 3 4 -# 28 "/usr/include/math.h" 2 3 4 - - - - - - -extern "C" { - - - - - -# 1 "/usr/include/bits/math-vector.h" 1 3 4 -# 25 "/usr/include/bits/math-vector.h" 3 4 -# 1 "/usr/include/bits/libm-simd-decl-stubs.h" 1 3 4 -# 26 "/usr/include/bits/math-vector.h" 2 3 4 -# 41 "/usr/include/math.h" 2 3 4 -# 152 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/flt-eval-method.h" 1 3 4 -# 153 "/usr/include/math.h" 2 3 4 -# 163 "/usr/include/math.h" 3 4 -typedef float float_t; -typedef double double_t; -# 204 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/fp-logb.h" 1 3 4 -# 205 "/usr/include/math.h" 2 3 4 -# 247 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/fp-fast.h" 1 3 4 -# 248 "/usr/include/math.h" 2 3 4 - - - -enum - { - FP_INT_UPWARD = - - 0, - FP_INT_DOWNWARD = - - 1, - FP_INT_TOWARDZERO = - - 2, - FP_INT_TONEARESTFROMZERO = - - 3, - FP_INT_TONEAREST = - - 4, - }; -# 312 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 -# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 -extern int __fpclassify (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __signbit (double __value) noexcept (true) - __attribute__ ((__const__)); - - - -extern int __isinf (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __finite (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __isnan (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __iseqsig (double __x, double __y) noexcept (true); - - -extern int __issignaling (double __value) noexcept (true) - __attribute__ ((__const__)); -# 313 "/usr/include/math.h" 2 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern double acos (double __x) noexcept (true); extern double __acos (double __x) noexcept (true); - - extern double asin (double __x) noexcept (true); extern double __asin (double __x) noexcept (true); - - extern double atan (double __x) noexcept (true); extern double __atan (double __x) noexcept (true); - - extern double atan2 (double __y, double __x) noexcept (true); extern double __atan2 (double __y, double __x) noexcept (true); - - - extern double cos (double __x) noexcept (true); extern double __cos (double __x) noexcept (true); - - extern double sin (double __x) noexcept (true); extern double __sin (double __x) noexcept (true); - - extern double tan (double __x) noexcept (true); extern double __tan (double __x) noexcept (true); - - - - - extern double cosh (double __x) noexcept (true); extern double __cosh (double __x) noexcept (true); - - extern double sinh (double __x) noexcept (true); extern double __sinh (double __x) noexcept (true); - - extern double tanh (double __x) noexcept (true); extern double __tanh (double __x) noexcept (true); - - - - extern void sincos (double __x, double *__sinx, double *__cosx) noexcept (true); extern void __sincos (double __x, double *__sinx, double *__cosx) noexcept (true); - - - - - - extern double acosh (double __x) noexcept (true); extern double __acosh (double __x) noexcept (true); - - extern double asinh (double __x) noexcept (true); extern double __asinh (double __x) noexcept (true); - - extern double atanh (double __x) noexcept (true); extern double __atanh (double __x) noexcept (true); - - - - - - extern double exp (double __x) noexcept (true); extern double __exp (double __x) noexcept (true); - - -extern double frexp (double __x, int *__exponent) noexcept (true); extern double __frexp (double __x, int *__exponent) noexcept (true); - - -extern double ldexp (double __x, int __exponent) noexcept (true); extern double __ldexp (double __x, int __exponent) noexcept (true); - - - extern double log (double __x) noexcept (true); extern double __log (double __x) noexcept (true); - - - extern double log10 (double __x) noexcept (true); extern double __log10 (double __x) noexcept (true); - - -extern double modf (double __x, double *__iptr) noexcept (true); extern double __modf (double __x, double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern double exp10 (double __x) noexcept (true); extern double __exp10 (double __x) noexcept (true); - - - - - extern double expm1 (double __x) noexcept (true); extern double __expm1 (double __x) noexcept (true); - - - extern double log1p (double __x) noexcept (true); extern double __log1p (double __x) noexcept (true); - - -extern double logb (double __x) noexcept (true); extern double __logb (double __x) noexcept (true); - - - - - extern double exp2 (double __x) noexcept (true); extern double __exp2 (double __x) noexcept (true); - - - extern double log2 (double __x) noexcept (true); extern double __log2 (double __x) noexcept (true); - - - - - - - extern double pow (double __x, double __y) noexcept (true); extern double __pow (double __x, double __y) noexcept (true); - - -extern double sqrt (double __x) noexcept (true); extern double __sqrt (double __x) noexcept (true); - - - - extern double hypot (double __x, double __y) noexcept (true); extern double __hypot (double __x, double __y) noexcept (true); - - - - - extern double cbrt (double __x) noexcept (true); extern double __cbrt (double __x) noexcept (true); - - - - - - -extern double ceil (double __x) noexcept (true) __attribute__ ((__const__)); extern double __ceil (double __x) noexcept (true) __attribute__ ((__const__)); - - -extern double fabs (double __x) noexcept (true) __attribute__ ((__const__)); extern double __fabs (double __x) noexcept (true) __attribute__ ((__const__)); - - -extern double floor (double __x) noexcept (true) __attribute__ ((__const__)); extern double __floor (double __x) noexcept (true) __attribute__ ((__const__)); - - -extern double fmod (double __x, double __y) noexcept (true); extern double __fmod (double __x, double __y) noexcept (true); -# 183 "/usr/include/bits/mathcalls.h" 3 4 -extern int finite (double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern double drem (double __x, double __y) noexcept (true); extern double __drem (double __x, double __y) noexcept (true); - - - -extern double significand (double __x) noexcept (true); extern double __significand (double __x) noexcept (true); - - - - - - -extern double copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __copysign (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern double nan (const char *__tagb) noexcept (true); extern double __nan (const char *__tagb) noexcept (true); -# 220 "/usr/include/bits/mathcalls.h" 3 4 -extern double j0 (double) noexcept (true); extern double __j0 (double) noexcept (true); -extern double j1 (double) noexcept (true); extern double __j1 (double) noexcept (true); -extern double jn (int, double) noexcept (true); extern double __jn (int, double) noexcept (true); -extern double y0 (double) noexcept (true); extern double __y0 (double) noexcept (true); -extern double y1 (double) noexcept (true); extern double __y1 (double) noexcept (true); -extern double yn (int, double) noexcept (true); extern double __yn (int, double) noexcept (true); - - - - - - extern double erf (double) noexcept (true); extern double __erf (double) noexcept (true); - extern double erfc (double) noexcept (true); extern double __erfc (double) noexcept (true); -extern double lgamma (double) noexcept (true); extern double __lgamma (double) noexcept (true); - - - - -extern double tgamma (double) noexcept (true); extern double __tgamma (double) noexcept (true); - - - - - -extern double gamma (double) noexcept (true); extern double __gamma (double) noexcept (true); - - - - - - - -extern double lgamma_r (double, int *__signgamp) noexcept (true); extern double __lgamma_r (double, int *__signgamp) noexcept (true); - - - - - - -extern double rint (double __x) noexcept (true); extern double __rint (double __x) noexcept (true); - - -extern double nextafter (double __x, double __y) noexcept (true); extern double __nextafter (double __x, double __y) noexcept (true); - -extern double nexttoward (double __x, long double __y) noexcept (true); extern double __nexttoward (double __x, long double __y) noexcept (true); - - - - -extern double nextdown (double __x) noexcept (true); extern double __nextdown (double __x) noexcept (true); - -extern double nextup (double __x) noexcept (true); extern double __nextup (double __x) noexcept (true); - - - -extern double remainder (double __x, double __y) noexcept (true); extern double __remainder (double __x, double __y) noexcept (true); - - - -extern double scalbn (double __x, int __n) noexcept (true); extern double __scalbn (double __x, int __n) noexcept (true); - - - -extern int ilogb (double __x) noexcept (true); extern int __ilogb (double __x) noexcept (true); - - - - -extern long int llogb (double __x) noexcept (true); extern long int __llogb (double __x) noexcept (true); - - - - -extern double scalbln (double __x, long int __n) noexcept (true); extern double __scalbln (double __x, long int __n) noexcept (true); - - - -extern double nearbyint (double __x) noexcept (true); extern double __nearbyint (double __x) noexcept (true); - - - -extern double round (double __x) noexcept (true) __attribute__ ((__const__)); extern double __round (double __x) noexcept (true) __attribute__ ((__const__)); - - - -extern double trunc (double __x) noexcept (true) __attribute__ ((__const__)); extern double __trunc (double __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern double remquo (double __x, double __y, int *__quo) noexcept (true); extern double __remquo (double __x, double __y, int *__quo) noexcept (true); - - - - - - -extern long int lrint (double __x) noexcept (true); extern long int __lrint (double __x) noexcept (true); -__extension__ -extern long long int llrint (double __x) noexcept (true); extern long long int __llrint (double __x) noexcept (true); - - - -extern long int lround (double __x) noexcept (true); extern long int __lround (double __x) noexcept (true); -__extension__ -extern long long int llround (double __x) noexcept (true); extern long long int __llround (double __x) noexcept (true); - - - -extern double fdim (double __x, double __y) noexcept (true); extern double __fdim (double __x, double __y) noexcept (true); - - - -extern double fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmax (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmin (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - - -extern double fma (double __x, double __y, double __z) noexcept (true); extern double __fma (double __x, double __y, double __z) noexcept (true); - - - - -extern double roundeven (double __x) noexcept (true) __attribute__ ((__const__)); extern double __roundeven (double __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfp (double __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfp (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfp (double __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpx (double __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpx (double __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalize (double *__cx, const double *__x) noexcept (true); - - - - - - -extern double fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaxmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminmag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern double fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fmaximum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - -extern double fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); extern double __fminimum_mag_num (double __x, double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorder (const double *__x, const double *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermag (const double *__x, const double *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern double getpayload (const double *__x) noexcept (true); extern double __getpayload (const double *__x) noexcept (true); - - -extern int setpayload (double *__x, double __payload) noexcept (true); - - -extern int setpayloadsig (double *__x, double __payload) noexcept (true); - - - - - - - -extern double scalb (double __x, double __n) noexcept (true); extern double __scalb (double __x, double __n) noexcept (true); -# 314 "/usr/include/math.h" 2 3 4 -# 329 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 -# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 -extern int __fpclassifyf (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __signbitf (float __value) noexcept (true) - __attribute__ ((__const__)); - - - -extern int __isinff (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __finitef (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __isnanf (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __iseqsigf (float __x, float __y) noexcept (true); - - -extern int __issignalingf (float __value) noexcept (true) - __attribute__ ((__const__)); -# 330 "/usr/include/math.h" 2 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern float acosf (float __x) noexcept (true); extern float __acosf (float __x) noexcept (true); - - extern float asinf (float __x) noexcept (true); extern float __asinf (float __x) noexcept (true); - - extern float atanf (float __x) noexcept (true); extern float __atanf (float __x) noexcept (true); - - extern float atan2f (float __y, float __x) noexcept (true); extern float __atan2f (float __y, float __x) noexcept (true); - - - extern float cosf (float __x) noexcept (true); extern float __cosf (float __x) noexcept (true); - - extern float sinf (float __x) noexcept (true); extern float __sinf (float __x) noexcept (true); - - extern float tanf (float __x) noexcept (true); extern float __tanf (float __x) noexcept (true); - - - - - extern float coshf (float __x) noexcept (true); extern float __coshf (float __x) noexcept (true); - - extern float sinhf (float __x) noexcept (true); extern float __sinhf (float __x) noexcept (true); - - extern float tanhf (float __x) noexcept (true); extern float __tanhf (float __x) noexcept (true); - - - - extern void sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); extern void __sincosf (float __x, float *__sinx, float *__cosx) noexcept (true); - - - - - - extern float acoshf (float __x) noexcept (true); extern float __acoshf (float __x) noexcept (true); - - extern float asinhf (float __x) noexcept (true); extern float __asinhf (float __x) noexcept (true); - - extern float atanhf (float __x) noexcept (true); extern float __atanhf (float __x) noexcept (true); - - - - - - extern float expf (float __x) noexcept (true); extern float __expf (float __x) noexcept (true); - - -extern float frexpf (float __x, int *__exponent) noexcept (true); extern float __frexpf (float __x, int *__exponent) noexcept (true); - - -extern float ldexpf (float __x, int __exponent) noexcept (true); extern float __ldexpf (float __x, int __exponent) noexcept (true); - - - extern float logf (float __x) noexcept (true); extern float __logf (float __x) noexcept (true); - - - extern float log10f (float __x) noexcept (true); extern float __log10f (float __x) noexcept (true); - - -extern float modff (float __x, float *__iptr) noexcept (true); extern float __modff (float __x, float *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern float exp10f (float __x) noexcept (true); extern float __exp10f (float __x) noexcept (true); - - - - - extern float expm1f (float __x) noexcept (true); extern float __expm1f (float __x) noexcept (true); - - - extern float log1pf (float __x) noexcept (true); extern float __log1pf (float __x) noexcept (true); - - -extern float logbf (float __x) noexcept (true); extern float __logbf (float __x) noexcept (true); - - - - - extern float exp2f (float __x) noexcept (true); extern float __exp2f (float __x) noexcept (true); - - - extern float log2f (float __x) noexcept (true); extern float __log2f (float __x) noexcept (true); - - - - - - - extern float powf (float __x, float __y) noexcept (true); extern float __powf (float __x, float __y) noexcept (true); - - -extern float sqrtf (float __x) noexcept (true); extern float __sqrtf (float __x) noexcept (true); - - - - extern float hypotf (float __x, float __y) noexcept (true); extern float __hypotf (float __x, float __y) noexcept (true); - - - - - extern float cbrtf (float __x) noexcept (true); extern float __cbrtf (float __x) noexcept (true); - - - - - - -extern float ceilf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __ceilf (float __x) noexcept (true) __attribute__ ((__const__)); - - -extern float fabsf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __fabsf (float __x) noexcept (true) __attribute__ ((__const__)); - - -extern float floorf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __floorf (float __x) noexcept (true) __attribute__ ((__const__)); - - -extern float fmodf (float __x, float __y) noexcept (true); extern float __fmodf (float __x, float __y) noexcept (true); -# 177 "/usr/include/bits/mathcalls.h" 3 4 -extern int isinff (float __value) noexcept (true) - __attribute__ ((__const__)); - - - - -extern int finitef (float __value) noexcept (true) - __attribute__ ((__const__)); - - -extern float dremf (float __x, float __y) noexcept (true); extern float __dremf (float __x, float __y) noexcept (true); - - - -extern float significandf (float __x) noexcept (true); extern float __significandf (float __x) noexcept (true); - - - - - - -extern float copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern float nanf (const char *__tagb) noexcept (true); extern float __nanf (const char *__tagb) noexcept (true); -# 213 "/usr/include/bits/mathcalls.h" 3 4 -extern int isnanf (float __value) noexcept (true) - __attribute__ ((__const__)); - - - - - -extern float j0f (float) noexcept (true); extern float __j0f (float) noexcept (true); -extern float j1f (float) noexcept (true); extern float __j1f (float) noexcept (true); -extern float jnf (int, float) noexcept (true); extern float __jnf (int, float) noexcept (true); -extern float y0f (float) noexcept (true); extern float __y0f (float) noexcept (true); -extern float y1f (float) noexcept (true); extern float __y1f (float) noexcept (true); -extern float ynf (int, float) noexcept (true); extern float __ynf (int, float) noexcept (true); - - - - - - extern float erff (float) noexcept (true); extern float __erff (float) noexcept (true); - extern float erfcf (float) noexcept (true); extern float __erfcf (float) noexcept (true); -extern float lgammaf (float) noexcept (true); extern float __lgammaf (float) noexcept (true); - - - - -extern float tgammaf (float) noexcept (true); extern float __tgammaf (float) noexcept (true); - - - - - -extern float gammaf (float) noexcept (true); extern float __gammaf (float) noexcept (true); - - - - - - - -extern float lgammaf_r (float, int *__signgamp) noexcept (true); extern float __lgammaf_r (float, int *__signgamp) noexcept (true); - - - - - - -extern float rintf (float __x) noexcept (true); extern float __rintf (float __x) noexcept (true); - - -extern float nextafterf (float __x, float __y) noexcept (true); extern float __nextafterf (float __x, float __y) noexcept (true); - -extern float nexttowardf (float __x, long double __y) noexcept (true); extern float __nexttowardf (float __x, long double __y) noexcept (true); - - - - -extern float nextdownf (float __x) noexcept (true); extern float __nextdownf (float __x) noexcept (true); - -extern float nextupf (float __x) noexcept (true); extern float __nextupf (float __x) noexcept (true); - - - -extern float remainderf (float __x, float __y) noexcept (true); extern float __remainderf (float __x, float __y) noexcept (true); - - - -extern float scalbnf (float __x, int __n) noexcept (true); extern float __scalbnf (float __x, int __n) noexcept (true); - - - -extern int ilogbf (float __x) noexcept (true); extern int __ilogbf (float __x) noexcept (true); - - - - -extern long int llogbf (float __x) noexcept (true); extern long int __llogbf (float __x) noexcept (true); - - - - -extern float scalblnf (float __x, long int __n) noexcept (true); extern float __scalblnf (float __x, long int __n) noexcept (true); - - - -extern float nearbyintf (float __x) noexcept (true); extern float __nearbyintf (float __x) noexcept (true); - - - -extern float roundf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundf (float __x) noexcept (true) __attribute__ ((__const__)); - - - -extern float truncf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __truncf (float __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern float remquof (float __x, float __y, int *__quo) noexcept (true); extern float __remquof (float __x, float __y, int *__quo) noexcept (true); - - - - - - -extern long int lrintf (float __x) noexcept (true); extern long int __lrintf (float __x) noexcept (true); -__extension__ -extern long long int llrintf (float __x) noexcept (true); extern long long int __llrintf (float __x) noexcept (true); - - - -extern long int lroundf (float __x) noexcept (true); extern long int __lroundf (float __x) noexcept (true); -__extension__ -extern long long int llroundf (float __x) noexcept (true); extern long long int __llroundf (float __x) noexcept (true); - - - -extern float fdimf (float __x, float __y) noexcept (true); extern float __fdimf (float __x, float __y) noexcept (true); - - - -extern float fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - - -extern float fmaf (float __x, float __y, float __z) noexcept (true); extern float __fmaf (float __x, float __y, float __z) noexcept (true); - - - - -extern float roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); extern float __roundevenf (float __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf (float __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf (float __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf (float __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf (float __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalizef (float *__cx, const float *__x) noexcept (true); - - - - - - -extern float fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaxmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminmagf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern float fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimumf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_magf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fmaximum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - -extern float fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); extern float __fminimum_mag_numf (float __x, float __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorderf (const float *__x, const float *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermagf (const float *__x, const float *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern float getpayloadf (const float *__x) noexcept (true); extern float __getpayloadf (const float *__x) noexcept (true); - - -extern int setpayloadf (float *__x, float __payload) noexcept (true); - - -extern int setpayloadsigf (float *__x, float __payload) noexcept (true); - - - - - - - -extern float scalbf (float __x, float __n) noexcept (true); extern float __scalbf (float __x, float __n) noexcept (true); -# 331 "/usr/include/math.h" 2 3 4 -# 398 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-helper-functions.h" 1 3 4 -# 20 "/usr/include/bits/mathcalls-helper-functions.h" 3 4 -extern int __fpclassifyl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __signbitl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - - -extern int __isinfl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __finitel (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __isnanl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern int __iseqsigl (long double __x, long double __y) noexcept (true); - - -extern int __issignalingl (long double __value) noexcept (true) - __attribute__ ((__const__)); -# 399 "/usr/include/math.h" 2 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern long double acosl (long double __x) noexcept (true); extern long double __acosl (long double __x) noexcept (true); - - extern long double asinl (long double __x) noexcept (true); extern long double __asinl (long double __x) noexcept (true); - - extern long double atanl (long double __x) noexcept (true); extern long double __atanl (long double __x) noexcept (true); - - extern long double atan2l (long double __y, long double __x) noexcept (true); extern long double __atan2l (long double __y, long double __x) noexcept (true); - - - extern long double cosl (long double __x) noexcept (true); extern long double __cosl (long double __x) noexcept (true); - - extern long double sinl (long double __x) noexcept (true); extern long double __sinl (long double __x) noexcept (true); - - extern long double tanl (long double __x) noexcept (true); extern long double __tanl (long double __x) noexcept (true); - - - - - extern long double coshl (long double __x) noexcept (true); extern long double __coshl (long double __x) noexcept (true); - - extern long double sinhl (long double __x) noexcept (true); extern long double __sinhl (long double __x) noexcept (true); - - extern long double tanhl (long double __x) noexcept (true); extern long double __tanhl (long double __x) noexcept (true); - - - - extern void sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); extern void __sincosl (long double __x, long double *__sinx, long double *__cosx) noexcept (true); - - - - - - extern long double acoshl (long double __x) noexcept (true); extern long double __acoshl (long double __x) noexcept (true); - - extern long double asinhl (long double __x) noexcept (true); extern long double __asinhl (long double __x) noexcept (true); - - extern long double atanhl (long double __x) noexcept (true); extern long double __atanhl (long double __x) noexcept (true); - - - - - - extern long double expl (long double __x) noexcept (true); extern long double __expl (long double __x) noexcept (true); - - -extern long double frexpl (long double __x, int *__exponent) noexcept (true); extern long double __frexpl (long double __x, int *__exponent) noexcept (true); - - -extern long double ldexpl (long double __x, int __exponent) noexcept (true); extern long double __ldexpl (long double __x, int __exponent) noexcept (true); - - - extern long double logl (long double __x) noexcept (true); extern long double __logl (long double __x) noexcept (true); - - - extern long double log10l (long double __x) noexcept (true); extern long double __log10l (long double __x) noexcept (true); - - -extern long double modfl (long double __x, long double *__iptr) noexcept (true); extern long double __modfl (long double __x, long double *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern long double exp10l (long double __x) noexcept (true); extern long double __exp10l (long double __x) noexcept (true); - - - - - extern long double expm1l (long double __x) noexcept (true); extern long double __expm1l (long double __x) noexcept (true); - - - extern long double log1pl (long double __x) noexcept (true); extern long double __log1pl (long double __x) noexcept (true); - - -extern long double logbl (long double __x) noexcept (true); extern long double __logbl (long double __x) noexcept (true); - - - - - extern long double exp2l (long double __x) noexcept (true); extern long double __exp2l (long double __x) noexcept (true); - - - extern long double log2l (long double __x) noexcept (true); extern long double __log2l (long double __x) noexcept (true); - - - - - - - extern long double powl (long double __x, long double __y) noexcept (true); extern long double __powl (long double __x, long double __y) noexcept (true); - - -extern long double sqrtl (long double __x) noexcept (true); extern long double __sqrtl (long double __x) noexcept (true); - - - - extern long double hypotl (long double __x, long double __y) noexcept (true); extern long double __hypotl (long double __x, long double __y) noexcept (true); - - - - - extern long double cbrtl (long double __x) noexcept (true); extern long double __cbrtl (long double __x) noexcept (true); - - - - - - -extern long double ceill (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __ceill (long double __x) noexcept (true) __attribute__ ((__const__)); - - -extern long double fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __fabsl (long double __x) noexcept (true) __attribute__ ((__const__)); - - -extern long double floorl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __floorl (long double __x) noexcept (true) __attribute__ ((__const__)); - - -extern long double fmodl (long double __x, long double __y) noexcept (true); extern long double __fmodl (long double __x, long double __y) noexcept (true); -# 177 "/usr/include/bits/mathcalls.h" 3 4 -extern int isinfl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - - - -extern int finitel (long double __value) noexcept (true) - __attribute__ ((__const__)); - - -extern long double dreml (long double __x, long double __y) noexcept (true); extern long double __dreml (long double __x, long double __y) noexcept (true); - - - -extern long double significandl (long double __x) noexcept (true); extern long double __significandl (long double __x) noexcept (true); - - - - - - -extern long double copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __copysignl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern long double nanl (const char *__tagb) noexcept (true); extern long double __nanl (const char *__tagb) noexcept (true); -# 213 "/usr/include/bits/mathcalls.h" 3 4 -extern int isnanl (long double __value) noexcept (true) - __attribute__ ((__const__)); - - - - - -extern long double j0l (long double) noexcept (true); extern long double __j0l (long double) noexcept (true); -extern long double j1l (long double) noexcept (true); extern long double __j1l (long double) noexcept (true); -extern long double jnl (int, long double) noexcept (true); extern long double __jnl (int, long double) noexcept (true); -extern long double y0l (long double) noexcept (true); extern long double __y0l (long double) noexcept (true); -extern long double y1l (long double) noexcept (true); extern long double __y1l (long double) noexcept (true); -extern long double ynl (int, long double) noexcept (true); extern long double __ynl (int, long double) noexcept (true); - - - - - - extern long double erfl (long double) noexcept (true); extern long double __erfl (long double) noexcept (true); - extern long double erfcl (long double) noexcept (true); extern long double __erfcl (long double) noexcept (true); -extern long double lgammal (long double) noexcept (true); extern long double __lgammal (long double) noexcept (true); - - - - -extern long double tgammal (long double) noexcept (true); extern long double __tgammal (long double) noexcept (true); - - - - - -extern long double gammal (long double) noexcept (true); extern long double __gammal (long double) noexcept (true); - - - - - - - -extern long double lgammal_r (long double, int *__signgamp) noexcept (true); extern long double __lgammal_r (long double, int *__signgamp) noexcept (true); - - - - - - -extern long double rintl (long double __x) noexcept (true); extern long double __rintl (long double __x) noexcept (true); - - -extern long double nextafterl (long double __x, long double __y) noexcept (true); extern long double __nextafterl (long double __x, long double __y) noexcept (true); - -extern long double nexttowardl (long double __x, long double __y) noexcept (true); extern long double __nexttowardl (long double __x, long double __y) noexcept (true); - - - - -extern long double nextdownl (long double __x) noexcept (true); extern long double __nextdownl (long double __x) noexcept (true); - -extern long double nextupl (long double __x) noexcept (true); extern long double __nextupl (long double __x) noexcept (true); - - - -extern long double remainderl (long double __x, long double __y) noexcept (true); extern long double __remainderl (long double __x, long double __y) noexcept (true); - - - -extern long double scalbnl (long double __x, int __n) noexcept (true); extern long double __scalbnl (long double __x, int __n) noexcept (true); - - - -extern int ilogbl (long double __x) noexcept (true); extern int __ilogbl (long double __x) noexcept (true); - - - - -extern long int llogbl (long double __x) noexcept (true); extern long int __llogbl (long double __x) noexcept (true); - - - - -extern long double scalblnl (long double __x, long int __n) noexcept (true); extern long double __scalblnl (long double __x, long int __n) noexcept (true); - - - -extern long double nearbyintl (long double __x) noexcept (true); extern long double __nearbyintl (long double __x) noexcept (true); - - - -extern long double roundl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundl (long double __x) noexcept (true) __attribute__ ((__const__)); - - - -extern long double truncl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __truncl (long double __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern long double remquol (long double __x, long double __y, int *__quo) noexcept (true); extern long double __remquol (long double __x, long double __y, int *__quo) noexcept (true); - - - - - - -extern long int lrintl (long double __x) noexcept (true); extern long int __lrintl (long double __x) noexcept (true); -__extension__ -extern long long int llrintl (long double __x) noexcept (true); extern long long int __llrintl (long double __x) noexcept (true); - - - -extern long int lroundl (long double __x) noexcept (true); extern long int __lroundl (long double __x) noexcept (true); -__extension__ -extern long long int llroundl (long double __x) noexcept (true); extern long long int __llroundl (long double __x) noexcept (true); - - - -extern long double fdiml (long double __x, long double __y) noexcept (true); extern long double __fdiml (long double __x, long double __y) noexcept (true); - - - -extern long double fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - - -extern long double fmal (long double __x, long double __y, long double __z) noexcept (true); extern long double __fmal (long double __x, long double __y, long double __z) noexcept (true); - - - - -extern long double roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); extern long double __roundevenl (long double __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpl (long double __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpl (long double __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxl (long double __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalizel (long double *__cx, const long double *__x) noexcept (true); - - - - - - -extern long double fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaxmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminmagl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern long double fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimuml (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_magl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fmaximum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - -extern long double fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); extern long double __fminimum_mag_numl (long double __x, long double __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorderl (const long double *__x, const long double *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermagl (const long double *__x, const long double *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern long double getpayloadl (const long double *__x) noexcept (true); extern long double __getpayloadl (const long double *__x) noexcept (true); - - -extern int setpayloadl (long double *__x, long double __payload) noexcept (true); - - -extern int setpayloadsigl (long double *__x, long double __payload) noexcept (true); - - - - - - - -extern long double scalbl (long double __x, long double __n) noexcept (true); extern long double __scalbl (long double __x, long double __n) noexcept (true); -# 400 "/usr/include/math.h" 2 3 4 -# 450 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern _Float32 acosf32 (_Float32 __x) noexcept (true); extern _Float32 __acosf32 (_Float32 __x) noexcept (true); - - extern _Float32 asinf32 (_Float32 __x) noexcept (true); extern _Float32 __asinf32 (_Float32 __x) noexcept (true); - - extern _Float32 atanf32 (_Float32 __x) noexcept (true); extern _Float32 __atanf32 (_Float32 __x) noexcept (true); - - extern _Float32 atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); extern _Float32 __atan2f32 (_Float32 __y, _Float32 __x) noexcept (true); - - - extern _Float32 cosf32 (_Float32 __x) noexcept (true); extern _Float32 __cosf32 (_Float32 __x) noexcept (true); - - extern _Float32 sinf32 (_Float32 __x) noexcept (true); extern _Float32 __sinf32 (_Float32 __x) noexcept (true); - - extern _Float32 tanf32 (_Float32 __x) noexcept (true); extern _Float32 __tanf32 (_Float32 __x) noexcept (true); - - - - - extern _Float32 coshf32 (_Float32 __x) noexcept (true); extern _Float32 __coshf32 (_Float32 __x) noexcept (true); - - extern _Float32 sinhf32 (_Float32 __x) noexcept (true); extern _Float32 __sinhf32 (_Float32 __x) noexcept (true); - - extern _Float32 tanhf32 (_Float32 __x) noexcept (true); extern _Float32 __tanhf32 (_Float32 __x) noexcept (true); - - - - extern void sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); extern void __sincosf32 (_Float32 __x, _Float32 *__sinx, _Float32 *__cosx) noexcept (true); - - - - - - extern _Float32 acoshf32 (_Float32 __x) noexcept (true); extern _Float32 __acoshf32 (_Float32 __x) noexcept (true); - - extern _Float32 asinhf32 (_Float32 __x) noexcept (true); extern _Float32 __asinhf32 (_Float32 __x) noexcept (true); - - extern _Float32 atanhf32 (_Float32 __x) noexcept (true); extern _Float32 __atanhf32 (_Float32 __x) noexcept (true); - - - - - - extern _Float32 expf32 (_Float32 __x) noexcept (true); extern _Float32 __expf32 (_Float32 __x) noexcept (true); - - -extern _Float32 frexpf32 (_Float32 __x, int *__exponent) noexcept (true); extern _Float32 __frexpf32 (_Float32 __x, int *__exponent) noexcept (true); - - -extern _Float32 ldexpf32 (_Float32 __x, int __exponent) noexcept (true); extern _Float32 __ldexpf32 (_Float32 __x, int __exponent) noexcept (true); - - - extern _Float32 logf32 (_Float32 __x) noexcept (true); extern _Float32 __logf32 (_Float32 __x) noexcept (true); - - - extern _Float32 log10f32 (_Float32 __x) noexcept (true); extern _Float32 __log10f32 (_Float32 __x) noexcept (true); - - -extern _Float32 modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true); extern _Float32 __modff32 (_Float32 __x, _Float32 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern _Float32 exp10f32 (_Float32 __x) noexcept (true); extern _Float32 __exp10f32 (_Float32 __x) noexcept (true); - - - - - extern _Float32 expm1f32 (_Float32 __x) noexcept (true); extern _Float32 __expm1f32 (_Float32 __x) noexcept (true); - - - extern _Float32 log1pf32 (_Float32 __x) noexcept (true); extern _Float32 __log1pf32 (_Float32 __x) noexcept (true); - - -extern _Float32 logbf32 (_Float32 __x) noexcept (true); extern _Float32 __logbf32 (_Float32 __x) noexcept (true); - - - - - extern _Float32 exp2f32 (_Float32 __x) noexcept (true); extern _Float32 __exp2f32 (_Float32 __x) noexcept (true); - - - extern _Float32 log2f32 (_Float32 __x) noexcept (true); extern _Float32 __log2f32 (_Float32 __x) noexcept (true); - - - - - - - extern _Float32 powf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __powf32 (_Float32 __x, _Float32 __y) noexcept (true); - - -extern _Float32 sqrtf32 (_Float32 __x) noexcept (true); extern _Float32 __sqrtf32 (_Float32 __x) noexcept (true); - - - - extern _Float32 hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __hypotf32 (_Float32 __x, _Float32 __y) noexcept (true); - - - - - extern _Float32 cbrtf32 (_Float32 __x) noexcept (true); extern _Float32 __cbrtf32 (_Float32 __x) noexcept (true); - - - - - - -extern _Float32 ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __ceilf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fabsf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __floorf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fmodf32 (_Float32 __x, _Float32 __y) noexcept (true); -# 198 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float32 copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __copysignf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float32 nanf32 (const char *__tagb) noexcept (true); extern _Float32 __nanf32 (const char *__tagb) noexcept (true); -# 220 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float32 j0f32 (_Float32) noexcept (true); extern _Float32 __j0f32 (_Float32) noexcept (true); -extern _Float32 j1f32 (_Float32) noexcept (true); extern _Float32 __j1f32 (_Float32) noexcept (true); -extern _Float32 jnf32 (int, _Float32) noexcept (true); extern _Float32 __jnf32 (int, _Float32) noexcept (true); -extern _Float32 y0f32 (_Float32) noexcept (true); extern _Float32 __y0f32 (_Float32) noexcept (true); -extern _Float32 y1f32 (_Float32) noexcept (true); extern _Float32 __y1f32 (_Float32) noexcept (true); -extern _Float32 ynf32 (int, _Float32) noexcept (true); extern _Float32 __ynf32 (int, _Float32) noexcept (true); - - - - - - extern _Float32 erff32 (_Float32) noexcept (true); extern _Float32 __erff32 (_Float32) noexcept (true); - extern _Float32 erfcf32 (_Float32) noexcept (true); extern _Float32 __erfcf32 (_Float32) noexcept (true); -extern _Float32 lgammaf32 (_Float32) noexcept (true); extern _Float32 __lgammaf32 (_Float32) noexcept (true); - - - - -extern _Float32 tgammaf32 (_Float32) noexcept (true); extern _Float32 __tgammaf32 (_Float32) noexcept (true); -# 252 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float32 lgammaf32_r (_Float32, int *__signgamp) noexcept (true); extern _Float32 __lgammaf32_r (_Float32, int *__signgamp) noexcept (true); - - - - - - -extern _Float32 rintf32 (_Float32 __x) noexcept (true); extern _Float32 __rintf32 (_Float32 __x) noexcept (true); - - -extern _Float32 nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __nextafterf32 (_Float32 __x, _Float32 __y) noexcept (true); - - - - - - -extern _Float32 nextdownf32 (_Float32 __x) noexcept (true); extern _Float32 __nextdownf32 (_Float32 __x) noexcept (true); - -extern _Float32 nextupf32 (_Float32 __x) noexcept (true); extern _Float32 __nextupf32 (_Float32 __x) noexcept (true); - - - -extern _Float32 remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __remainderf32 (_Float32 __x, _Float32 __y) noexcept (true); - - - -extern _Float32 scalbnf32 (_Float32 __x, int __n) noexcept (true); extern _Float32 __scalbnf32 (_Float32 __x, int __n) noexcept (true); - - - -extern int ilogbf32 (_Float32 __x) noexcept (true); extern int __ilogbf32 (_Float32 __x) noexcept (true); - - - - -extern long int llogbf32 (_Float32 __x) noexcept (true); extern long int __llogbf32 (_Float32 __x) noexcept (true); - - - - -extern _Float32 scalblnf32 (_Float32 __x, long int __n) noexcept (true); extern _Float32 __scalblnf32 (_Float32 __x, long int __n) noexcept (true); - - - -extern _Float32 nearbyintf32 (_Float32 __x) noexcept (true); extern _Float32 __nearbyintf32 (_Float32 __x) noexcept (true); - - - -extern _Float32 roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float32 truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __truncf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float32 remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); extern _Float32 __remquof32 (_Float32 __x, _Float32 __y, int *__quo) noexcept (true); - - - - - - -extern long int lrintf32 (_Float32 __x) noexcept (true); extern long int __lrintf32 (_Float32 __x) noexcept (true); -__extension__ -extern long long int llrintf32 (_Float32 __x) noexcept (true); extern long long int __llrintf32 (_Float32 __x) noexcept (true); - - - -extern long int lroundf32 (_Float32 __x) noexcept (true); extern long int __lroundf32 (_Float32 __x) noexcept (true); -__extension__ -extern long long int llroundf32 (_Float32 __x) noexcept (true); extern long long int __llroundf32 (_Float32 __x) noexcept (true); - - - -extern _Float32 fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); extern _Float32 __fdimf32 (_Float32 __x, _Float32 __y) noexcept (true); - - - -extern _Float32 fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float32 fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); extern _Float32 __fmaf32 (_Float32 __x, _Float32 __y, _Float32 __z) noexcept (true); - - - - -extern _Float32 roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); extern _Float32 __roundevenf32 (_Float32 __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32 (_Float32 __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalizef32 (_Float32 *__cx, const _Float32 *__x) noexcept (true); - - - - - - -extern _Float32 fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaxmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminmagf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float32 fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimumf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_magf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fmaximum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32 fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); extern _Float32 __fminimum_mag_numf32 (_Float32 __x, _Float32 __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorderf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermagf32 (const _Float32 *__x, const _Float32 *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern _Float32 getpayloadf32 (const _Float32 *__x) noexcept (true); extern _Float32 __getpayloadf32 (const _Float32 *__x) noexcept (true); - - -extern int setpayloadf32 (_Float32 *__x, _Float32 __payload) noexcept (true); - - -extern int setpayloadsigf32 (_Float32 *__x, _Float32 __payload) noexcept (true); -# 451 "/usr/include/math.h" 2 3 4 -# 467 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern _Float64 acosf64 (_Float64 __x) noexcept (true); extern _Float64 __acosf64 (_Float64 __x) noexcept (true); - - extern _Float64 asinf64 (_Float64 __x) noexcept (true); extern _Float64 __asinf64 (_Float64 __x) noexcept (true); - - extern _Float64 atanf64 (_Float64 __x) noexcept (true); extern _Float64 __atanf64 (_Float64 __x) noexcept (true); - - extern _Float64 atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); extern _Float64 __atan2f64 (_Float64 __y, _Float64 __x) noexcept (true); - - - extern _Float64 cosf64 (_Float64 __x) noexcept (true); extern _Float64 __cosf64 (_Float64 __x) noexcept (true); - - extern _Float64 sinf64 (_Float64 __x) noexcept (true); extern _Float64 __sinf64 (_Float64 __x) noexcept (true); - - extern _Float64 tanf64 (_Float64 __x) noexcept (true); extern _Float64 __tanf64 (_Float64 __x) noexcept (true); - - - - - extern _Float64 coshf64 (_Float64 __x) noexcept (true); extern _Float64 __coshf64 (_Float64 __x) noexcept (true); - - extern _Float64 sinhf64 (_Float64 __x) noexcept (true); extern _Float64 __sinhf64 (_Float64 __x) noexcept (true); - - extern _Float64 tanhf64 (_Float64 __x) noexcept (true); extern _Float64 __tanhf64 (_Float64 __x) noexcept (true); - - - - extern void sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); extern void __sincosf64 (_Float64 __x, _Float64 *__sinx, _Float64 *__cosx) noexcept (true); - - - - - - extern _Float64 acoshf64 (_Float64 __x) noexcept (true); extern _Float64 __acoshf64 (_Float64 __x) noexcept (true); - - extern _Float64 asinhf64 (_Float64 __x) noexcept (true); extern _Float64 __asinhf64 (_Float64 __x) noexcept (true); - - extern _Float64 atanhf64 (_Float64 __x) noexcept (true); extern _Float64 __atanhf64 (_Float64 __x) noexcept (true); - - - - - - extern _Float64 expf64 (_Float64 __x) noexcept (true); extern _Float64 __expf64 (_Float64 __x) noexcept (true); - - -extern _Float64 frexpf64 (_Float64 __x, int *__exponent) noexcept (true); extern _Float64 __frexpf64 (_Float64 __x, int *__exponent) noexcept (true); - - -extern _Float64 ldexpf64 (_Float64 __x, int __exponent) noexcept (true); extern _Float64 __ldexpf64 (_Float64 __x, int __exponent) noexcept (true); - - - extern _Float64 logf64 (_Float64 __x) noexcept (true); extern _Float64 __logf64 (_Float64 __x) noexcept (true); - - - extern _Float64 log10f64 (_Float64 __x) noexcept (true); extern _Float64 __log10f64 (_Float64 __x) noexcept (true); - - -extern _Float64 modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true); extern _Float64 __modff64 (_Float64 __x, _Float64 *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern _Float64 exp10f64 (_Float64 __x) noexcept (true); extern _Float64 __exp10f64 (_Float64 __x) noexcept (true); - - - - - extern _Float64 expm1f64 (_Float64 __x) noexcept (true); extern _Float64 __expm1f64 (_Float64 __x) noexcept (true); - - - extern _Float64 log1pf64 (_Float64 __x) noexcept (true); extern _Float64 __log1pf64 (_Float64 __x) noexcept (true); - - -extern _Float64 logbf64 (_Float64 __x) noexcept (true); extern _Float64 __logbf64 (_Float64 __x) noexcept (true); - - - - - extern _Float64 exp2f64 (_Float64 __x) noexcept (true); extern _Float64 __exp2f64 (_Float64 __x) noexcept (true); - - - extern _Float64 log2f64 (_Float64 __x) noexcept (true); extern _Float64 __log2f64 (_Float64 __x) noexcept (true); - - - - - - - extern _Float64 powf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __powf64 (_Float64 __x, _Float64 __y) noexcept (true); - - -extern _Float64 sqrtf64 (_Float64 __x) noexcept (true); extern _Float64 __sqrtf64 (_Float64 __x) noexcept (true); - - - - extern _Float64 hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __hypotf64 (_Float64 __x, _Float64 __y) noexcept (true); - - - - - extern _Float64 cbrtf64 (_Float64 __x) noexcept (true); extern _Float64 __cbrtf64 (_Float64 __x) noexcept (true); - - - - - - -extern _Float64 ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __ceilf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fabsf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __floorf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fmodf64 (_Float64 __x, _Float64 __y) noexcept (true); -# 198 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float64 copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __copysignf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float64 nanf64 (const char *__tagb) noexcept (true); extern _Float64 __nanf64 (const char *__tagb) noexcept (true); -# 220 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float64 j0f64 (_Float64) noexcept (true); extern _Float64 __j0f64 (_Float64) noexcept (true); -extern _Float64 j1f64 (_Float64) noexcept (true); extern _Float64 __j1f64 (_Float64) noexcept (true); -extern _Float64 jnf64 (int, _Float64) noexcept (true); extern _Float64 __jnf64 (int, _Float64) noexcept (true); -extern _Float64 y0f64 (_Float64) noexcept (true); extern _Float64 __y0f64 (_Float64) noexcept (true); -extern _Float64 y1f64 (_Float64) noexcept (true); extern _Float64 __y1f64 (_Float64) noexcept (true); -extern _Float64 ynf64 (int, _Float64) noexcept (true); extern _Float64 __ynf64 (int, _Float64) noexcept (true); - - - - - - extern _Float64 erff64 (_Float64) noexcept (true); extern _Float64 __erff64 (_Float64) noexcept (true); - extern _Float64 erfcf64 (_Float64) noexcept (true); extern _Float64 __erfcf64 (_Float64) noexcept (true); -extern _Float64 lgammaf64 (_Float64) noexcept (true); extern _Float64 __lgammaf64 (_Float64) noexcept (true); - - - - -extern _Float64 tgammaf64 (_Float64) noexcept (true); extern _Float64 __tgammaf64 (_Float64) noexcept (true); -# 252 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float64 lgammaf64_r (_Float64, int *__signgamp) noexcept (true); extern _Float64 __lgammaf64_r (_Float64, int *__signgamp) noexcept (true); - - - - - - -extern _Float64 rintf64 (_Float64 __x) noexcept (true); extern _Float64 __rintf64 (_Float64 __x) noexcept (true); - - -extern _Float64 nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __nextafterf64 (_Float64 __x, _Float64 __y) noexcept (true); - - - - - - -extern _Float64 nextdownf64 (_Float64 __x) noexcept (true); extern _Float64 __nextdownf64 (_Float64 __x) noexcept (true); - -extern _Float64 nextupf64 (_Float64 __x) noexcept (true); extern _Float64 __nextupf64 (_Float64 __x) noexcept (true); - - - -extern _Float64 remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __remainderf64 (_Float64 __x, _Float64 __y) noexcept (true); - - - -extern _Float64 scalbnf64 (_Float64 __x, int __n) noexcept (true); extern _Float64 __scalbnf64 (_Float64 __x, int __n) noexcept (true); - - - -extern int ilogbf64 (_Float64 __x) noexcept (true); extern int __ilogbf64 (_Float64 __x) noexcept (true); - - - - -extern long int llogbf64 (_Float64 __x) noexcept (true); extern long int __llogbf64 (_Float64 __x) noexcept (true); - - - - -extern _Float64 scalblnf64 (_Float64 __x, long int __n) noexcept (true); extern _Float64 __scalblnf64 (_Float64 __x, long int __n) noexcept (true); - - - -extern _Float64 nearbyintf64 (_Float64 __x) noexcept (true); extern _Float64 __nearbyintf64 (_Float64 __x) noexcept (true); - - - -extern _Float64 roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float64 truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __truncf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float64 remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); extern _Float64 __remquof64 (_Float64 __x, _Float64 __y, int *__quo) noexcept (true); - - - - - - -extern long int lrintf64 (_Float64 __x) noexcept (true); extern long int __lrintf64 (_Float64 __x) noexcept (true); -__extension__ -extern long long int llrintf64 (_Float64 __x) noexcept (true); extern long long int __llrintf64 (_Float64 __x) noexcept (true); - - - -extern long int lroundf64 (_Float64 __x) noexcept (true); extern long int __lroundf64 (_Float64 __x) noexcept (true); -__extension__ -extern long long int llroundf64 (_Float64 __x) noexcept (true); extern long long int __llroundf64 (_Float64 __x) noexcept (true); - - - -extern _Float64 fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); extern _Float64 __fdimf64 (_Float64 __x, _Float64 __y) noexcept (true); - - - -extern _Float64 fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float64 fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); extern _Float64 __fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); - - - - -extern _Float64 roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); extern _Float64 __roundevenf64 (_Float64 __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64 (_Float64 __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalizef64 (_Float64 *__cx, const _Float64 *__x) noexcept (true); - - - - - - -extern _Float64 fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaxmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminmagf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float64 fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimumf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_magf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fmaximum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64 fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); extern _Float64 __fminimum_mag_numf64 (_Float64 __x, _Float64 __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorderf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermagf64 (const _Float64 *__x, const _Float64 *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern _Float64 getpayloadf64 (const _Float64 *__x) noexcept (true); extern _Float64 __getpayloadf64 (const _Float64 *__x) noexcept (true); - - -extern int setpayloadf64 (_Float64 *__x, _Float64 __payload) noexcept (true); - - -extern int setpayloadsigf64 (_Float64 *__x, _Float64 __payload) noexcept (true); -# 468 "/usr/include/math.h" 2 3 4 -# 501 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern _Float32x acosf32x (_Float32x __x) noexcept (true); extern _Float32x __acosf32x (_Float32x __x) noexcept (true); - - extern _Float32x asinf32x (_Float32x __x) noexcept (true); extern _Float32x __asinf32x (_Float32x __x) noexcept (true); - - extern _Float32x atanf32x (_Float32x __x) noexcept (true); extern _Float32x __atanf32x (_Float32x __x) noexcept (true); - - extern _Float32x atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); extern _Float32x __atan2f32x (_Float32x __y, _Float32x __x) noexcept (true); - - - extern _Float32x cosf32x (_Float32x __x) noexcept (true); extern _Float32x __cosf32x (_Float32x __x) noexcept (true); - - extern _Float32x sinf32x (_Float32x __x) noexcept (true); extern _Float32x __sinf32x (_Float32x __x) noexcept (true); - - extern _Float32x tanf32x (_Float32x __x) noexcept (true); extern _Float32x __tanf32x (_Float32x __x) noexcept (true); - - - - - extern _Float32x coshf32x (_Float32x __x) noexcept (true); extern _Float32x __coshf32x (_Float32x __x) noexcept (true); - - extern _Float32x sinhf32x (_Float32x __x) noexcept (true); extern _Float32x __sinhf32x (_Float32x __x) noexcept (true); - - extern _Float32x tanhf32x (_Float32x __x) noexcept (true); extern _Float32x __tanhf32x (_Float32x __x) noexcept (true); - - - - extern void sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); extern void __sincosf32x (_Float32x __x, _Float32x *__sinx, _Float32x *__cosx) noexcept (true); - - - - - - extern _Float32x acoshf32x (_Float32x __x) noexcept (true); extern _Float32x __acoshf32x (_Float32x __x) noexcept (true); - - extern _Float32x asinhf32x (_Float32x __x) noexcept (true); extern _Float32x __asinhf32x (_Float32x __x) noexcept (true); - - extern _Float32x atanhf32x (_Float32x __x) noexcept (true); extern _Float32x __atanhf32x (_Float32x __x) noexcept (true); - - - - - - extern _Float32x expf32x (_Float32x __x) noexcept (true); extern _Float32x __expf32x (_Float32x __x) noexcept (true); - - -extern _Float32x frexpf32x (_Float32x __x, int *__exponent) noexcept (true); extern _Float32x __frexpf32x (_Float32x __x, int *__exponent) noexcept (true); - - -extern _Float32x ldexpf32x (_Float32x __x, int __exponent) noexcept (true); extern _Float32x __ldexpf32x (_Float32x __x, int __exponent) noexcept (true); - - - extern _Float32x logf32x (_Float32x __x) noexcept (true); extern _Float32x __logf32x (_Float32x __x) noexcept (true); - - - extern _Float32x log10f32x (_Float32x __x) noexcept (true); extern _Float32x __log10f32x (_Float32x __x) noexcept (true); - - -extern _Float32x modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true); extern _Float32x __modff32x (_Float32x __x, _Float32x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern _Float32x exp10f32x (_Float32x __x) noexcept (true); extern _Float32x __exp10f32x (_Float32x __x) noexcept (true); - - - - - extern _Float32x expm1f32x (_Float32x __x) noexcept (true); extern _Float32x __expm1f32x (_Float32x __x) noexcept (true); - - - extern _Float32x log1pf32x (_Float32x __x) noexcept (true); extern _Float32x __log1pf32x (_Float32x __x) noexcept (true); - - -extern _Float32x logbf32x (_Float32x __x) noexcept (true); extern _Float32x __logbf32x (_Float32x __x) noexcept (true); - - - - - extern _Float32x exp2f32x (_Float32x __x) noexcept (true); extern _Float32x __exp2f32x (_Float32x __x) noexcept (true); - - - extern _Float32x log2f32x (_Float32x __x) noexcept (true); extern _Float32x __log2f32x (_Float32x __x) noexcept (true); - - - - - - - extern _Float32x powf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __powf32x (_Float32x __x, _Float32x __y) noexcept (true); - - -extern _Float32x sqrtf32x (_Float32x __x) noexcept (true); extern _Float32x __sqrtf32x (_Float32x __x) noexcept (true); - - - - extern _Float32x hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __hypotf32x (_Float32x __x, _Float32x __y) noexcept (true); - - - - - extern _Float32x cbrtf32x (_Float32x __x) noexcept (true); extern _Float32x __cbrtf32x (_Float32x __x) noexcept (true); - - - - - - -extern _Float32x ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __ceilf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fabsf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __floorf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fmodf32x (_Float32x __x, _Float32x __y) noexcept (true); -# 198 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float32x copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __copysignf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float32x nanf32x (const char *__tagb) noexcept (true); extern _Float32x __nanf32x (const char *__tagb) noexcept (true); -# 220 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float32x j0f32x (_Float32x) noexcept (true); extern _Float32x __j0f32x (_Float32x) noexcept (true); -extern _Float32x j1f32x (_Float32x) noexcept (true); extern _Float32x __j1f32x (_Float32x) noexcept (true); -extern _Float32x jnf32x (int, _Float32x) noexcept (true); extern _Float32x __jnf32x (int, _Float32x) noexcept (true); -extern _Float32x y0f32x (_Float32x) noexcept (true); extern _Float32x __y0f32x (_Float32x) noexcept (true); -extern _Float32x y1f32x (_Float32x) noexcept (true); extern _Float32x __y1f32x (_Float32x) noexcept (true); -extern _Float32x ynf32x (int, _Float32x) noexcept (true); extern _Float32x __ynf32x (int, _Float32x) noexcept (true); - - - - - - extern _Float32x erff32x (_Float32x) noexcept (true); extern _Float32x __erff32x (_Float32x) noexcept (true); - extern _Float32x erfcf32x (_Float32x) noexcept (true); extern _Float32x __erfcf32x (_Float32x) noexcept (true); -extern _Float32x lgammaf32x (_Float32x) noexcept (true); extern _Float32x __lgammaf32x (_Float32x) noexcept (true); - - - - -extern _Float32x tgammaf32x (_Float32x) noexcept (true); extern _Float32x __tgammaf32x (_Float32x) noexcept (true); -# 252 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float32x lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); extern _Float32x __lgammaf32x_r (_Float32x, int *__signgamp) noexcept (true); - - - - - - -extern _Float32x rintf32x (_Float32x __x) noexcept (true); extern _Float32x __rintf32x (_Float32x __x) noexcept (true); - - -extern _Float32x nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __nextafterf32x (_Float32x __x, _Float32x __y) noexcept (true); - - - - - - -extern _Float32x nextdownf32x (_Float32x __x) noexcept (true); extern _Float32x __nextdownf32x (_Float32x __x) noexcept (true); - -extern _Float32x nextupf32x (_Float32x __x) noexcept (true); extern _Float32x __nextupf32x (_Float32x __x) noexcept (true); - - - -extern _Float32x remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __remainderf32x (_Float32x __x, _Float32x __y) noexcept (true); - - - -extern _Float32x scalbnf32x (_Float32x __x, int __n) noexcept (true); extern _Float32x __scalbnf32x (_Float32x __x, int __n) noexcept (true); - - - -extern int ilogbf32x (_Float32x __x) noexcept (true); extern int __ilogbf32x (_Float32x __x) noexcept (true); - - - - -extern long int llogbf32x (_Float32x __x) noexcept (true); extern long int __llogbf32x (_Float32x __x) noexcept (true); - - - - -extern _Float32x scalblnf32x (_Float32x __x, long int __n) noexcept (true); extern _Float32x __scalblnf32x (_Float32x __x, long int __n) noexcept (true); - - - -extern _Float32x nearbyintf32x (_Float32x __x) noexcept (true); extern _Float32x __nearbyintf32x (_Float32x __x) noexcept (true); - - - -extern _Float32x roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float32x truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __truncf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float32x remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); extern _Float32x __remquof32x (_Float32x __x, _Float32x __y, int *__quo) noexcept (true); - - - - - - -extern long int lrintf32x (_Float32x __x) noexcept (true); extern long int __lrintf32x (_Float32x __x) noexcept (true); -__extension__ -extern long long int llrintf32x (_Float32x __x) noexcept (true); extern long long int __llrintf32x (_Float32x __x) noexcept (true); - - - -extern long int lroundf32x (_Float32x __x) noexcept (true); extern long int __lroundf32x (_Float32x __x) noexcept (true); -__extension__ -extern long long int llroundf32x (_Float32x __x) noexcept (true); extern long long int __llroundf32x (_Float32x __x) noexcept (true); - - - -extern _Float32x fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); extern _Float32x __fdimf32x (_Float32x __x, _Float32x __y) noexcept (true); - - - -extern _Float32x fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float32x fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); extern _Float32x __fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); - - - - -extern _Float32x roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); extern _Float32x __roundevenf32x (_Float32x __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf32x (_Float32x __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalizef32x (_Float32x *__cx, const _Float32x *__x) noexcept (true); - - - - - - -extern _Float32x fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaxmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminmagf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float32x fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimumf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_magf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fmaximum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float32x fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); extern _Float32x __fminimum_mag_numf32x (_Float32x __x, _Float32x __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorderf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermagf32x (const _Float32x *__x, const _Float32x *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern _Float32x getpayloadf32x (const _Float32x *__x) noexcept (true); extern _Float32x __getpayloadf32x (const _Float32x *__x) noexcept (true); - - -extern int setpayloadf32x (_Float32x *__x, _Float32x __payload) noexcept (true); - - -extern int setpayloadsigf32x (_Float32x *__x, _Float32x __payload) noexcept (true); -# 502 "/usr/include/math.h" 2 3 4 -# 518 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls.h" 1 3 4 -# 53 "/usr/include/bits/mathcalls.h" 3 4 - extern _Float64x acosf64x (_Float64x __x) noexcept (true); extern _Float64x __acosf64x (_Float64x __x) noexcept (true); - - extern _Float64x asinf64x (_Float64x __x) noexcept (true); extern _Float64x __asinf64x (_Float64x __x) noexcept (true); - - extern _Float64x atanf64x (_Float64x __x) noexcept (true); extern _Float64x __atanf64x (_Float64x __x) noexcept (true); - - extern _Float64x atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); extern _Float64x __atan2f64x (_Float64x __y, _Float64x __x) noexcept (true); - - - extern _Float64x cosf64x (_Float64x __x) noexcept (true); extern _Float64x __cosf64x (_Float64x __x) noexcept (true); - - extern _Float64x sinf64x (_Float64x __x) noexcept (true); extern _Float64x __sinf64x (_Float64x __x) noexcept (true); - - extern _Float64x tanf64x (_Float64x __x) noexcept (true); extern _Float64x __tanf64x (_Float64x __x) noexcept (true); - - - - - extern _Float64x coshf64x (_Float64x __x) noexcept (true); extern _Float64x __coshf64x (_Float64x __x) noexcept (true); - - extern _Float64x sinhf64x (_Float64x __x) noexcept (true); extern _Float64x __sinhf64x (_Float64x __x) noexcept (true); - - extern _Float64x tanhf64x (_Float64x __x) noexcept (true); extern _Float64x __tanhf64x (_Float64x __x) noexcept (true); - - - - extern void sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); extern void __sincosf64x (_Float64x __x, _Float64x *__sinx, _Float64x *__cosx) noexcept (true); - - - - - - extern _Float64x acoshf64x (_Float64x __x) noexcept (true); extern _Float64x __acoshf64x (_Float64x __x) noexcept (true); - - extern _Float64x asinhf64x (_Float64x __x) noexcept (true); extern _Float64x __asinhf64x (_Float64x __x) noexcept (true); - - extern _Float64x atanhf64x (_Float64x __x) noexcept (true); extern _Float64x __atanhf64x (_Float64x __x) noexcept (true); - - - - - - extern _Float64x expf64x (_Float64x __x) noexcept (true); extern _Float64x __expf64x (_Float64x __x) noexcept (true); - - -extern _Float64x frexpf64x (_Float64x __x, int *__exponent) noexcept (true); extern _Float64x __frexpf64x (_Float64x __x, int *__exponent) noexcept (true); - - -extern _Float64x ldexpf64x (_Float64x __x, int __exponent) noexcept (true); extern _Float64x __ldexpf64x (_Float64x __x, int __exponent) noexcept (true); - - - extern _Float64x logf64x (_Float64x __x) noexcept (true); extern _Float64x __logf64x (_Float64x __x) noexcept (true); - - - extern _Float64x log10f64x (_Float64x __x) noexcept (true); extern _Float64x __log10f64x (_Float64x __x) noexcept (true); - - -extern _Float64x modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true); extern _Float64x __modff64x (_Float64x __x, _Float64x *__iptr) noexcept (true) __attribute__ ((__nonnull__ (2))); - - - - extern _Float64x exp10f64x (_Float64x __x) noexcept (true); extern _Float64x __exp10f64x (_Float64x __x) noexcept (true); - - - - - extern _Float64x expm1f64x (_Float64x __x) noexcept (true); extern _Float64x __expm1f64x (_Float64x __x) noexcept (true); - - - extern _Float64x log1pf64x (_Float64x __x) noexcept (true); extern _Float64x __log1pf64x (_Float64x __x) noexcept (true); - - -extern _Float64x logbf64x (_Float64x __x) noexcept (true); extern _Float64x __logbf64x (_Float64x __x) noexcept (true); - - - - - extern _Float64x exp2f64x (_Float64x __x) noexcept (true); extern _Float64x __exp2f64x (_Float64x __x) noexcept (true); - - - extern _Float64x log2f64x (_Float64x __x) noexcept (true); extern _Float64x __log2f64x (_Float64x __x) noexcept (true); - - - - - - - extern _Float64x powf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __powf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float64x sqrtf64x (_Float64x __x) noexcept (true); extern _Float64x __sqrtf64x (_Float64x __x) noexcept (true); - - - - extern _Float64x hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __hypotf64x (_Float64x __x, _Float64x __y) noexcept (true); - - - - - extern _Float64x cbrtf64x (_Float64x __x) noexcept (true); extern _Float64x __cbrtf64x (_Float64x __x) noexcept (true); - - - - - - -extern _Float64x ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __ceilf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fabsf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __floorf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fmodf64x (_Float64x __x, _Float64x __y) noexcept (true); -# 198 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float64x copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __copysignf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float64x nanf64x (const char *__tagb) noexcept (true); extern _Float64x __nanf64x (const char *__tagb) noexcept (true); -# 220 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float64x j0f64x (_Float64x) noexcept (true); extern _Float64x __j0f64x (_Float64x) noexcept (true); -extern _Float64x j1f64x (_Float64x) noexcept (true); extern _Float64x __j1f64x (_Float64x) noexcept (true); -extern _Float64x jnf64x (int, _Float64x) noexcept (true); extern _Float64x __jnf64x (int, _Float64x) noexcept (true); -extern _Float64x y0f64x (_Float64x) noexcept (true); extern _Float64x __y0f64x (_Float64x) noexcept (true); -extern _Float64x y1f64x (_Float64x) noexcept (true); extern _Float64x __y1f64x (_Float64x) noexcept (true); -extern _Float64x ynf64x (int, _Float64x) noexcept (true); extern _Float64x __ynf64x (int, _Float64x) noexcept (true); - - - - - - extern _Float64x erff64x (_Float64x) noexcept (true); extern _Float64x __erff64x (_Float64x) noexcept (true); - extern _Float64x erfcf64x (_Float64x) noexcept (true); extern _Float64x __erfcf64x (_Float64x) noexcept (true); -extern _Float64x lgammaf64x (_Float64x) noexcept (true); extern _Float64x __lgammaf64x (_Float64x) noexcept (true); - - - - -extern _Float64x tgammaf64x (_Float64x) noexcept (true); extern _Float64x __tgammaf64x (_Float64x) noexcept (true); -# 252 "/usr/include/bits/mathcalls.h" 3 4 -extern _Float64x lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); extern _Float64x __lgammaf64x_r (_Float64x, int *__signgamp) noexcept (true); - - - - - - -extern _Float64x rintf64x (_Float64x __x) noexcept (true); extern _Float64x __rintf64x (_Float64x __x) noexcept (true); - - -extern _Float64x nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __nextafterf64x (_Float64x __x, _Float64x __y) noexcept (true); - - - - - - -extern _Float64x nextdownf64x (_Float64x __x) noexcept (true); extern _Float64x __nextdownf64x (_Float64x __x) noexcept (true); - -extern _Float64x nextupf64x (_Float64x __x) noexcept (true); extern _Float64x __nextupf64x (_Float64x __x) noexcept (true); - - - -extern _Float64x remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __remainderf64x (_Float64x __x, _Float64x __y) noexcept (true); - - - -extern _Float64x scalbnf64x (_Float64x __x, int __n) noexcept (true); extern _Float64x __scalbnf64x (_Float64x __x, int __n) noexcept (true); - - - -extern int ilogbf64x (_Float64x __x) noexcept (true); extern int __ilogbf64x (_Float64x __x) noexcept (true); - - - - -extern long int llogbf64x (_Float64x __x) noexcept (true); extern long int __llogbf64x (_Float64x __x) noexcept (true); - - - - -extern _Float64x scalblnf64x (_Float64x __x, long int __n) noexcept (true); extern _Float64x __scalblnf64x (_Float64x __x, long int __n) noexcept (true); - - - -extern _Float64x nearbyintf64x (_Float64x __x) noexcept (true); extern _Float64x __nearbyintf64x (_Float64x __x) noexcept (true); - - - -extern _Float64x roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float64x truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __truncf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float64x remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); extern _Float64x __remquof64x (_Float64x __x, _Float64x __y, int *__quo) noexcept (true); - - - - - - -extern long int lrintf64x (_Float64x __x) noexcept (true); extern long int __lrintf64x (_Float64x __x) noexcept (true); -__extension__ -extern long long int llrintf64x (_Float64x __x) noexcept (true); extern long long int __llrintf64x (_Float64x __x) noexcept (true); - - - -extern long int lroundf64x (_Float64x __x) noexcept (true); extern long int __lroundf64x (_Float64x __x) noexcept (true); -__extension__ -extern long long int llroundf64x (_Float64x __x) noexcept (true); extern long long int __llroundf64x (_Float64x __x) noexcept (true); - - - -extern _Float64x fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); extern _Float64x __fdimf64x (_Float64x __x, _Float64x __y) noexcept (true); - - - -extern _Float64x fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - - -extern _Float64x fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); extern _Float64x __fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); - - - - -extern _Float64x roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); extern _Float64x __roundevenf64x (_Float64x __x) noexcept (true) __attribute__ ((__const__)); - - - -extern __intmax_t fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); - - - - -extern __uintmax_t ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __intmax_t fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __intmax_t __fromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); - - - - - -extern __uintmax_t ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); extern __uintmax_t __ufromfpxf64x (_Float64x __x, int __round, unsigned int __width) noexcept (true); - - - -extern int canonicalizef64x (_Float64x *__cx, const _Float64x *__x) noexcept (true); - - - - - - -extern _Float64x fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaxmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminmagf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern _Float64x fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimumf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_magf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fmaximum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - -extern _Float64x fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); extern _Float64x __fminimum_mag_numf64x (_Float64x __x, _Float64x __y) noexcept (true) __attribute__ ((__const__)); - - - - -extern int totalorderf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern int totalordermagf64x (const _Float64x *__x, const _Float64x *__y) noexcept (true) - - __attribute__ ((__pure__)); - - -extern _Float64x getpayloadf64x (const _Float64x *__x) noexcept (true); extern _Float64x __getpayloadf64x (const _Float64x *__x) noexcept (true); - - -extern int setpayloadf64x (_Float64x *__x, _Float64x __payload) noexcept (true); - - -extern int setpayloadsigf64x (_Float64x *__x, _Float64x __payload) noexcept (true); -# 519 "/usr/include/math.h" 2 3 4 -# 566 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 -# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 -extern float fadd (double __x, double __y) noexcept (true); - - -extern float fdiv (double __x, double __y) noexcept (true); - - -extern float ffma (double __x, double __y, double __z) noexcept (true); - - -extern float fmul (double __x, double __y) noexcept (true); - - -extern float fsqrt (double __x) noexcept (true); - - -extern float fsub (double __x, double __y) noexcept (true); -# 567 "/usr/include/math.h" 2 3 4 -# 587 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 -# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 -extern float faddl (long double __x, long double __y) noexcept (true); - - -extern float fdivl (long double __x, long double __y) noexcept (true); - - -extern float ffmal (long double __x, long double __y, long double __z) noexcept (true); - - -extern float fmull (long double __x, long double __y) noexcept (true); - - -extern float fsqrtl (long double __x) noexcept (true); - - -extern float fsubl (long double __x, long double __y) noexcept (true); -# 588 "/usr/include/math.h" 2 3 4 -# 616 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 -# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 -extern double daddl (long double __x, long double __y) noexcept (true); - - -extern double ddivl (long double __x, long double __y) noexcept (true); - - -extern double dfmal (long double __x, long double __y, long double __z) noexcept (true); - - -extern double dmull (long double __x, long double __y) noexcept (true); - - -extern double dsqrtl (long double __x) noexcept (true); - - -extern double dsubl (long double __x, long double __y) noexcept (true); -# 617 "/usr/include/math.h" 2 3 4 -# 697 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 -# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 -extern _Float32 f32addf32x (_Float32x __x, _Float32x __y) noexcept (true); - - -extern _Float32 f32divf32x (_Float32x __x, _Float32x __y) noexcept (true); - - -extern _Float32 f32fmaf32x (_Float32x __x, _Float32x __y, _Float32x __z) noexcept (true); - - -extern _Float32 f32mulf32x (_Float32x __x, _Float32x __y) noexcept (true); - - -extern _Float32 f32sqrtf32x (_Float32x __x) noexcept (true); - - -extern _Float32 f32subf32x (_Float32x __x, _Float32x __y) noexcept (true); -# 698 "/usr/include/math.h" 2 3 4 -# 707 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 -# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 -extern _Float32 f32addf64 (_Float64 __x, _Float64 __y) noexcept (true); - - -extern _Float32 f32divf64 (_Float64 __x, _Float64 __y) noexcept (true); - - -extern _Float32 f32fmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); - - -extern _Float32 f32mulf64 (_Float64 __x, _Float64 __y) noexcept (true); - - -extern _Float32 f32sqrtf64 (_Float64 __x) noexcept (true); - - -extern _Float32 f32subf64 (_Float64 __x, _Float64 __y) noexcept (true); -# 708 "/usr/include/math.h" 2 3 4 -# 717 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 -# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 -extern _Float32 f32addf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float32 f32divf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float32 f32fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); - - -extern _Float32 f32mulf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float32 f32sqrtf64x (_Float64x __x) noexcept (true); - - -extern _Float32 f32subf64x (_Float64x __x, _Float64x __y) noexcept (true); -# 718 "/usr/include/math.h" 2 3 4 -# 747 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 -# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 -extern _Float32x f32xaddf64 (_Float64 __x, _Float64 __y) noexcept (true); - - -extern _Float32x f32xdivf64 (_Float64 __x, _Float64 __y) noexcept (true); - - -extern _Float32x f32xfmaf64 (_Float64 __x, _Float64 __y, _Float64 __z) noexcept (true); - - -extern _Float32x f32xmulf64 (_Float64 __x, _Float64 __y) noexcept (true); - - -extern _Float32x f32xsqrtf64 (_Float64 __x) noexcept (true); - - -extern _Float32x f32xsubf64 (_Float64 __x, _Float64 __y) noexcept (true); -# 748 "/usr/include/math.h" 2 3 4 -# 757 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 -# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 -extern _Float32x f32xaddf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float32x f32xdivf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float32x f32xfmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); - - -extern _Float32x f32xmulf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float32x f32xsqrtf64x (_Float64x __x) noexcept (true); - - -extern _Float32x f32xsubf64x (_Float64x __x, _Float64x __y) noexcept (true); -# 758 "/usr/include/math.h" 2 3 4 -# 787 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/mathcalls-narrow.h" 1 3 4 -# 24 "/usr/include/bits/mathcalls-narrow.h" 3 4 -extern _Float64 f64addf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float64 f64divf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float64 f64fmaf64x (_Float64x __x, _Float64x __y, _Float64x __z) noexcept (true); - - -extern _Float64 f64mulf64x (_Float64x __x, _Float64x __y) noexcept (true); - - -extern _Float64 f64sqrtf64x (_Float64x __x) noexcept (true); - - -extern _Float64 f64subf64x (_Float64x __x, _Float64x __y) noexcept (true); -# 788 "/usr/include/math.h" 2 3 4 -# 854 "/usr/include/math.h" 3 4 -extern int signgam; -# 934 "/usr/include/math.h" 3 4 -enum - { - FP_NAN = - - 0, - FP_INFINITE = - - 1, - FP_ZERO = - - 2, - FP_SUBNORMAL = - - 3, - FP_NORMAL = - - 4 - }; -# 1055 "/usr/include/math.h" 3 4 -# 1 "/usr/include/bits/iscanonical.h" 1 3 4 -# 23 "/usr/include/bits/iscanonical.h" 3 4 -extern int __iscanonicall (long double __x) - noexcept (true) __attribute__ ((__const__)); -# 46 "/usr/include/bits/iscanonical.h" 3 4 -extern "C++" { -inline int iscanonical (float __val) { return ((void) (__typeof (__val)) (__val), 1); } -inline int iscanonical (double __val) { return ((void) (__typeof (__val)) (__val), 1); } -inline int iscanonical (long double __val) { return __iscanonicall (__val); } - - - -} -# 1056 "/usr/include/math.h" 2 3 4 -# 1067 "/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); - -} - - - - - -} -# 1098 "/usr/include/math.h" 3 4 -extern "C++" { -# 1129 "/usr/include/math.h" 3 4 -template inline bool -iszero (__T __val) -{ - return __val == 0; -} - -} -# 1364 "/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); - - - - } -}; -# 1455 "/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); -} - -} - - - - -} -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 2 3 -# 79 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 -extern "C++" -{ -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - using ::acos; - - - inline constexpr float - acos(float __x) - { return __builtin_acosf(__x); } - - inline constexpr long double - acos(long double __x) - { return __builtin_acosl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - acos(_Tp __x) - { return __builtin_acos(__x); } - - using ::asin; - - - inline constexpr float - asin(float __x) - { return __builtin_asinf(__x); } - - inline constexpr long double - asin(long double __x) - { return __builtin_asinl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - asin(_Tp __x) - { return __builtin_asin(__x); } - - using ::atan; - - - inline constexpr float - atan(float __x) - { return __builtin_atanf(__x); } - - inline constexpr long double - atan(long double __x) - { return __builtin_atanl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - atan(_Tp __x) - { return __builtin_atan(__x); } - - using ::atan2; - - - inline constexpr float - atan2(float __y, float __x) - { return __builtin_atan2f(__y, __x); } - - inline constexpr long double - atan2(long double __y, long double __x) - { return __builtin_atan2l(__y, __x); } - - - using ::ceil; - - - inline constexpr float - ceil(float __x) - { return __builtin_ceilf(__x); } - - inline constexpr long double - ceil(long double __x) - { return __builtin_ceill(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - ceil(_Tp __x) - { return __builtin_ceil(__x); } - - using ::cos; - - - inline constexpr float - cos(float __x) - { return __builtin_cosf(__x); } - - inline constexpr long double - cos(long double __x) - { return __builtin_cosl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - cos(_Tp __x) - { return __builtin_cos(__x); } - - using ::cosh; - - - inline constexpr float - cosh(float __x) - { return __builtin_coshf(__x); } - - inline constexpr long double - cosh(long double __x) - { return __builtin_coshl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - cosh(_Tp __x) - { return __builtin_cosh(__x); } - - using ::exp; - - - inline constexpr float - exp(float __x) - { return __builtin_expf(__x); } - - inline constexpr long double - exp(long double __x) - { return __builtin_expl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - exp(_Tp __x) - { return __builtin_exp(__x); } - - using ::fabs; - - - inline constexpr float - fabs(float __x) - { return __builtin_fabsf(__x); } - - inline constexpr long double - fabs(long double __x) - { return __builtin_fabsl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - fabs(_Tp __x) - { return __builtin_fabs(__x); } - - using ::floor; - - - inline constexpr float - floor(float __x) - { return __builtin_floorf(__x); } - - inline constexpr long double - floor(long double __x) - { return __builtin_floorl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - floor(_Tp __x) - { return __builtin_floor(__x); } - - using ::fmod; - - - inline constexpr float - fmod(float __x, float __y) - { return __builtin_fmodf(__x, __y); } - - inline constexpr long double - fmod(long double __x, long double __y) - { return __builtin_fmodl(__x, __y); } - - - using ::frexp; - - - inline float - frexp(float __x, int* __exp) - { return __builtin_frexpf(__x, __exp); } - - inline long double - frexp(long double __x, int* __exp) - { return __builtin_frexpl(__x, __exp); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - frexp(_Tp __x, int* __exp) - { return __builtin_frexp(__x, __exp); } - - using ::ldexp; - - - inline constexpr float - ldexp(float __x, int __exp) - { return __builtin_ldexpf(__x, __exp); } - - inline constexpr long double - ldexp(long double __x, int __exp) - { return __builtin_ldexpl(__x, __exp); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - ldexp(_Tp __x, int __exp) - { return __builtin_ldexp(__x, __exp); } - - using ::log; - - - inline constexpr float - log(float __x) - { return __builtin_logf(__x); } - - inline constexpr long double - log(long double __x) - { return __builtin_logl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - log(_Tp __x) - { return __builtin_log(__x); } - - using ::log10; - - - inline constexpr float - log10(float __x) - { return __builtin_log10f(__x); } - - inline constexpr long double - log10(long double __x) - { return __builtin_log10l(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - log10(_Tp __x) - { return __builtin_log10(__x); } - - using ::modf; - - - inline float - modf(float __x, float* __iptr) - { return __builtin_modff(__x, __iptr); } - - inline long double - modf(long double __x, long double* __iptr) - { return __builtin_modfl(__x, __iptr); } - - - using ::pow; - - - inline constexpr float - pow(float __x, float __y) - { return __builtin_powf(__x, __y); } - - inline constexpr long double - pow(long double __x, long double __y) - { return __builtin_powl(__x, __y); } -# 396 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 - using ::sin; - - - inline constexpr float - sin(float __x) - { return __builtin_sinf(__x); } - - inline constexpr long double - sin(long double __x) - { return __builtin_sinl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - sin(_Tp __x) - { return __builtin_sin(__x); } - - using ::sinh; - - - inline constexpr float - sinh(float __x) - { return __builtin_sinhf(__x); } - - inline constexpr long double - sinh(long double __x) - { return __builtin_sinhl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - sinh(_Tp __x) - { return __builtin_sinh(__x); } - - using ::sqrt; - - - inline constexpr float - sqrt(float __x) - { return __builtin_sqrtf(__x); } - - inline constexpr long double - sqrt(long double __x) - { return __builtin_sqrtl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - sqrt(_Tp __x) - { return __builtin_sqrt(__x); } - - using ::tan; - - - inline constexpr float - tan(float __x) - { return __builtin_tanf(__x); } - - inline constexpr long double - tan(long double __x) - { return __builtin_tanl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - tan(_Tp __x) - { return __builtin_tan(__x); } - - using ::tanh; - - - inline constexpr float - tanh(float __x) - { return __builtin_tanhf(__x); } - - inline constexpr long double - tanh(long double __x) - { return __builtin_tanhl(__x); } - - - template - inline constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - tanh(_Tp __x) - { return __builtin_tanh(__x); } -# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 - template - inline constexpr - typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - atan2(_Tp __y, _Up __x) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return atan2(__type(__y), __type(__x)); - } - - template - inline constexpr - typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - fmod(_Tp __x, _Up __y) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return fmod(__type(__x), __type(__y)); - } - - template - inline constexpr - typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - pow(_Tp __x, _Up __y) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return pow(__type(__x), __type(__y)); - } -# 1096 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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)); - } -# 1881 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 - using ::double_t; - using ::float_t; - - - using ::acosh; - using ::acoshf; - using ::acoshl; - - using ::asinh; - using ::asinhf; - using ::asinhl; - - using ::atanh; - using ::atanhf; - using ::atanhl; - - using ::cbrt; - using ::cbrtf; - using ::cbrtl; - - using ::copysign; - using ::copysignf; - using ::copysignl; - - using ::erf; - using ::erff; - using ::erfl; - - using ::erfc; - using ::erfcf; - using ::erfcl; - - using ::exp2; - using ::exp2f; - using ::exp2l; - - using ::expm1; - using ::expm1f; - using ::expm1l; - - using ::fdim; - using ::fdimf; - using ::fdiml; - - using ::fma; - using ::fmaf; - using ::fmal; - - using ::fmax; - using ::fmaxf; - using ::fmaxl; - - using ::fmin; - using ::fminf; - using ::fminl; - - using ::hypot; - using ::hypotf; - using ::hypotl; - - using ::ilogb; - using ::ilogbf; - using ::ilogbl; - - using ::lgamma; - using ::lgammaf; - using ::lgammal; - - - using ::llrint; - using ::llrintf; - using ::llrintl; - - using ::llround; - using ::llroundf; - using ::llroundl; - - - using ::log1p; - using ::log1pf; - using ::log1pl; - - using ::log2; - using ::log2f; - using ::log2l; - - using ::logb; - using ::logbf; - using ::logbl; - - using ::lrint; - using ::lrintf; - using ::lrintl; - - using ::lround; - using ::lroundf; - using ::lroundl; - - using ::nan; - using ::nanf; - using ::nanl; - - using ::nearbyint; - using ::nearbyintf; - using ::nearbyintl; - - using ::nextafter; - using ::nextafterf; - using ::nextafterl; - - using ::nexttoward; - using ::nexttowardf; - using ::nexttowardl; - - using ::remainder; - using ::remainderf; - using ::remainderl; - - using ::remquo; - using ::remquof; - using ::remquol; - - using ::rint; - using ::rintf; - using ::rintl; - - using ::round; - using ::roundf; - using ::roundl; - - using ::scalbln; - using ::scalblnf; - using ::scalblnl; - - using ::scalbn; - using ::scalbnf; - using ::scalbnl; - - using ::tgamma; - using ::tgammaf; - using ::tgammal; - - using ::trunc; - using ::truncf; - using ::truncl; - - - - constexpr float - acosh(float __x) - { return __builtin_acoshf(__x); } - - constexpr long double - acosh(long double __x) - { return __builtin_acoshl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - acosh(_Tp __x) - { return __builtin_acosh(__x); } - - - - constexpr float - asinh(float __x) - { return __builtin_asinhf(__x); } - - constexpr long double - asinh(long double __x) - { return __builtin_asinhl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - asinh(_Tp __x) - { return __builtin_asinh(__x); } - - - - constexpr float - atanh(float __x) - { return __builtin_atanhf(__x); } - - constexpr long double - atanh(long double __x) - { return __builtin_atanhl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - atanh(_Tp __x) - { return __builtin_atanh(__x); } - - - - constexpr float - cbrt(float __x) - { return __builtin_cbrtf(__x); } - - constexpr long double - cbrt(long double __x) - { return __builtin_cbrtl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - cbrt(_Tp __x) - { return __builtin_cbrt(__x); } - - - - constexpr float - copysign(float __x, float __y) - { return __builtin_copysignf(__x, __y); } - - constexpr long double - copysign(long double __x, long double __y) - { return __builtin_copysignl(__x, __y); } - - - - constexpr float - erf(float __x) - { return __builtin_erff(__x); } - - constexpr long double - erf(long double __x) - { return __builtin_erfl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - erf(_Tp __x) - { return __builtin_erf(__x); } - - - - constexpr float - erfc(float __x) - { return __builtin_erfcf(__x); } - - constexpr long double - erfc(long double __x) - { return __builtin_erfcl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - erfc(_Tp __x) - { return __builtin_erfc(__x); } - - - - constexpr float - exp2(float __x) - { return __builtin_exp2f(__x); } - - constexpr long double - exp2(long double __x) - { return __builtin_exp2l(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - exp2(_Tp __x) - { return __builtin_exp2(__x); } - - - - constexpr float - expm1(float __x) - { return __builtin_expm1f(__x); } - - constexpr long double - expm1(long double __x) - { return __builtin_expm1l(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - expm1(_Tp __x) - { return __builtin_expm1(__x); } - - - - constexpr float - fdim(float __x, float __y) - { return __builtin_fdimf(__x, __y); } - - constexpr long double - fdim(long double __x, long double __y) - { return __builtin_fdiml(__x, __y); } - - - - constexpr float - fma(float __x, float __y, float __z) - { return __builtin_fmaf(__x, __y, __z); } - - constexpr long double - fma(long double __x, long double __y, long double __z) - { return __builtin_fmal(__x, __y, __z); } - - - - constexpr float - fmax(float __x, float __y) - { return __builtin_fmaxf(__x, __y); } - - constexpr long double - fmax(long double __x, long double __y) - { return __builtin_fmaxl(__x, __y); } - - - - constexpr float - fmin(float __x, float __y) - { return __builtin_fminf(__x, __y); } - - constexpr long double - fmin(long double __x, long double __y) - { return __builtin_fminl(__x, __y); } - - - - constexpr float - hypot(float __x, float __y) - { return __builtin_hypotf(__x, __y); } - - constexpr long double - hypot(long double __x, long double __y) - { return __builtin_hypotl(__x, __y); } - - - - constexpr int - ilogb(float __x) - { return __builtin_ilogbf(__x); } - - constexpr int - ilogb(long double __x) - { return __builtin_ilogbl(__x); } - - - - template - constexpr - typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - int>::__type - ilogb(_Tp __x) - { return __builtin_ilogb(__x); } - - - - constexpr float - lgamma(float __x) - { return __builtin_lgammaf(__x); } - - constexpr long double - lgamma(long double __x) - { return __builtin_lgammal(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - lgamma(_Tp __x) - { return __builtin_lgamma(__x); } - - - - constexpr long long - llrint(float __x) - { return __builtin_llrintf(__x); } - - constexpr long long - llrint(long double __x) - { return __builtin_llrintl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - long long>::__type - llrint(_Tp __x) - { return __builtin_llrint(__x); } - - - - constexpr long long - llround(float __x) - { return __builtin_llroundf(__x); } - - constexpr long long - llround(long double __x) - { return __builtin_llroundl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - long long>::__type - llround(_Tp __x) - { return __builtin_llround(__x); } - - - - constexpr float - log1p(float __x) - { return __builtin_log1pf(__x); } - - constexpr long double - log1p(long double __x) - { return __builtin_log1pl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - log1p(_Tp __x) - { return __builtin_log1p(__x); } - - - - - constexpr float - log2(float __x) - { return __builtin_log2f(__x); } - - constexpr long double - log2(long double __x) - { return __builtin_log2l(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - log2(_Tp __x) - { return __builtin_log2(__x); } - - - - constexpr float - logb(float __x) - { return __builtin_logbf(__x); } - - constexpr long double - logb(long double __x) - { return __builtin_logbl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - logb(_Tp __x) - { return __builtin_logb(__x); } - - - - constexpr long - lrint(float __x) - { return __builtin_lrintf(__x); } - - constexpr long - lrint(long double __x) - { return __builtin_lrintl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - long>::__type - lrint(_Tp __x) - { return __builtin_lrint(__x); } - - - - constexpr long - lround(float __x) - { return __builtin_lroundf(__x); } - - constexpr long - lround(long double __x) - { return __builtin_lroundl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - long>::__type - lround(_Tp __x) - { return __builtin_lround(__x); } - - - - constexpr float - nearbyint(float __x) - { return __builtin_nearbyintf(__x); } - - constexpr long double - nearbyint(long double __x) - { return __builtin_nearbyintl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - nearbyint(_Tp __x) - { return __builtin_nearbyint(__x); } - - - - constexpr float - nextafter(float __x, float __y) - { return __builtin_nextafterf(__x, __y); } - - constexpr long double - nextafter(long double __x, long double __y) - { return __builtin_nextafterl(__x, __y); } - - - - constexpr float - nexttoward(float __x, long double __y) - { return __builtin_nexttowardf(__x, __y); } - - constexpr long double - nexttoward(long double __x, long double __y) - { return __builtin_nexttowardl(__x, __y); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - nexttoward(_Tp __x, long double __y) - { return __builtin_nexttoward(__x, __y); } - - - - constexpr float - remainder(float __x, float __y) - { return __builtin_remainderf(__x, __y); } - - constexpr long double - remainder(long double __x, long double __y) - { return __builtin_remainderl(__x, __y); } - - - - inline float - remquo(float __x, float __y, int* __pquo) - { return __builtin_remquof(__x, __y, __pquo); } - - inline long double - remquo(long double __x, long double __y, int* __pquo) - { return __builtin_remquol(__x, __y, __pquo); } - - - - constexpr float - rint(float __x) - { return __builtin_rintf(__x); } - - constexpr long double - rint(long double __x) - { return __builtin_rintl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - rint(_Tp __x) - { return __builtin_rint(__x); } - - - - constexpr float - round(float __x) - { return __builtin_roundf(__x); } - - constexpr long double - round(long double __x) - { return __builtin_roundl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - round(_Tp __x) - { return __builtin_round(__x); } - - - - constexpr float - scalbln(float __x, long __ex) - { return __builtin_scalblnf(__x, __ex); } - - constexpr long double - scalbln(long double __x, long __ex) - { return __builtin_scalblnl(__x, __ex); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - scalbln(_Tp __x, long __ex) - { return __builtin_scalbln(__x, __ex); } - - - - constexpr float - scalbn(float __x, int __ex) - { return __builtin_scalbnf(__x, __ex); } - - constexpr long double - scalbn(long double __x, int __ex) - { return __builtin_scalbnl(__x, __ex); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - scalbn(_Tp __x, int __ex) - { return __builtin_scalbn(__x, __ex); } - - - - constexpr float - tgamma(float __x) - { return __builtin_tgammaf(__x); } - - constexpr long double - tgamma(long double __x) - { return __builtin_tgammal(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - tgamma(_Tp __x) - { return __builtin_tgamma(__x); } - - - - constexpr float - trunc(float __x) - { return __builtin_truncf(__x); } - - constexpr long double - trunc(long double __x) - { return __builtin_truncl(__x); } - - - - template - constexpr typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, - double>::__type - trunc(_Tp __x) - { return __builtin_trunc(__x); } -# 3469 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 - template - constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - copysign(_Tp __x, _Up __y) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return copysign(__type(__x), __type(__y)); - } - - template - constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - fdim(_Tp __x, _Up __y) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return fdim(__type(__x), __type(__y)); - } - - template - constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - fmax(_Tp __x, _Up __y) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return fmax(__type(__x), __type(__y)); - } - - template - constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - fmin(_Tp __x, _Up __y) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return fmin(__type(__x), __type(__y)); - } - - template - constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - hypot(_Tp __x, _Up __y) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return hypot(__type(__x), __type(__y)); - } - - template - constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - nextafter(_Tp __x, _Up __y) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return nextafter(__type(__x), __type(__y)); - } - - template - constexpr typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - remainder(_Tp __x, _Up __y) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return remainder(__type(__x), __type(__y)); - } - - template - inline typename __gnu_cxx::__promote_2<_Tp, _Up>::__type - remquo(_Tp __x, _Up __y, int* __pquo) - { - typedef typename __gnu_cxx::__promote_2<_Tp, _Up>::__type __type; - return remquo(__type(__x), __type(__y), __pquo); - } - - template - constexpr typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type - fma(_Tp __x, _Up __y, _Vp __z) - { - typedef typename __gnu_cxx::__promote_3<_Tp, _Up, _Vp>::__type __type; - return fma(__type(__x), __type(__y), __type(__z)); - } -# 3550 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 - template - inline _Tp - __hypot3(_Tp __x, _Tp __y, _Tp __z) - { - __x = std::abs(__x); - __y = std::abs(__y); - __z = std::abs(__z); - if (_Tp __a = __x < __y ? __y < __z ? __z : __y : __x < __z ? __z : __x) - return __a * std::sqrt((__x / __a) * (__x / __a) - + (__y / __a) * (__y / __a) - + (__z / __a) * (__z / __a)); - else - return {}; - } - - inline float - hypot(float __x, float __y, float __z) - { return std::__hypot3(__x, __y, __z); } - - inline double - hypot(double __x, double __y, double __z) - { return std::__hypot3(__x, __y, __z); } - - inline long double - hypot(long double __x, long double __y, long double __z) - { return std::__hypot3(__x, __y, __z); } - - template - __gnu_cxx::__promoted_t<_Tp, _Up, _Vp> - hypot(_Tp __x, _Up __y, _Vp __z) - { - using __type = __gnu_cxx::__promoted_t<_Tp, _Up, _Vp>; - return std::__hypot3<__type>(__x, __y, __z); - } -# 3696 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/cmath" 3 -} - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/specfun.h" 1 3 -# 43 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/specfun.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 1 3 -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/exception_defines.h" 1 3 -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 2 3 - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - void - __throw_bad_exception(void) __attribute__((__noreturn__)); - - - void - __throw_bad_alloc(void) __attribute__((__noreturn__)); - - void - __throw_bad_array_new_length(void) __attribute__((__noreturn__)); - - - void - __throw_bad_cast(void) __attribute__((__noreturn__)); - - void - __throw_bad_typeid(void) __attribute__((__noreturn__)); - - - void - __throw_logic_error(const char*) __attribute__((__noreturn__)); - - void - __throw_domain_error(const char*) __attribute__((__noreturn__)); - - void - __throw_invalid_argument(const char*) __attribute__((__noreturn__)); - - void - __throw_length_error(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range(const char*) __attribute__((__noreturn__)); - - void - __throw_out_of_range_fmt(const char*, ...) __attribute__((__noreturn__)) - __attribute__((__format__(__gnu_printf__, 1, 2))); - - void - __throw_runtime_error(const char*) __attribute__((__noreturn__)); - - void - __throw_range_error(const char*) __attribute__((__noreturn__)); - - void - __throw_overflow_error(const char*) __attribute__((__noreturn__)); - - void - __throw_underflow_error(const char*) __attribute__((__noreturn__)); - - - void - __throw_ios_failure(const char*) __attribute__((__noreturn__)); - - void - __throw_ios_failure(const char*, int) __attribute__((__noreturn__)); - - - void - __throw_system_error(int) __attribute__((__noreturn__)); - - - void - __throw_future_error(int) __attribute__((__noreturn__)); - - - void - __throw_bad_function_call() __attribute__((__noreturn__)); -# 141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/functexcept.h" 3 -} -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - - - - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 50 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __is_integer_nonstrict - : public std::__is_integer<_Tp> - { - using std::__is_integer<_Tp>::__value; - - - enum { __width = __value ? sizeof(_Tp) * 8 : 0 }; - }; - - template - struct __numeric_traits_integer - { - - static_assert(__is_integer_nonstrict<_Value>::__value, - "invalid specialization"); - - - - - static const bool __is_signed = (_Value)(-1) < 0; - static const int __digits - = __is_integer_nonstrict<_Value>::__width - __is_signed; - - - static const _Value __max = __is_signed - ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1) - : ~(_Value)0; - static const _Value __min = __is_signed ? -__max - 1 : (_Value)0; - }; - - template - const _Value __numeric_traits_integer<_Value>::__min; - - template - const _Value __numeric_traits_integer<_Value>::__max; - - template - const bool __numeric_traits_integer<_Value>::__is_signed; - - template - const int __numeric_traits_integer<_Value>::__digits; -# 130 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; - - - - - - - template - using __int_traits = __numeric_traits_integer<_Tp>; -# 157 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 - template - struct __numeric_traits_floating - { - - static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136); - - - static const bool __is_signed = true; - static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18); - static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932); - }; - - template - const int __numeric_traits_floating<_Value>::__max_digits10; - - template - const bool __numeric_traits_floating<_Value>::__is_signed; - - template - const int __numeric_traits_floating<_Value>::__digits10; - - template - const int __numeric_traits_floating<_Value>::__max_exponent10; - - - - - - - template - struct __numeric_traits - : public __numeric_traits_integer<_Value> - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; - - template<> - struct __numeric_traits - : public __numeric_traits_floating - { }; -# 239 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/ext/numeric_traits.h" 3 -} -# 64 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 1 3 -# 60 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - class reference_wrapper; -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; } - - }; - - - - - - - - using true_type = integral_constant; - - - using false_type = integral_constant; - - - - template - using __bool_constant = integral_constant; - - - - - - - template - using bool_constant = integral_constant; - - - - - - - template - struct enable_if - { }; - - - template - struct enable_if - { typedef _Tp type; }; - - - template - using __enable_if_t = typename enable_if<_Cond, _Tp>::type; - - template - struct __conditional - { - template - using type = _Tp; - }; - - template<> - struct __conditional - { - template - using type = _Up; - }; - - - template - using __conditional_t - = typename __conditional<_Cond>::template type<_If, _Else>; - - - template - struct __type_identity - { using type = _Type; }; - - template - using __type_identity_t = typename __type_identity<_Tp>::type; - - namespace __detail - { - - template - using __first_t = _Tp; - - - template - auto __or_fn(int) -> __first_t...>; - - template - auto __or_fn(...) -> true_type; - - template - auto __and_fn(int) -> __first_t...>; - - template - auto __and_fn(...) -> false_type; - } - - - - - template - struct __or_ - : decltype(__detail::__or_fn<_Bn...>(0)) - { }; - - template - struct __and_ - : decltype(__detail::__and_fn<_Bn...>(0)) - { }; - - template - struct __not_ - : __bool_constant - { }; - - - - - - template - inline constexpr bool __or_v = __or_<_Bn...>::value; - template - inline constexpr bool __and_v = __and_<_Bn...>::value; - - namespace __detail - { - template - struct __disjunction_impl - { using type = _B1; }; - - template - struct __disjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __disjunction_impl::type; }; - - template - struct __conjunction_impl - { using type = _B1; }; - - template - struct __conjunction_impl<__enable_if_t, _B1, _B2, _Bn...> - { using type = typename __conjunction_impl::type; }; - } - - - - - template - struct conjunction - : __detail::__conjunction_impl::type - { }; - - template<> - struct conjunction<> - : true_type - { }; - - template - struct disjunction - : __detail::__disjunction_impl::type - { }; - - template<> - struct disjunction<> - : false_type - { }; - - template - struct negation - : __not_<_Pp>::type - { }; - - - - - template - inline constexpr bool conjunction_v = conjunction<_Bn...>::value; - - template - inline constexpr bool disjunction_v = disjunction<_Bn...>::value; - - template - inline constexpr bool negation_v = negation<_Pp>::value; - - - - - - template - struct is_reference; - template - struct is_function; - template - struct is_void; - template - struct remove_cv; - template - struct is_const; - - - template - struct __is_array_unknown_bounds; - - - - - template - constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>) - { return {}; } - - template - constexpr typename __or_< - is_reference<_NestedType>, - is_function<_NestedType>, - is_void<_NestedType>, - __is_array_unknown_bounds<_NestedType> - >::type __is_complete_or_unbounded(_TypeIdentity) - { return {}; } - - - template - using __remove_cv_t = typename remove_cv<_Tp>::type; - - - - - - template - struct is_void - : public false_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - template<> - struct is_void - : public true_type { }; - - - template - struct __is_integral_helper - : public false_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - - - - - - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; - - template<> - struct __is_integral_helper - : public true_type { }; -# 440 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_integral - : public __is_integral_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct __is_floating_point_helper - : public false_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; - - template<> - struct __is_floating_point_helper - : public true_type { }; -# 500 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_floating_point - : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_array - : public false_type { }; - - template - struct is_array<_Tp[_Size]> - : public true_type { }; - - template - struct is_array<_Tp[]> - : public true_type { }; - - template - struct __is_pointer_helper - : public false_type { }; - - template - struct __is_pointer_helper<_Tp*> - : public true_type { }; - - - template - struct is_pointer - : public __is_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_lvalue_reference - : public false_type { }; - - template - struct is_lvalue_reference<_Tp&> - : public true_type { }; - - - template - struct is_rvalue_reference - : public false_type { }; - - template - struct is_rvalue_reference<_Tp&&> - : public true_type { }; - - template - struct __is_member_object_pointer_helper - : public false_type { }; - - template - struct __is_member_object_pointer_helper<_Tp _Cp::*> - : public __not_>::type { }; - - - template - struct is_member_object_pointer - : public __is_member_object_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct __is_member_function_pointer_helper - : public false_type { }; - - template - struct __is_member_function_pointer_helper<_Tp _Cp::*> - : public is_function<_Tp>::type { }; - - - template - struct is_member_function_pointer - : public __is_member_function_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - - template - struct is_enum - : public integral_constant - { }; - - - template - struct is_union - : public integral_constant - { }; - - - template - struct is_class - : public integral_constant - { }; - - - template - struct is_function - : public __bool_constant::value> { }; - - template - struct is_function<_Tp&> - : public false_type { }; - - template - struct is_function<_Tp&&> - : public false_type { }; - - - - - template - struct is_null_pointer - : public false_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - template<> - struct is_null_pointer - : public true_type { }; - - - - template - struct __is_nullptr_t - : public is_null_pointer<_Tp> - { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead"))); - - - - - template - struct is_reference - : public false_type - { }; - - template - struct is_reference<_Tp&> - : public true_type - { }; - - template - struct is_reference<_Tp&&> - : public true_type - { }; - - - template - struct is_arithmetic - : public __or_, is_floating_point<_Tp>>::type - { }; - - - template - struct is_fundamental - : public __or_, is_void<_Tp>, - is_null_pointer<_Tp>>::type - { }; - - - template - struct is_object - : public __not_<__or_, is_reference<_Tp>, - is_void<_Tp>>>::type - { }; - - template - struct is_member_pointer; - - - template - struct is_scalar - : public __or_, is_enum<_Tp>, is_pointer<_Tp>, - is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type - { }; - - - template - struct is_compound - : public __not_>::type { }; - - - template - struct __is_member_pointer_helper - : public false_type { }; - - template - struct __is_member_pointer_helper<_Tp _Cp::*> - : public true_type { }; - - - - template - struct is_member_pointer - : public __is_member_pointer_helper<__remove_cv_t<_Tp>>::type - { }; - - template - struct is_same; - - - template - using __is_one_of = __or_...>; - - - __extension__ - template - using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>, - signed char, signed short, signed int, signed long, - signed long long -# 733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - __extension__ - template - using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>, - unsigned char, unsigned short, unsigned int, unsigned long, - unsigned long long -# 753 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - >; - - - template - using __is_standard_integer - = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>; - - - template using __void_t = void; - - - - - - template - struct is_const - : public false_type { }; - - template - struct is_const<_Tp const> - : public true_type { }; - - - template - struct is_volatile - : public false_type { }; - - template - struct is_volatile<_Tp volatile> - : public true_type { }; - - - template - struct is_trivial - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copyable - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_standard_layout - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - template - struct - - is_pod - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct - [[__deprecated__]] - is_literal_type - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_empty - : public integral_constant - { }; - - - template - struct is_polymorphic - : public integral_constant - { }; - - - - - - template - struct is_final - : public integral_constant - { }; - - - - template - struct is_abstract - : public integral_constant - { }; - - - template::value> - struct __is_signed_helper - : public false_type { }; - - template - struct __is_signed_helper<_Tp, true> - : public integral_constant - { }; - - - - template - struct is_signed - : public __is_signed_helper<_Tp>::type - { }; - - - template - struct is_unsigned - : public __and_, __not_>>::type - { }; - - - template - _Up - __declval(int); - - template - _Tp - __declval(long); - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)); - - template - struct remove_all_extents; - - - template - struct __is_array_known_bounds - : public false_type - { }; - - template - struct __is_array_known_bounds<_Tp[_Size]> - : public true_type - { }; - - template - struct __is_array_unknown_bounds - : public false_type - { }; - - template - struct __is_array_unknown_bounds<_Tp[]> - : public true_type - { }; -# 936 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - struct __do_is_destructible_impl - { - template().~_Tp())> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_destructible_impl - : public __do_is_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_destructible_safe; - - template - struct __is_destructible_safe<_Tp, false, false> - : public __is_destructible_impl::type>::type - { }; - - template - struct __is_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_destructible - : public __is_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - - - struct __do_is_nt_destructible_impl - { - template - static __bool_constant().~_Tp())> - __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_nt_destructible_impl - : public __do_is_nt_destructible_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template, - __is_array_unknown_bounds<_Tp>, - is_function<_Tp>>::value, - bool = __or_, is_scalar<_Tp>>::value> - struct __is_nt_destructible_safe; - - template - struct __is_nt_destructible_safe<_Tp, false, false> - : public __is_nt_destructible_impl::type>::type - { }; - - template - struct __is_nt_destructible_safe<_Tp, true, false> - : public false_type { }; - - template - struct __is_nt_destructible_safe<_Tp, false, true> - : public true_type { }; - - - - template - struct is_nothrow_destructible - : public __is_nt_destructible_safe<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_constructible_impl - = __bool_constant<__is_constructible(_Tp, _Args...)>; - - - - template - struct is_constructible - : public __is_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_default_constructible - : public __is_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_lvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>> - { using type = _Tp&; }; - - template - using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type; - - - - template - struct is_copy_constructible - : public __is_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct __add_rvalue_reference_helper - { using type = _Tp; }; - - template - struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>> - { using type = _Tp&&; }; - - template - using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type; - - - - template - struct is_move_constructible - : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_constructible_impl - = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>; - - - - template - struct is_nothrow_constructible - : public __is_nothrow_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_default_constructible - : public __is_nothrow_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_constructible - : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>; - - - - template - struct is_assignable - : public __is_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_copy_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_move_assignable - : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_nothrow_assignable_impl - = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>; - - - - template - struct is_nothrow_assignable - : public __is_nothrow_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_copy_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_move_assignable - : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_constructible_impl - = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>; - - - - template - struct is_trivially_constructible - : public __is_trivially_constructible_impl<_Tp, _Args...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_default_constructible - : public __is_trivially_constructible_impl<_Tp> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - struct __do_is_implicitly_default_constructible_impl - { - template - static void __helper(const _Tp&); - - template - static true_type __test(const _Tp&, - decltype(__helper({}))* = 0); - - static false_type __test(...); - }; - - template - struct __is_implicitly_default_constructible_impl - : public __do_is_implicitly_default_constructible_impl - { - typedef decltype(__test(declval<_Tp>())) type; - }; - - template - struct __is_implicitly_default_constructible_safe - : public __is_implicitly_default_constructible_impl<_Tp>::type - { }; - - template - struct __is_implicitly_default_constructible - : public __and_<__is_constructible_impl<_Tp>, - __is_implicitly_default_constructible_safe<_Tp>>::type - { }; - - - template - struct is_trivially_copy_constructible - : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_constructible - : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - using __is_trivially_assignable_impl - = __bool_constant<__is_trivially_assignable(_Tp, _Up)>; - - - - template - struct is_trivially_assignable - : public __is_trivially_assignable_impl<_Tp, _Up> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_copy_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_lval_ref_t> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_move_assignable - : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_trivially_destructible - : public __and_<__is_destructible_safe<_Tp>, - __bool_constant<__has_trivial_destructor(_Tp)>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - struct has_virtual_destructor - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - - - template - struct alignment_of - : public integral_constant - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct rank - : public integral_constant { }; - - template - struct rank<_Tp[_Size]> - : public integral_constant::value> { }; - - template - struct rank<_Tp[]> - : public integral_constant::value> { }; - - - template - struct extent - : public integral_constant { }; - - template - struct extent<_Tp[_Size], 0> - : public integral_constant { }; - - template - struct extent<_Tp[_Size], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - template - struct extent<_Tp[], 0> - : public integral_constant { }; - - template - struct extent<_Tp[], _Uint> - : public extent<_Tp, _Uint - 1>::type { }; - - - - - - template - struct is_same - - : public integral_constant - - - - { }; -# 1409 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct is_base_of - : public integral_constant - { }; - - - template - struct is_convertible - : public __bool_constant<__is_convertible(_From, _To)> - { }; -# 1458 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - using __is_array_convertible - = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>; -# 1522 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_const - { typedef _Tp type; }; - - template - struct remove_const<_Tp const> - { typedef _Tp type; }; - - - template - struct remove_volatile - { typedef _Tp type; }; - - template - struct remove_volatile<_Tp volatile> - { typedef _Tp type; }; - - - - template - struct remove_cv - { using type = __remove_cv(_Tp); }; -# 1563 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct add_const - { using type = _Tp const; }; - - - template - struct add_volatile - { using type = _Tp volatile; }; - - - template - struct add_cv - { using type = _Tp const volatile; }; - - - - - - - template - using remove_const_t = typename remove_const<_Tp>::type; - - - template - using remove_volatile_t = typename remove_volatile<_Tp>::type; - - - template - using remove_cv_t = typename remove_cv<_Tp>::type; - - - template - using add_const_t = typename add_const<_Tp>::type; - - - template - using add_volatile_t = typename add_volatile<_Tp>::type; - - - template - using add_cv_t = typename add_cv<_Tp>::type; -# 1614 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct remove_reference - { using type = _Tp; }; - - template - struct remove_reference<_Tp&> - { using type = _Tp; }; - - template - struct remove_reference<_Tp&&> - { using type = _Tp; }; - - - - template - struct add_lvalue_reference - { using type = __add_lval_ref_t<_Tp>; }; - - - template - struct add_rvalue_reference - { using type = __add_rval_ref_t<_Tp>; }; - - - - template - using remove_reference_t = typename remove_reference<_Tp>::type; - - - template - using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type; - - - template - using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type; - - - - - - - - template - struct __cv_selector; - - template - struct __cv_selector<_Unqualified, false, false> - { 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; }; -# 1741 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_unsigned_selector; - - template - class __make_unsigned_selector<_Tp, true, false> - { - using __unsigned_type - = typename __make_unsigned<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - class __make_unsigned_selector_base - { - protected: - template struct _List { }; - - template - struct _List<_Tp, _Up...> : _List<_Up...> - { static constexpr size_t __size = sizeof(_Tp); }; - - template - struct __select; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, true> - { using __type = _Uint; }; - - template - struct __select<_Sz, _List<_Uint, _UInts...>, false> - : __select<_Sz, _List<_UInts...>> - { }; - }; - - - template - class __make_unsigned_selector<_Tp, false, true> - : __make_unsigned_selector_base - { - - using _UInts = _List; - - using __unsigned_type = typename __select::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type; - }; - - - - - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; -# 1815 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - template<> - struct __make_unsigned - { - using __type - = typename __make_unsigned_selector::__type; - }; - - - - - - - template - struct make_unsigned - { typedef typename __make_unsigned_selector<_Tp>::__type type; }; - - - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - template<> struct make_unsigned; - - - - - template - struct __make_signed - { typedef _Tp __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed char __type; }; - - template<> - struct __make_signed - { typedef signed short __type; }; - - template<> - struct __make_signed - { typedef signed int __type; }; - - template<> - struct __make_signed - { typedef signed long __type; }; - - template<> - struct __make_signed - { typedef signed long long __type; }; -# 1901 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, - bool _IsEnum = is_enum<_Tp>::value> - class __make_signed_selector; - - template - class __make_signed_selector<_Tp, true, false> - { - using __signed_type - = typename __make_signed<__remove_cv_t<_Tp>>::__type; - - public: - using __type - = typename __match_cv_qualifiers<_Tp, __signed_type>::__type; - }; - - - template - class __make_signed_selector<_Tp, false, true> - { - typedef typename __make_unsigned_selector<_Tp>::__type __unsigned_type; - - public: - typedef typename __make_signed_selector<__unsigned_type>::__type __type; - }; - - - - - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; -# 1947 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - template<> - struct __make_signed - { - using __type - = typename __make_signed_selector::__type; - }; - - - - - - - template - struct make_signed - { typedef typename __make_signed_selector<_Tp>::__type type; }; - - - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - template<> struct make_signed; - - - - template - using make_signed_t = typename make_signed<_Tp>::type; - - - template - using make_unsigned_t = typename make_unsigned<_Tp>::type; - - - - - - template - struct remove_extent - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[_Size]> - { typedef _Tp type; }; - - template - struct remove_extent<_Tp[]> - { typedef _Tp type; }; - - - template - struct remove_all_extents - { typedef _Tp type; }; - - template - struct remove_all_extents<_Tp[_Size]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - template - struct remove_all_extents<_Tp[]> - { typedef typename remove_all_extents<_Tp>::type type; }; - - - - template - using remove_extent_t = typename remove_extent<_Tp>::type; - - - template - using remove_all_extents_t = typename remove_all_extents<_Tp>::type; - - - - - template - struct __remove_pointer_helper - { typedef _Tp type; }; - - template - struct __remove_pointer_helper<_Tp, _Up*> - { typedef _Up type; }; - - - template - struct remove_pointer - : public __remove_pointer_helper<_Tp, __remove_cv_t<_Tp>> - { }; - - template - struct __add_pointer_helper - { using type = _Tp; }; - - template - struct __add_pointer_helper<_Tp, __void_t<_Tp*>> - { using type = _Tp*; }; - - - template - struct add_pointer - : public __add_pointer_helper<_Tp> - { }; - - template - struct add_pointer<_Tp&> - { using type = _Tp*; }; - - template - struct add_pointer<_Tp&&> - { using type = _Tp*; }; - - - - template - using remove_pointer_t = typename remove_pointer<_Tp>::type; - - - template - using add_pointer_t = typename add_pointer<_Tp>::type; - - - template - struct __aligned_storage_msa - { - union __type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__)) { } __align; - }; - }; -# 2095 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::__type)> - struct - - aligned_storage - { - union type - { - unsigned char __data[_Len]; - struct __attribute__((__aligned__((_Align)))) { } __align; - }; - }; - - template - struct __strictest_alignment - { - static const size_t _S_alignment = 0; - static const size_t _S_size = 0; - }; - - template - struct __strictest_alignment<_Tp, _Types...> - { - static const size_t _S_alignment = - alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment - ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment; - static const size_t _S_size = - sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size - ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 2141 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/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; -#pragma GCC diagnostic pop - - - - - - template - struct __decay_selector - : __conditional_t::value, - remove_cv<_Up>, - add_pointer<_Up>> - { }; - - template - struct __decay_selector<_Up[_Nm]> - { using type = _Up*; }; - - template - struct __decay_selector<_Up[]> - { using type = _Up*; }; - - - - - template - struct decay - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&> - { using type = typename __decay_selector<_Tp>::type; }; - - template - struct decay<_Tp&&> - { using type = typename __decay_selector<_Tp>::type; }; - - - - - template - struct __strip_reference_wrapper - { - typedef _Tp __type; - }; - - template - struct __strip_reference_wrapper > - { - typedef _Tp& __type; - }; - - - template - using __decay_t = typename decay<_Tp>::type; - - template - using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>; - - - - - - template - using _Require = __enable_if_t<__and_<_Cond...>::value>; - - - template - using __remove_cvref_t - = typename remove_cv::type>::type; - - - - - template - struct conditional - { typedef _Iftrue type; }; - - - template - struct conditional - { typedef _Iffalse type; }; - - - template - struct common_type; -# 2256 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __success_type - { typedef _Tp type; }; - - struct __failure_type - { }; - - struct __do_common_type_impl - { - template - using __cond_t - = decltype(true ? std::declval<_Tp>() : std::declval<_Up>()); - - - - template - static __success_type<__decay_t<__cond_t<_Tp, _Up>>> - _S_test(int); -# 2283 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - static __failure_type - _S_test_2(...); - - template - static decltype(_S_test_2<_Tp, _Up>(0)) - _S_test(...); - }; - - - template<> - struct common_type<> - { }; - - - template - struct common_type<_Tp0> - : public common_type<_Tp0, _Tp0> - { }; - - - template, typename _Dp2 = __decay_t<_Tp2>> - struct __common_type_impl - { - - - using type = common_type<_Dp1, _Dp2>; - }; - - template - struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2> - : private __do_common_type_impl - { - - - using type = decltype(_S_test<_Tp1, _Tp2>(0)); - }; - - - template - struct common_type<_Tp1, _Tp2> - : public __common_type_impl<_Tp1, _Tp2>::type - { }; - - template - struct __common_type_pack - { }; - - template - struct __common_type_fold; - - - template - struct common_type<_Tp1, _Tp2, _Rp...> - : public __common_type_fold, - __common_type_pack<_Rp...>> - { }; - - - - - template - struct __common_type_fold<_CTp, __common_type_pack<_Rp...>, - __void_t> - : public common_type - { }; - - - template - struct __common_type_fold<_CTp, _Rp, void> - { }; - - template::value> - struct __underlying_type_impl - { - using type = __underlying_type(_Tp); - }; - - template - struct __underlying_type_impl<_Tp, false> - { }; - - - - template - struct underlying_type - : public __underlying_type_impl<_Tp> - { }; - - - template - struct __declval_protector - { - static const bool __stop = false; - }; - - - - - - - template - auto declval() noexcept -> decltype(__declval<_Tp>(0)) - { - static_assert(__declval_protector<_Tp>::__stop, - "declval() must not be used!"); - return __declval<_Tp>(0); - } - - - template - struct result_of; - - - - - - - struct __invoke_memfun_ref { }; - struct __invoke_memfun_deref { }; - struct __invoke_memobj_ref { }; - struct __invoke_memobj_deref { }; - struct __invoke_other { }; - - - template - struct __result_of_success : __success_type<_Tp> - { using __invoke_type = _Tag; }; - - - struct __result_of_memfun_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_ref - : private __result_of_memfun_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memfun_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>())(std::declval<_Args>()...) - ), __invoke_memfun_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memfun_deref - : private __result_of_memfun_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type; - }; - - - struct __result_of_memobj_ref_impl - { - template - static __result_of_success().*std::declval<_Fp>() - ), __invoke_memobj_ref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_ref - : private __result_of_memobj_ref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - - struct __result_of_memobj_deref_impl - { - template - static __result_of_success()).*std::declval<_Fp>() - ), __invoke_memobj_deref> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_memobj_deref - : private __result_of_memobj_deref_impl - { - typedef decltype(_S_test<_MemPtr, _Arg>(0)) type; - }; - - template - struct __result_of_memobj; - - template - struct __result_of_memobj<_Res _Class::*, _Arg> - { - typedef __remove_cvref_t<_Arg> _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t<__or_, - is_base_of<_Class, _Argval>>::value, - __result_of_memobj_ref<_MemPtr, _Arg>, - __result_of_memobj_deref<_MemPtr, _Arg> - >::type type; - }; - - template - struct __result_of_memfun; - - template - struct __result_of_memfun<_Res _Class::*, _Arg, _Args...> - { - typedef typename remove_reference<_Arg>::type _Argval; - typedef _Res _Class::* _MemPtr; - typedef typename __conditional_t::value, - __result_of_memfun_ref<_MemPtr, _Arg, _Args...>, - __result_of_memfun_deref<_MemPtr, _Arg, _Args...> - >::type type; - }; - - - - - - - template> - struct __inv_unwrap - { - using type = _Tp; - }; - - template - struct __inv_unwrap<_Tp, reference_wrapper<_Up>> - { - using type = _Up&; - }; - - template - struct __result_of_impl - { - typedef __failure_type type; - }; - - template - struct __result_of_impl - : public __result_of_memobj<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type> - { }; - - template - struct __result_of_impl - : public __result_of_memfun<__decay_t<_MemPtr>, - typename __inv_unwrap<_Arg>::type, _Args...> - { }; - - - struct __result_of_other_impl - { - template - static __result_of_success()(std::declval<_Args>()...) - ), __invoke_other> _S_test(int); - - template - static __failure_type _S_test(...); - }; - - template - struct __result_of_impl - : private __result_of_other_impl - { - typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type; - }; - - - template - struct __invoke_result - : public __result_of_impl< - is_member_object_pointer< - typename remove_reference<_Functor>::type - >::value, - is_member_function_pointer< - typename remove_reference<_Functor>::type - >::value, - _Functor, _ArgTypes... - >::type - { }; - - - template - struct result_of<_Functor(_ArgTypes...)> - : public __invoke_result<_Functor, _ArgTypes...> - { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead"))); - - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" - - template::__type)> - using aligned_storage_t = typename aligned_storage<_Len, _Align>::type; - - template - using aligned_union_t = typename aligned_union<_Len, _Types...>::type; -#pragma GCC diagnostic pop - - - template - using decay_t = typename decay<_Tp>::type; - - - template - using enable_if_t = typename enable_if<_Cond, _Tp>::type; - - - template - using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type; - - - template - using common_type_t = typename common_type<_Tp...>::type; - - - template - using underlying_type_t = typename underlying_type<_Tp>::type; - - - template - using result_of_t = typename result_of<_Tp>::type; - - - - - - template using void_t = void; -# 2659 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template class _Op, typename... _Args> - struct __detector - { - using type = _Default; - using __is_detected = false_type; - }; - - - template class _Op, - typename... _Args> - struct __detector<_Default, __void_t<_Op<_Args...>>, _Op, _Args...> - { - using type = _Op<_Args...>; - using __is_detected = true_type; - }; - - template class _Op, - typename... _Args> - using __detected_or = __detector<_Default, void, _Op, _Args...>; - - - - template class _Op, - typename... _Args> - using __detected_or_t - = typename __detected_or<_Default, _Op, _Args...>::type; -# 2701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template - struct __is_swappable; - - template - struct __is_nothrow_swappable; - - template - struct __is_tuple_like_impl : false_type - { }; - - - template - struct __is_tuple_like - : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type - { }; - - - template - - inline - _Require<__not_<__is_tuple_like<_Tp>>, - is_move_constructible<_Tp>, - is_move_assignable<_Tp>> - swap(_Tp&, _Tp&) - noexcept(__and_, - is_nothrow_move_assignable<_Tp>>::value); - - template - - inline - __enable_if_t<__is_swappable<_Tp>::value> - swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(__is_nothrow_swappable<_Tp>::value); - - - namespace __swappable_details { - using std::swap; - - struct __do_is_swappable_impl - { - template(), std::declval<_Tp&>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_impl - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_nothrow_swappable_impl - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp>(0)) type; - }; - - template - struct __is_swappable - : public __is_swappable_impl<_Tp>::type - { }; - - template - struct __is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { }; - - - - - - - - template - struct is_swappable - : public __is_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable - : public __is_nothrow_swappable_impl<_Tp>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_v = - is_swappable<_Tp>::value; - - - template - inline constexpr bool is_nothrow_swappable_v = - is_nothrow_swappable<_Tp>::value; - - - - namespace __swappable_with_details { - using std::swap; - - struct __do_is_swappable_with_impl - { - template(), std::declval<_Up>())), - typename - = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - struct __do_is_nothrow_swappable_with_impl - { - template - static __bool_constant< - noexcept(swap(std::declval<_Tp>(), std::declval<_Up>())) - && - noexcept(swap(std::declval<_Up>(), std::declval<_Tp>())) - > __test(int); - - template - static false_type __test(...); - }; - - } - - template - struct __is_swappable_with_impl - : public __swappable_with_details::__do_is_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - template - struct __is_nothrow_swappable_with_impl - : public __swappable_with_details::__do_is_nothrow_swappable_with_impl - { - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - - - template - struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&> - : public __swappable_details::__do_is_nothrow_swappable_impl - { - typedef decltype(__test<_Tp&>(0)) type; - }; - - - - template - struct is_swappable_with - : public __is_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_swappable_with - : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "first template argument must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}), - "second template argument must be a complete class or an unbounded array"); - }; - - - - template - inline constexpr bool is_swappable_with_v = - is_swappable_with<_Tp, _Up>::value; - - - template - inline constexpr bool is_nothrow_swappable_with_v = - is_nothrow_swappable_with<_Tp, _Up>::value; -# 2924 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 - template::value, typename = void> - struct __is_invocable_impl - : false_type - { - using __nothrow_conv = false_type; - }; - - - template - struct __is_invocable_impl<_Result, _Ret, - true, - __void_t> - : true_type - { - using __nothrow_conv = true_type; - }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - - template - struct __is_invocable_impl<_Result, _Ret, - false, - __void_t> - { - private: - - using _Res_t = typename _Result::type; - - - - static _Res_t _S_get() noexcept; - - - template - static void _S_conv(__type_identity_t<_Tp>) noexcept; - - - template(_S_get())), - typename = decltype(_S_conv<_Tp>(_S_get())), - - - - bool _Dangle = false - - > - static __bool_constant<_Nothrow && !_Dangle> - _S_test(int); - - template - static false_type - _S_test(...); - - public: - - using type = decltype(_S_test<_Ret, true>(1)); - - - using __nothrow_conv = decltype(_S_test<_Ret>(1)); - }; -#pragma GCC diagnostic pop - - template - struct __is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { }; - - template - constexpr bool __call_is_nt(__invoke_memfun_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept((std::declval<_Up>().*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memfun_deref) - { - return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())( - std::declval<_Args>()...)); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_ref) - { - using _Up = typename __inv_unwrap<_Tp>::type; - return noexcept(std::declval<_Up>().*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_memobj_deref) - { - return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>()); - } - - template - constexpr bool __call_is_nt(__invoke_other) - { - return noexcept(std::declval<_Fn>()(std::declval<_Args>()...)); - } - - template - struct __call_is_nothrow - : __bool_constant< - std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{}) - > - { }; - - template - using __call_is_nothrow_ - = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>; - - - template - struct __is_nothrow_invocable - : __and_<__is_invocable<_Fn, _Args...>, - __call_is_nothrow_<_Fn, _Args...>>::type - { }; - -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wctor-dtor-privacy" - struct __nonesuchbase {}; - struct __nonesuch : private __nonesuchbase { - ~__nonesuch() = delete; - __nonesuch(__nonesuch const&) = delete; - void operator=(__nonesuch const&) = delete; - }; -#pragma GCC diagnostic pop - - - - - - - template - struct invoke_result - : public __invoke_result<_Functor, _ArgTypes...> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}), - "_Functor must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - using invoke_result_t = typename invoke_result<_Fn, _Args...>::type; - - - template - struct is_invocable - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - template - struct is_invocable_r - : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; - - - template - struct is_nothrow_invocable - : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - }; - - - - - - template - using __is_nt_invocable_impl - = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv; - - - - template - struct is_nothrow_invocable_r - : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), - "_Fn must be a complete class or an unbounded array"); - static_assert((std::__is_complete_or_unbounded( - __type_identity<_ArgTypes>{}) && ...), - "each argument type must be a complete class or an unbounded array"); - static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}), - "_Ret must be a complete class or an unbounded array"); - }; -# 3155 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -template - inline constexpr bool is_void_v = is_void<_Tp>::value; -template - inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value; -template - inline constexpr bool is_integral_v = is_integral<_Tp>::value; -template - inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value; - -template - inline constexpr bool is_array_v = false; -template - inline constexpr bool is_array_v<_Tp[]> = true; -template - inline constexpr bool is_array_v<_Tp[_Num]> = true; - -template - inline constexpr bool is_pointer_v = is_pointer<_Tp>::value; -template - inline constexpr bool is_lvalue_reference_v = false; -template - inline constexpr bool is_lvalue_reference_v<_Tp&> = true; -template - inline constexpr bool is_rvalue_reference_v = false; -template - inline constexpr bool is_rvalue_reference_v<_Tp&&> = true; -template - inline constexpr bool is_member_object_pointer_v = - is_member_object_pointer<_Tp>::value; -template - inline constexpr bool is_member_function_pointer_v = - is_member_function_pointer<_Tp>::value; -template - inline constexpr bool is_enum_v = __is_enum(_Tp); -template - inline constexpr bool is_union_v = __is_union(_Tp); -template - inline constexpr bool is_class_v = __is_class(_Tp); -template - inline constexpr bool is_function_v = is_function<_Tp>::value; -template - inline constexpr bool is_reference_v = false; -template - inline constexpr bool is_reference_v<_Tp&> = true; -template - inline constexpr bool is_reference_v<_Tp&&> = true; -template - inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value; -template - inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value; -template - inline constexpr bool is_object_v = is_object<_Tp>::value; -template - inline constexpr bool is_scalar_v = is_scalar<_Tp>::value; -template - inline constexpr bool is_compound_v = is_compound<_Tp>::value; -template - inline constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value; -template - inline constexpr bool is_const_v = false; -template - inline constexpr bool is_const_v = true; -template - inline constexpr bool is_volatile_v = false; -template - inline constexpr bool is_volatile_v = true; - -template - inline constexpr bool is_trivial_v = __is_trivial(_Tp); -template - inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp); -template - inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp); -template - - inline constexpr bool is_pod_v = __is_pod(_Tp); -template - [[__deprecated__]] - inline constexpr bool is_literal_type_v = __is_literal_type(_Tp); -template - inline constexpr bool is_empty_v = __is_empty(_Tp); -template - inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp); -template - inline constexpr bool is_abstract_v = __is_abstract(_Tp); -template - inline constexpr bool is_final_v = __is_final(_Tp); - -template - inline constexpr bool is_signed_v = is_signed<_Tp>::value; -template - inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value; - -template - inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...); -template - inline constexpr bool is_default_constructible_v = __is_constructible(_Tp); -template - inline constexpr bool is_copy_constructible_v - = __is_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_move_constructible_v - = __is_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up); -template - inline constexpr bool is_copy_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t); -template - inline constexpr bool is_move_assignable_v - = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_destructible_v = is_destructible<_Tp>::value; - -template - inline constexpr bool is_trivially_constructible_v - = __is_trivially_constructible(_Tp, _Args...); -template - inline constexpr bool is_trivially_default_constructible_v - = __is_trivially_constructible(_Tp); -template - inline constexpr bool is_trivially_copy_constructible_v - = __is_trivially_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_constructible_v - = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_trivially_assignable_v - = __is_trivially_assignable(_Tp, _Up); -template - inline constexpr bool is_trivially_copy_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_trivially_move_assignable_v - = __is_trivially_assignable(__add_lval_ref_t<_Tp>, - __add_rval_ref_t<_Tp>); -template - inline constexpr bool is_trivially_destructible_v = - is_trivially_destructible<_Tp>::value; -template - inline constexpr bool is_nothrow_constructible_v - = __is_nothrow_constructible(_Tp, _Args...); -template - inline constexpr bool is_nothrow_default_constructible_v - = __is_nothrow_constructible(_Tp); -template - inline constexpr bool is_nothrow_copy_constructible_v - = __is_nothrow_constructible(_Tp, __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_constructible_v - = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_assignable_v - = __is_nothrow_assignable(_Tp, _Up); -template - inline constexpr bool is_nothrow_copy_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, - __add_lval_ref_t); -template - inline constexpr bool is_nothrow_move_assignable_v - = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>); - -template - inline constexpr bool is_nothrow_destructible_v = - is_nothrow_destructible<_Tp>::value; - -template - inline constexpr bool has_virtual_destructor_v - = __has_virtual_destructor(_Tp); - -template - inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value; - -template - inline constexpr size_t rank_v = 0; -template - inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>; -template - inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>; - -template - inline constexpr size_t extent_v = 0; -template - inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size; -template - inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>; -template - inline constexpr size_t extent_v<_Tp[], 0> = 0; -template - inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>; - - -template - inline constexpr bool is_same_v = __is_same(_Tp, _Up); - - - - - - -template - inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived); -template - inline constexpr bool is_convertible_v = __is_convertible(_From, _To); -template - inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_v - = is_nothrow_invocable<_Fn, _Args...>::value; -template - inline constexpr bool is_invocable_r_v - = is_invocable_r<_Ret, _Fn, _Args...>::value; -template - inline constexpr bool is_nothrow_invocable_r_v - = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value; - - - - - - - template - struct has_unique_object_representations - : bool_constant<__has_unique_object_representations( - remove_cv_t> - )> - { - static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), - "template argument must be a complete class or an unbounded array"); - }; - - - template - inline constexpr bool has_unique_object_representations_v - = has_unique_object_representations<_Tp>::value; - - - - - - - template - struct is_aggregate - : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> - { }; - - - - - - template - inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>); -# 3829 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/type_traits" 3 -} -# 61 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 1 3 -# 40 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - template - inline constexpr _Tp* - __addressof(_Tp& __r) noexcept - { return __builtin_addressof(__r); } -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type& __t) noexcept - { return static_cast<_Tp&&>(__t); } - - - - - - - - template - [[__nodiscard__]] - constexpr _Tp&& - forward(typename std::remove_reference<_Tp>::type&& __t) noexcept - { - static_assert(!std::is_lvalue_reference<_Tp>::value, - "std::forward must not be used to convert an rvalue to an lvalue"); - return static_cast<_Tp&&>(__t); - } - - - - - - - template - [[__nodiscard__]] - constexpr typename std::remove_reference<_Tp>::type&& - move(_Tp&& __t) noexcept - { return static_cast::type&&>(__t); } - - - template - struct __move_if_noexcept_cond - : public __and_<__not_>, - is_copy_constructible<_Tp>>::type { }; -# 114 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - constexpr - __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&> - move_if_noexcept(_Tp& __x) noexcept - { return std::move(__x); } -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - [[__nodiscard__]] - inline constexpr _Tp* - addressof(_Tp& __r) noexcept - { return std::__addressof(__r); } - - - - template - const _Tp* addressof(const _Tp&&) = delete; - - - template - - inline _Tp - __exchange(_Tp& __obj, _Up&& __new_val) - { - _Tp __old_val = std::move(__obj); - __obj = std::forward<_Up>(__new_val); - return __old_val; - } -# 179 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/move.h" 3 - template - - inline - - typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>, - is_move_constructible<_Tp>, - is_move_assignable<_Tp>>::value>::type - - - - swap(_Tp& __a, _Tp& __b) - noexcept(__and_, is_nothrow_move_assignable<_Tp>>::value) - - { - - - - - _Tp __tmp = std::move(__a); - __a = std::move(__b); - __b = std::move(__tmp); - } - - - - - template - - inline - - typename enable_if<__is_swappable<_Tp>::value>::type - - - - swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) - noexcept(__is_nothrow_swappable<_Tp>::value) - { - for (size_t __n = 0; __n < _Nm; ++__n) - swap(__a[__n], __b[__n]); - } - - - -} -# 62 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 1 3 -# 37 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - template - struct tuple_size; - - - - - - template::type, - typename = typename enable_if::value>::type, - size_t = tuple_size<_Tp>::value> - using __enable_if_has_tuple_size = _Tp; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - template - struct tuple_size> - : public tuple_size<_Tp> { }; - - - template - inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value; - - - - template - struct tuple_element; - - - template - using __tuple_element_t = typename tuple_element<__i, _Tp>::type; - - template - struct tuple_element<__i, const _Tp> - { - using type = const __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, volatile _Tp> - { - using type = volatile __tuple_element_t<__i, _Tp>; - }; - - template - struct tuple_element<__i, const volatile _Tp> - { - using type = const volatile __tuple_element_t<__i, _Tp>; - }; - - - - - - template - constexpr size_t - __find_uniq_type_in_pack() - { - constexpr size_t __sz = sizeof...(_Types); - constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... }; - size_t __n = __sz; - for (size_t __i = 0; __i < __sz; ++__i) - { - if (__found[__i]) - { - if (__n < __sz) - return __sz; - __n = __i; - } - } - return __n; - } -# 134 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/utility.h" 3 - template - using tuple_element_t = typename tuple_element<__i, _Tp>::type; - - - - - template struct _Index_tuple { }; - - - template - struct _Build_index_tuple - { - - template - using _IdxTuple = _Index_tuple<_Indices...>; - - - using __type = __make_integer_seq<_IdxTuple, size_t, _Num>; - - - - - }; - - - - - - - template - struct integer_sequence - { - typedef _Tp value_type; - static constexpr size_t size() noexcept { return sizeof...(_Idx); } - }; - - - template - using make_integer_sequence - - = __make_integer_seq; - - - - - - template - using index_sequence = integer_sequence; - - - template - using make_index_sequence = make_integer_sequence; - - - template - using index_sequence_for = make_index_sequence; - - - - struct in_place_t { - explicit in_place_t() = default; - }; - - inline constexpr in_place_t in_place{}; - - template struct in_place_type_t - { - explicit in_place_type_t() = default; - }; - - template - inline constexpr in_place_type_t<_Tp> in_place_type{}; - - template struct in_place_index_t - { - explicit in_place_index_t() = default; - }; - - template - inline constexpr in_place_index_t<_Idx> in_place_index{}; - - template - inline constexpr bool __is_in_place_type_v = false; - - template - inline constexpr bool __is_in_place_type_v> = true; - - template - using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>; - - - - - template - struct _Nth_type - { }; - - template - struct _Nth_type<0, _Tp0, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Rest...> - { using type = _Tp1; }; - - template - struct _Nth_type<2, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp2; }; - - template - - - - struct _Nth_type<_Np, _Tp0, _Tp1, _Tp2, _Rest...> - : _Nth_type<_Np - 3, _Rest...> - { }; - - - template - struct _Nth_type<0, _Tp0, _Tp1, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<0, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp0; }; - - template - struct _Nth_type<1, _Tp0, _Tp1, _Tp2, _Rest...> - { using type = _Tp1; }; - - - - - - - -} -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 2 3 - - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 80 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - struct piecewise_construct_t { explicit piecewise_construct_t() = default; }; - - - inline constexpr piecewise_construct_t piecewise_construct = - piecewise_construct_t(); - - - - - template - class tuple; - - template - struct _Index_tuple; - - - - - - - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return __and_, - is_constructible<_T2, const _U2&>>::value; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return __and_, - is_convertible>::value; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return __and_, - is_constructible<_T2, _U2&&>>::value; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return __and_, - is_convertible<_U2&&, _T2>>::value; - } - }; - - template - struct _PCC - { - template - static constexpr bool _ConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyConvertiblePair() - { - return false; - } - - template - static constexpr bool _MoveConstructiblePair() - { - return false; - } - - template - static constexpr bool _ImplicitlyMoveConvertiblePair() - { - return false; - } - }; - - - - template class __pair_base - { - - template friend struct pair; - __pair_base() = default; - ~__pair_base() = default; - __pair_base(const __pair_base&) = default; - __pair_base& operator=(const __pair_base&) = delete; - - }; -# 186 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct pair - : public __pair_base<_T1, _T2> - { - typedef _T1 first_type; - typedef _T2 second_type; - - _T1 first; - _T2 second; - - - constexpr pair(const pair&) = default; - constexpr pair(pair&&) = default; - - template - - pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>); - - - void - swap(pair& __p) - noexcept(__and_<__is_nothrow_swappable<_T1>, - __is_nothrow_swappable<_T2>>::value) - { - using std::swap; - swap(first, __p.first); - swap(second, __p.second); - } -# 234 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - template - - pair(tuple<_Args1...>&, tuple<_Args2...>&, - _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>); - public: -# 525 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template , - __is_implicitly_default_constructible<_U2>> - ::value, bool>::type = true> - constexpr pair() - : first(), second() { } - - template , - is_default_constructible<_U2>, - __not_< - __and_<__is_implicitly_default_constructible<_U1>, - __is_implicitly_default_constructible<_U2>>>> - ::value, bool>::type = false> - explicit constexpr pair() - : first(), second() { } - - - - using _PCCP = _PCC; - - - - template() - && _PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - template() - && !_PCCP::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const _T1& __a, const _T2& __b) - : first(__a), second(__b) { } - - - - template - using _PCCFP = _PCC::value - || !is_same<_T2, _U2>::value, - _T1, _T2>; - - - template::template - _ConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } - - template::template - _ConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(const pair<_U1, _U2>& __p) - : first(__p.first), second(__p.second) - { ; } -# 609 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - private: - - - - struct __zero_as_null_pointer_constant - { - __zero_as_null_pointer_constant(int __zero_as_null_pointer_constant::*) - { } - template::value>> - __zero_as_null_pointer_constant(_Tp) = delete; - }; - - public: - - - - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - is_convertible<_U1, _T1>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template>, - is_pointer<_T2>, - is_constructible<_T1, _U1>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(_U1&& __x, __zero_as_null_pointer_constant, ...) - : first(std::forward<_U1>(__x)), second(nullptr) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - is_convertible<_U2, _T2>>::value, - bool> = true> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - template, - __not_>, - is_constructible<_T2, _U2>, - __not_>, - __not_>>::value, - bool> = false> - __attribute__ ((__deprecated__ ("use 'nullptr' instead of '0' to " "initialize std::pair of move-only " "type and pointer"))) - explicit constexpr - pair(__zero_as_null_pointer_constant, _U2&& __y, ...) - : first(nullptr), second(std::forward<_U2>(__y)) - { ; } - - - - template() - && _PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - template() - && !_PCCP::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(_U1&& __x, _U2&& __y) - : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) - { ; } - - - template::template - _MoveConstructiblePair<_U1, _U2>() - && _PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=true> - constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - template::template - _MoveConstructiblePair<_U1, _U2>() - && !_PCCFP<_U1, _U2>::template - _ImplicitlyMoveConvertiblePair<_U1, _U2>(), - bool>::type=false> - explicit constexpr pair(pair<_U1, _U2>&& __p) - : first(std::forward<_U1>(__p.first)), - second(std::forward<_U2>(__p.second)) - { ; } - - - - pair& - operator=(__conditional_t<__and_, - is_copy_assignable<_T2>>::value, - const pair&, const __nonesuch&> __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - pair& - operator=(__conditional_t<__and_, - is_move_assignable<_T2>>::value, - pair&&, __nonesuch&&> __p) - noexcept(__and_, - is_nothrow_move_assignable<_T2>>::value) - { - first = std::forward(__p.first); - second = std::forward(__p.second); - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, const _U2&>>::value, - pair&>::type - operator=(const pair<_U1, _U2>& __p) - { - first = __p.first; - second = __p.second; - return *this; - } - - template - typename enable_if<__and_, - is_assignable<_T2&, _U2&&>>::value, - pair&>::type - operator=(pair<_U1, _U2>&& __p) - { - first = std::forward<_U1>(__p.first); - second = std::forward<_U2>(__p.second); - return *this; - } -# 801 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - }; - - - - - template pair(_T1, _T2) -> pair<_T1, _T2>; - - - - template - inline constexpr bool - operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first == __y.first && __x.second == __y.second; } -# 833 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline constexpr bool - operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __x.first < __y.first - || (!(__y.first < __x.first) && __x.second < __y.second); } - - - template - inline constexpr bool - operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x == __y); } - - - template - inline constexpr bool - operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return __y < __x; } - - - template - inline constexpr bool - operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__y < __x); } - - - template - inline constexpr bool - operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) - { return !(__x < __y); } -# 870 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - inline - - - typename enable_if<__and_<__is_swappable<_T1>, - __is_swappable<_T2>>::value>::type - - - - swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y) - noexcept(noexcept(__x.swap(__y))) - { __x.swap(__y); } -# 893 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - typename enable_if, - __is_swappable<_T2>>::value>::type - swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete; -# 919 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - constexpr pair::__type, - typename __decay_and_strip<_T2>::__type> - make_pair(_T1&& __x, _T2&& __y) - { - typedef typename __decay_and_strip<_T1>::__type __ds_type1; - typedef typename __decay_and_strip<_T2>::__type __ds_type2; - typedef pair<__ds_type1, __ds_type2> __pair_type; - return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y)); - } -# 942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 - template - struct __is_tuple_like_impl> : true_type - { }; - - - - template - struct tuple_size> - : public integral_constant { }; - - - template - struct tuple_element<0, pair<_Tp1, _Tp2>> - { typedef _Tp1 type; }; - - - template - struct tuple_element<1, pair<_Tp1, _Tp2>> - { typedef _Tp2 type; }; - - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr size_t tuple_size_v> = 2; - - template - inline constexpr bool __is_pair = false; - - template - inline constexpr bool __is_pair> = true; - - - - template - struct __pair_get; - - template<> - struct __pair_get<0> - { - template - static constexpr _Tp1& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr _Tp1&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp1>(__pair.first); } - - template - static constexpr const _Tp1& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.first; } - - template - static constexpr const _Tp1&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.first); } - }; - - template<> - struct __pair_get<1> - { - template - static constexpr _Tp2& - __get(pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr _Tp2&& - __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward<_Tp2>(__pair.second); } - - template - static constexpr const _Tp2& - __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept - { return __pair.second; } - - template - static constexpr const _Tp2&& - __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept - { return std::forward(__pair.second); } - }; - - - - - - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__get(__in); } - - template - constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__move_get(std::move(__in)); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type& - get(const pair<_Tp1, _Tp2>& __in) noexcept - { return __pair_get<_Int>::__const_get(__in); } - - template - constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&& - get(const pair<_Tp1, _Tp2>&& __in) noexcept - { return __pair_get<_Int>::__const_move_get(std::move(__in)); } - - - - - - template - constexpr _Tp& - get(pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr const _Tp& - get(const pair<_Tp, _Up>& __p) noexcept - { return __p.first; } - - template - constexpr _Tp&& - get(pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr const _Tp&& - get(const pair<_Tp, _Up>&& __p) noexcept - { return std::move(__p.first); } - - template - constexpr _Tp& - get(pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr const _Tp& - get(const pair<_Up, _Tp>& __p) noexcept - { return __p.second; } - - template - constexpr _Tp&& - get(pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } - - template - constexpr const _Tp&& - get(const pair<_Up, _Tp>&& __p) noexcept - { return std::move(__p.second); } -# 1119 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_pair.h" 3 -} -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -# 74 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 93 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - struct input_iterator_tag { }; - - - struct output_iterator_tag { }; - - - struct forward_iterator_tag : public input_iterator_tag { }; - - - - struct bidirectional_iterator_tag : public forward_iterator_tag { }; - - - - struct random_access_iterator_tag : public bidirectional_iterator_tag { }; -# 125 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct [[__deprecated__]] iterator - { - - typedef _Category iterator_category; - - typedef _Tp value_type; - - typedef _Distance difference_type; - - typedef _Pointer pointer; - - typedef _Reference reference; - }; -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits; - - - - - template> - struct __iterator_traits { }; - - - - template - struct __iterator_traits<_Iterator, - __void_t> - { - typedef typename _Iterator::iterator_category iterator_category; - typedef typename _Iterator::value_type value_type; - typedef typename _Iterator::difference_type difference_type; - typedef typename _Iterator::pointer pointer; - typedef typename _Iterator::reference reference; - }; - - - template - struct iterator_traits - : public __iterator_traits<_Iterator> { }; -# 209 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 - template - struct iterator_traits<_Tp*> - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef _Tp* pointer; - typedef _Tp& reference; - }; - - - template - struct iterator_traits - { - typedef random_access_iterator_tag iterator_category; - typedef _Tp value_type; - typedef ptrdiff_t difference_type; - typedef const _Tp* pointer; - typedef const _Tp& reference; - }; - - - - - - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_Iter>::iterator_category - __iterator_category(const _Iter&) - { return typename iterator_traits<_Iter>::iterator_category(); } - - - - - template - using __iterator_category_t - = typename iterator_traits<_Iter>::iterator_category; - - template - using _RequireInputIter = - __enable_if_t, - input_iterator_tag>::value>; - - template> - struct __is_random_access_iter - : is_base_of - { - typedef is_base_of _Base; - enum { __value = _Base::value }; - }; -# 270 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_types.h" 3 -} -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 1 3 -# 63 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 1 3 -# 34 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/concept_check.h" 3 -# 65 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/assertions.h" 1 3 -# 66 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 2 3 - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - template struct _List_iterator; - template struct _List_const_iterator; - - - template - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - __distance(_InputIterator __first, _InputIterator __last, - input_iterator_tag) - { - - - - typename iterator_traits<_InputIterator>::difference_type __n = 0; - while (__first != __last) - { - ++__first; - ++__n; - } - return __n; - } - - template - __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_RandomAccessIterator>::difference_type - __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, - random_access_iterator_tag) - { - - - - return __last - __first; - } - - - - template - ptrdiff_t - __distance(std::_List_iterator<_Tp>, - std::_List_iterator<_Tp>, - input_iterator_tag); - - template - ptrdiff_t - __distance(std::_List_const_iterator<_Tp>, - std::_List_const_iterator<_Tp>, - input_iterator_tag); - - - - - template - void - __distance(_OutputIterator, _OutputIterator, output_iterator_tag) = delete; -# 144 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - [[__nodiscard__]] __attribute__((__always_inline__)) - inline constexpr - typename iterator_traits<_InputIterator>::difference_type - distance(_InputIterator __first, _InputIterator __last) - { - - return std::__distance(__first, __last, - std::__iterator_category(__first)); - } - - template - inline constexpr void - __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) - { - - - do { if (std::__is_constant_evaluated() && !bool(__n >= 0)) __builtin_unreachable(); } while (false); - while (__n--) - ++__i; - } - - template - inline constexpr void - __advance(_BidirectionalIterator& __i, _Distance __n, - bidirectional_iterator_tag) - { - - - - if (__n > 0) - while (__n--) - ++__i; - else - while (__n++) - --__i; - } - - template - inline constexpr void - __advance(_RandomAccessIterator& __i, _Distance __n, - random_access_iterator_tag) - { - - - - if (__builtin_constant_p(__n) && __n == 1) - ++__i; - else if (__builtin_constant_p(__n) && __n == -1) - --__i; - else - __i += __n; - } - - - - template - void - __advance(_OutputIterator&, _Distance, output_iterator_tag) = delete; -# 217 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator_base_funcs.h" 3 - template - __attribute__((__always_inline__)) - inline constexpr void - advance(_InputIterator& __i, _Distance __n) - { - - typename iterator_traits<_InputIterator>::difference_type __d = __n; - std::__advance(__i, __d, std::__iterator_category(__i)); - } - - - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _InputIterator - next(_InputIterator __x, typename - iterator_traits<_InputIterator>::difference_type __n = 1) - { - - - std::advance(__x, __n); - return __x; - } - - template - [[__nodiscard__]] [[__gnu__::__always_inline__]] - inline constexpr _BidirectionalIterator - prev(_BidirectionalIterator __x, typename - iterator_traits<_BidirectionalIterator>::difference_type __n = 1) - { - - - - std::advance(__x, -__n); - return __x; - } - - - - -} -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 1 3 -# 67 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 1 3 -# 49 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - class __undefined; - - - - template - struct __get_first_arg - { using type = __undefined; }; - - template class _SomeTemplate, typename _Tp, - typename... _Types> - struct __get_first_arg<_SomeTemplate<_Tp, _Types...>> - { using type = _Tp; }; - - - - template - struct __replace_first_arg - { }; - - template class _SomeTemplate, typename _Up, - typename _Tp, typename... _Types> - struct __replace_first_arg<_SomeTemplate<_Tp, _Types...>, _Up> - { using type = _SomeTemplate<_Up, _Types...>; }; - - - template - struct __ptr_traits_elem : __get_first_arg<_Ptr> - { }; - - - - - - - - template - struct __ptr_traits_elem<_Ptr, __void_t> - { using type = typename _Ptr::element_type; }; - - - template - using __ptr_traits_elem_t = typename __ptr_traits_elem<_Ptr>::type; - - - - - template::value> - struct __ptr_traits_ptr_to - { - using pointer = _Ptr; - using element_type = _Elt; - - - - - - - - static pointer - pointer_to(element_type& __r) - - - - - - { return pointer::pointer_to(__r); } - }; - - - template - struct __ptr_traits_ptr_to<_Ptr, _Elt, true> - { }; - - - template - struct __ptr_traits_ptr_to<_Tp*, _Tp, false> - { - using pointer = _Tp*; - using element_type = _Tp; - - - - - - - static pointer - pointer_to(element_type& __r) noexcept - { return std::addressof(__r); } - }; - - template - struct __ptr_traits_impl : __ptr_traits_ptr_to<_Ptr, _Elt> - { - private: - template - using __diff_t = typename _Tp::difference_type; - - template - using __rebind = __type_identity>; - - public: - - using pointer = _Ptr; - - - using element_type = _Elt; - - - using difference_type = __detected_or_t; - - - template - using rebind = typename __detected_or_t<__replace_first_arg<_Ptr, _Up>, - __rebind, _Ptr, _Up>::type; - }; - - - - template - struct __ptr_traits_impl<_Ptr, __undefined> - { }; - - - - - - - - template - struct pointer_traits : __ptr_traits_impl<_Ptr, __ptr_traits_elem_t<_Ptr>> - { }; - - - - - - - - template - struct pointer_traits<_Tp*> : __ptr_traits_ptr_to<_Tp*, _Tp> - { - - typedef _Tp* pointer; - - typedef _Tp element_type; - - typedef ptrdiff_t difference_type; - - template using rebind = _Up*; - }; - - - template - using __ptr_rebind = typename pointer_traits<_Ptr>::template rebind<_Tp>; - - template - constexpr _Tp* - __to_address(_Tp* __ptr) noexcept - { - static_assert(!std::is_function<_Tp>::value, "not a function pointer"); - return __ptr; - } - - - template - constexpr typename std::pointer_traits<_Ptr>::element_type* - __to_address(const _Ptr& __ptr) - { return std::__to_address(__ptr.operator->()); } -# 267 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/ptr_traits.h" 3 -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 2 3 -# 88 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 113 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wdeprecated-declarations" -# 135 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class reverse_iterator - : public iterator::iterator_category, - typename iterator_traits<_Iterator>::value_type, - typename iterator_traits<_Iterator>::difference_type, - typename iterator_traits<_Iterator>::pointer, - typename iterator_traits<_Iterator>::reference> - { - template - friend class reverse_iterator; -# 154 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - protected: - _Iterator current; - - typedef iterator_traits<_Iterator> __traits_type; - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::pointer pointer; - - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - constexpr - reverse_iterator() - noexcept(noexcept(_Iterator())) - : current() - { } - - - - - explicit constexpr - reverse_iterator(iterator_type __x) - noexcept(noexcept(_Iterator(__x))) - : current(__x) - { } - - - - - constexpr - reverse_iterator(const reverse_iterator& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - reverse_iterator& operator=(const reverse_iterator&) = default; - - - - - - - template - - - - constexpr - reverse_iterator(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(_Iterator(__x.current))) - : current(__x.current) - { } - - - template - - - - - constexpr - reverse_iterator& - operator=(const reverse_iterator<_Iter>& __x) - noexcept(noexcept(current = __x.current)) - { - current = __x.current; - return *this; - } - - - - - - [[__nodiscard__]] - constexpr iterator_type - base() const - noexcept(noexcept(_Iterator(current))) - { return current; } -# 262 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - { - _Iterator __tmp = current; - return *--__tmp; - } - - - - - - - [[__nodiscard__]] - constexpr pointer - operator->() const - - - - - { - - - _Iterator __tmp = current; - --__tmp; - return _S_to_pointer(__tmp); - } - - - - - - - constexpr reverse_iterator& - operator++() - { - --current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator++(int) - { - reverse_iterator __tmp = *this; - --current; - return __tmp; - } - - - - - - - constexpr reverse_iterator& - operator--() - { - ++current; - return *this; - } - - - - - - - constexpr reverse_iterator - operator--(int) - { - reverse_iterator __tmp = *this; - ++current; - return __tmp; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator+(difference_type __n) const - { return reverse_iterator(current - __n); } - - - - - - - - constexpr reverse_iterator& - operator+=(difference_type __n) - { - current -= __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reverse_iterator - operator-(difference_type __n) const - { return reverse_iterator(current + __n); } - - - - - - - - constexpr reverse_iterator& - operator-=(difference_type __n) - { - current += __n; - return *this; - } - - - - - - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - { return *(*this + __n); } -# 422 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - private: - template - static constexpr _Tp* - _S_to_pointer(_Tp* __p) - { return __p; } - - template - static constexpr pointer - _S_to_pointer(_Tp __t) - { return __t.operator->(); } - }; -# 445 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y.base() < __x.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_Iterator>& __x, - const reverse_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() == __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() > __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() != __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() < __y.base(); } - - template - inline constexpr bool - operator<=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() >= __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - { return __x.base() <= __y.base(); } -# 622 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr auto - operator-(const reverse_iterator<_IteratorL>& __x, - const reverse_iterator<_IteratorR>& __y) - -> decltype(__y.base() - __x.base()) - { return __y.base() - __x.base(); } - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - operator+(typename reverse_iterator<_Iterator>::difference_type __n, - const reverse_iterator<_Iterator>& __x) - { return reverse_iterator<_Iterator>(__x.base() - __n); } - - - - template - inline constexpr reverse_iterator<_Iterator> - __make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } - - - - - - - - template - [[__nodiscard__]] - inline constexpr reverse_iterator<_Iterator> - make_reverse_iterator(_Iterator __i) - { return reverse_iterator<_Iterator>(__i); } -# 666 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__niter_base(__it.base()))) - { return __make_reverse_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - : __is_move_iterator<_Iterator> - { }; - - template - - auto - __miter_base(reverse_iterator<_Iterator> __it) - -> decltype(__make_reverse_iterator(__miter_base(__it.base()))) - { return __make_reverse_iterator(__miter_base(__it.base())); } -# 697 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class back_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - back_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 736 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - back_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_back(__value); - return *this; - } - - - back_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_back(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - back_insert_iterator& - operator*() - { return *this; } - - - - back_insert_iterator& - operator++() - { return *this; } - - - - back_insert_iterator - operator++(int) - { return *this; } - }; -# 782 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline back_insert_iterator<_Container> - back_inserter(_Container& __x) - { return back_insert_iterator<_Container>(__x); } -# 798 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class front_insert_iterator - : public iterator - { - protected: - _Container* container; - - public: - - typedef _Container container_type; - - - - - - explicit - front_insert_iterator(_Container& __x) - : container(std::__addressof(__x)) { } -# 837 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - front_insert_iterator& - operator=(const typename _Container::value_type& __value) - { - container->push_front(__value); - return *this; - } - - - front_insert_iterator& - operator=(typename _Container::value_type&& __value) - { - container->push_front(std::move(__value)); - return *this; - } - - - - [[__nodiscard__]] - front_insert_iterator& - operator*() - { return *this; } - - - - front_insert_iterator& - operator++() - { return *this; } - - - - front_insert_iterator - operator++(int) - { return *this; } - }; -# 883 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline front_insert_iterator<_Container> - front_inserter(_Container& __x) - { return front_insert_iterator<_Container>(__x); } -# 903 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class insert_iterator - : public iterator - { - - - - typedef typename _Container::iterator _Iter; - - protected: - _Container* container; - _Iter iter; - - public: - - typedef _Container container_type; -# 929 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator(_Container& __x, _Iter __i) - : container(std::__addressof(__x)), iter(__i) {} -# 965 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - insert_iterator& - operator=(const typename _Container::value_type& __value) - { - iter = container->insert(iter, __value); - ++iter; - return *this; - } - - - insert_iterator& - operator=(typename _Container::value_type&& __value) - { - iter = container->insert(iter, std::move(__value)); - ++iter; - return *this; - } - - - - [[__nodiscard__]] - insert_iterator& - operator*() - { return *this; } - - - - insert_iterator& - operator++() - { return *this; } - - - - insert_iterator& - operator++(int) - { return *this; } - }; - -#pragma GCC diagnostic pop -# 1023 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline insert_iterator<_Container> - inserter(_Container& __x, typename _Container::iterator __i) - { return insert_iterator<_Container>(__x, __i); } - - - - - -} - -namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) -{ -# 1046 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class __normal_iterator - { - protected: - _Iterator _M_current; - - typedef std::iterator_traits<_Iterator> __traits_type; - - - template - using __convertible_from - = std::__enable_if_t::value>; - - - public: - typedef _Iterator iterator_type; - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - typedef typename __traits_type::reference reference; - typedef typename __traits_type::pointer pointer; - - - - - - constexpr __normal_iterator() noexcept - : _M_current(_Iterator()) { } - - explicit - __normal_iterator(const _Iterator& __i) noexcept - : _M_current(__i) { } - - - - template> - - __normal_iterator(const __normal_iterator<_Iter, _Container>& __i) - noexcept -# 1094 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - : _M_current(__i.base()) { } - - - - reference - operator*() const noexcept - { return *_M_current; } - - - pointer - operator->() const noexcept - { return _M_current; } - - - __normal_iterator& - operator++() noexcept - { - ++_M_current; - return *this; - } - - - __normal_iterator - operator++(int) noexcept - { return __normal_iterator(_M_current++); } - - - - __normal_iterator& - operator--() noexcept - { - --_M_current; - return *this; - } - - - __normal_iterator - operator--(int) noexcept - { return __normal_iterator(_M_current--); } - - - - reference - operator[](difference_type __n) const noexcept - { return _M_current[__n]; } - - - __normal_iterator& - operator+=(difference_type __n) noexcept - { _M_current += __n; return *this; } - - - __normal_iterator - operator+(difference_type __n) const noexcept - { return __normal_iterator(_M_current + __n); } - - - __normal_iterator& - operator-=(difference_type __n) noexcept - { _M_current -= __n; return *this; } - - - __normal_iterator - operator-(difference_type __n) const noexcept - { return __normal_iterator(_M_current - __n); } - - - const _Iterator& - base() const noexcept - { return _M_current; } - }; -# 1214 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator==(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() == __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() != __rhs.base(); } - - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() < __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() > __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() <= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - template - [[__nodiscard__]] - inline bool - operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() >= __rhs.base(); } - - - - - - - template - - - [[__nodiscard__]] - inline auto - operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, - const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept - -> decltype(__lhs.base() - __rhs.base()) - - - - - - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline typename __normal_iterator<_Iterator, _Container>::difference_type - operator-(const __normal_iterator<_Iterator, _Container>& __lhs, - const __normal_iterator<_Iterator, _Container>& __rhs) - noexcept - { return __lhs.base() - __rhs.base(); } - - template - [[__nodiscard__]] - inline __normal_iterator<_Iterator, _Container> - operator+(typename __normal_iterator<_Iterator, _Container>::difference_type - __n, const __normal_iterator<_Iterator, _Container>& __i) - noexcept - { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } - - -} - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - template - - _Iterator - __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it.base(); } - - - - - - - template - constexpr auto - __to_address(const __gnu_cxx::__normal_iterator<_Iterator, - _Container>& __it) noexcept - -> decltype(std::__to_address(__it.base())) - { return std::__to_address(__it.base()); } -# 1421 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - namespace __detail - { -# 1437 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - } -# 1448 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - class move_iterator - - - - { - _Iterator _M_current; - - using __traits_type = iterator_traits<_Iterator>; - - using __base_ref = typename __traits_type::reference; - - - template - friend class move_iterator; -# 1487 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - public: - using iterator_type = _Iterator; -# 1501 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - typedef typename __traits_type::iterator_category iterator_category; - typedef typename __traits_type::value_type value_type; - typedef typename __traits_type::difference_type difference_type; - - typedef _Iterator pointer; - - - using reference - = __conditional_t::value, - typename remove_reference<__base_ref>::type&&, - __base_ref>; - - - constexpr - move_iterator() - : _M_current() { } - - explicit constexpr - move_iterator(iterator_type __i) - : _M_current(std::move(__i)) { } - - template - - - - constexpr - move_iterator(const move_iterator<_Iter>& __i) - : _M_current(__i._M_current) { } - - template - - - - - constexpr - move_iterator& operator=(const move_iterator<_Iter>& __i) - { - _M_current = __i._M_current; - return *this; - } - - - [[__nodiscard__]] - constexpr iterator_type - base() const - { return _M_current; } -# 1559 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - [[__nodiscard__]] - constexpr reference - operator*() const - - - - { return static_cast(*_M_current); } - - - [[__nodiscard__]] - constexpr pointer - operator->() const - { return _M_current; } - - constexpr move_iterator& - operator++() - { - ++_M_current; - return *this; - } - - constexpr move_iterator - operator++(int) - { - move_iterator __tmp = *this; - ++_M_current; - return __tmp; - } - - - - - - - - constexpr move_iterator& - operator--() - { - --_M_current; - return *this; - } - - constexpr move_iterator - operator--(int) - { - move_iterator __tmp = *this; - --_M_current; - return __tmp; - } - - [[__nodiscard__]] - constexpr move_iterator - operator+(difference_type __n) const - { return move_iterator(_M_current + __n); } - - constexpr move_iterator& - operator+=(difference_type __n) - { - _M_current += __n; - return *this; - } - - [[__nodiscard__]] - constexpr move_iterator - operator-(difference_type __n) const - { return move_iterator(_M_current - __n); } - - constexpr move_iterator& - operator-=(difference_type __n) - { - _M_current -= __n; - return *this; - } - - [[__nodiscard__]] - constexpr reference - operator[](difference_type __n) const - - - - { return std::move(_M_current[__n]); } -# 1673 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - }; - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() == __y.base(); } -# 1694 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - { return !(__x == __y); } - - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - - - - { return !(__x < __y); } - - - - - template - [[__nodiscard__]] - inline constexpr bool - operator==(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() == __y.base(); } -# 1760 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - [[__nodiscard__]] - inline constexpr bool - operator!=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x == __y); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __x.base() < __y.base(); } - - template - [[__nodiscard__]] - inline constexpr bool - operator<=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__y < __x); } - - template - [[__nodiscard__]] - inline constexpr bool - operator>(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return __y < __x; } - - template - [[__nodiscard__]] - inline constexpr bool - operator>=(const move_iterator<_Iterator>& __x, - const move_iterator<_Iterator>& __y) - { return !(__x < __y); } - - - - template - [[__nodiscard__]] - inline constexpr auto - operator-(const move_iterator<_IteratorL>& __x, - const move_iterator<_IteratorR>& __y) - -> decltype(__x.base() - __y.base()) - { return __x.base() - __y.base(); } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - operator+(typename move_iterator<_Iterator>::difference_type __n, - const move_iterator<_Iterator>& __x) - { return __x + __n; } - - template - [[__nodiscard__]] - inline constexpr move_iterator<_Iterator> - make_move_iterator(_Iterator __i) - { return move_iterator<_Iterator>(std::move(__i)); } - - template::value_type>::value, - _Iterator, move_iterator<_Iterator>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Iterator __i) - { return _ReturnType(__i); } - - - - template::value, - const _Tp*, move_iterator<_Tp*>>> - inline constexpr _ReturnType - __make_move_if_noexcept_iterator(_Tp* __i) - { return _ReturnType(__i); } -# 2952 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - - auto - __niter_base(move_iterator<_Iterator> __it) - -> decltype(make_move_iterator(__niter_base(__it.base()))) - { return make_move_iterator(__niter_base(__it.base())); } - - template - struct __is_move_iterator > - { - enum { __value = 1 }; - typedef __true_type __type; - }; - - template - - auto - __miter_base(move_iterator<_Iterator> __it) - -> decltype(__miter_base(__it.base())) - { return __miter_base(__it.base()); } -# 2984 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_iterator.h" 3 - template - using __iter_key_t = remove_const_t< - typename iterator_traits<_InputIterator>::value_type::first_type>; - - template - using __iter_val_t - = typename iterator_traits<_InputIterator>::value_type::second_type; - - template - struct pair; - - template - using __iter_to_alloc_t - = pair, __iter_val_t<_InputIterator>>; - - - -} -# 68 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 1 3 -# 48 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/debug/debug.h" 3 -namespace std -{ - namespace __debug { } -} - - - - -namespace __gnu_debug -{ - using namespace std::__debug; - - template - struct _Safe_iterator; -} -# 70 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 1 3 -# 35 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/predefined_ops.h" 3 -namespace __gnu_cxx -{ -namespace __ops -{ - struct _Iter_less_iter - { - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 < *__it2; } - }; - - constexpr - inline _Iter_less_iter - __iter_less_iter() - { return _Iter_less_iter(); } - - struct _Iter_less_val - { - - constexpr _Iter_less_val() = default; - - - - - - explicit - _Iter_less_val(_Iter_less_iter) { } - - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it < __val; } - }; - - - inline _Iter_less_val - __iter_less_val() - { return _Iter_less_val(); } - - - inline _Iter_less_val - __iter_comp_val(_Iter_less_iter) - { return _Iter_less_val(); } - - struct _Val_less_iter - { - - constexpr _Val_less_iter() = default; - - - - - - explicit - _Val_less_iter(_Iter_less_iter) { } - - template - - bool - operator()(_Value& __val, _Iterator __it) const - { return __val < *__it; } - }; - - - inline _Val_less_iter - __val_less_iter() - { return _Val_less_iter(); } - - - inline _Val_less_iter - __val_comp_iter(_Iter_less_iter) - { return _Val_less_iter(); } - - struct _Iter_equal_to_iter - { - template - - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) const - { return *__it1 == *__it2; } - }; - - - inline _Iter_equal_to_iter - __iter_equal_to_iter() - { return _Iter_equal_to_iter(); } - - struct _Iter_equal_to_val - { - template - - bool - operator()(_Iterator __it, _Value& __val) const - { return *__it == __val; } - }; - - - inline _Iter_equal_to_val - __iter_equal_to_val() - { return _Iter_equal_to_val(); } - - - inline _Iter_equal_to_val - __iter_comp_val(_Iter_equal_to_iter) - { return _Iter_equal_to_val(); } - - template - struct _Iter_comp_iter - { - _Compare _M_comp; - - explicit constexpr - _Iter_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - template - constexpr - bool - operator()(_Iterator1 __it1, _Iterator2 __it2) - { return bool(_M_comp(*__it1, *__it2)); } - }; - - template - constexpr - inline _Iter_comp_iter<_Compare> - __iter_comp_iter(_Compare __comp) - { return _Iter_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_comp_val - { - _Compare _M_comp; - - - explicit - _Iter_comp_val(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Iter_comp_val(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Iter_comp_val(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Iterator __it, _Value& __val) - { return bool(_M_comp(*__it, __val)); } - }; - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Compare __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - - inline _Iter_comp_val<_Compare> - __iter_comp_val(_Iter_comp_iter<_Compare> __comp) - { return _Iter_comp_val<_Compare>(std::move(__comp)); } - - template - struct _Val_comp_iter - { - _Compare _M_comp; - - - explicit - _Val_comp_iter(_Compare __comp) - : _M_comp(std::move(__comp)) - { } - - - explicit - _Val_comp_iter(const _Iter_comp_iter<_Compare>& __comp) - : _M_comp(__comp._M_comp) - { } - - - - explicit - _Val_comp_iter(_Iter_comp_iter<_Compare>&& __comp) - : _M_comp(std::move(__comp._M_comp)) - { } - - - template - - bool - operator()(_Value& __val, _Iterator __it) - { return bool(_M_comp(__val, *__it)); } - }; - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Compare __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - - inline _Val_comp_iter<_Compare> - __val_comp_iter(_Iter_comp_iter<_Compare> __comp) - { return _Val_comp_iter<_Compare>(std::move(__comp)); } - - template - struct _Iter_equals_val - { - _Value& _M_value; - - - explicit - _Iter_equals_val(_Value& __value) - : _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return *__it == _M_value; } - }; - - template - - inline _Iter_equals_val<_Value> - __iter_equals_val(_Value& __val) - { return _Iter_equals_val<_Value>(__val); } - - template - struct _Iter_equals_iter - { - _Iterator1 _M_it1; - - - explicit - _Iter_equals_iter(_Iterator1 __it1) - : _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return *__it2 == *_M_it1; } - }; - - template - - inline _Iter_equals_iter<_Iterator> - __iter_comp_iter(_Iter_equal_to_iter, _Iterator __it) - { return _Iter_equals_iter<_Iterator>(__it); } - - template - struct _Iter_pred - { - _Predicate _M_pred; - - - explicit - _Iter_pred(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_pred<_Predicate> - __pred_iter(_Predicate __pred) - { return _Iter_pred<_Predicate>(std::move(__pred)); } - - template - struct _Iter_comp_to_val - { - _Compare _M_comp; - _Value& _M_value; - - - _Iter_comp_to_val(_Compare __comp, _Value& __value) - : _M_comp(std::move(__comp)), _M_value(__value) - { } - - template - - bool - operator()(_Iterator __it) - { return bool(_M_comp(*__it, _M_value)); } - }; - - template - _Iter_comp_to_val<_Compare, _Value> - - __iter_comp_val(_Compare __comp, _Value &__val) - { - return _Iter_comp_to_val<_Compare, _Value>(std::move(__comp), __val); - } - - template - struct _Iter_comp_to_iter - { - _Compare _M_comp; - _Iterator1 _M_it1; - - - _Iter_comp_to_iter(_Compare __comp, _Iterator1 __it1) - : _M_comp(std::move(__comp)), _M_it1(__it1) - { } - - template - - bool - operator()(_Iterator2 __it2) - { return bool(_M_comp(*__it2, *_M_it1)); } - }; - - template - - inline _Iter_comp_to_iter<_Compare, _Iterator> - __iter_comp_iter(_Iter_comp_iter<_Compare> __comp, _Iterator __it) - { - return _Iter_comp_to_iter<_Compare, _Iterator>( - std::move(__comp._M_comp), __it); - } - - template - struct _Iter_negate - { - _Predicate _M_pred; - - - explicit - _Iter_negate(_Predicate __pred) - : _M_pred(std::move(__pred)) - { } - - template - - bool - operator()(_Iterator __it) - { return !bool(_M_pred(*__it)); } - }; - - template - - inline _Iter_negate<_Predicate> - __negate(_Iter_pred<_Predicate> __pred) - { return _Iter_negate<_Predicate>(std::move(__pred._M_pred)); } - -} -} -# 72 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 1 3 -# 33 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -# 55 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ -# 149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 - template - constexpr _Tp - __rotl(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x << __r) | (__x >> ((_Nd - __r) % _Nd)); - else - return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); - } - - template - constexpr _Tp - __rotr(_Tp __x, int __s) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if constexpr ((_Nd & (_Nd - 1)) == 0) - { - - - constexpr unsigned __uNd = _Nd; - const unsigned __r = __s; - return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd)); - } - const int __r = __s % _Nd; - if (__r == 0) - return __x; - else if (__r > 0) - return (__x >> __r) | (__x << ((_Nd - __r) % _Nd)); - else - return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); - } - - template - constexpr int - __countl_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - { - constexpr int __diff = _Nd_u - _Nd; - return __builtin_clz(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ul) - { - constexpr int __diff = _Nd_ul - _Nd; - return __builtin_clzl(__x) - __diff; - } - else if constexpr (_Nd <= _Nd_ull) - { - constexpr int __diff = _Nd_ull - _Nd; - return __builtin_clzll(__x) - __diff; - } - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - unsigned long long __high = __x >> _Nd_ull; - if (__high != 0) - { - constexpr int __diff = (2 * _Nd_ull) - _Nd; - return __builtin_clzll(__high) - __diff; - } - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - return (_Nd - _Nd_ull) + __builtin_clzll(__low); - } - } - - template - constexpr int - __countl_one(_Tp __x) noexcept - { - return std::__countl_zero<_Tp>((_Tp)~__x); - } - - template - constexpr int - __countr_zero(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - if (__x == 0) - return _Nd; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_ctz(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_ctzl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_ctzll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - if (__low != 0) - return __builtin_ctzll(__low); - unsigned long long __high = __x >> _Nd_ull; - return __builtin_ctzll(__high) + _Nd_ull; - } - } - - template - constexpr int - __countr_one(_Tp __x) noexcept - { - return std::__countr_zero((_Tp)~__x); - } - - template - constexpr int - __popcount(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - - constexpr auto _Nd_ull = __int_traits::__digits; - constexpr auto _Nd_ul = __int_traits::__digits; - constexpr auto _Nd_u = __int_traits::__digits; - - if constexpr (_Nd <= _Nd_u) - return __builtin_popcount(__x); - else if constexpr (_Nd <= _Nd_ul) - return __builtin_popcountl(__x); - else if constexpr (_Nd <= _Nd_ull) - return __builtin_popcountll(__x); - else - { - static_assert(_Nd <= (2 * _Nd_ull), - "Maximum supported integer size is 128-bit"); - - constexpr auto __max_ull = __int_traits::__max; - unsigned long long __low = __x & __max_ull; - unsigned long long __high = __x >> _Nd_ull; - return __builtin_popcountll(__low) + __builtin_popcountll(__high); - } - } - - template - constexpr bool - __has_single_bit(_Tp __x) noexcept - { return std::__popcount(__x) == 1; } - - template - constexpr _Tp - __bit_ceil(_Tp __x) noexcept - { - using __gnu_cxx::__int_traits; - constexpr auto _Nd = __int_traits<_Tp>::__digits; - if (__x == 0 || __x == 1) - return 1; - auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u)); - - - - - if (!std::__is_constant_evaluated()) - { - do { if (std::__is_constant_evaluated() && !bool(__shift_exponent != __int_traits<_Tp>::__digits)) __builtin_unreachable(); } while (false); - } - - using __promoted_type = decltype(__x << 1); - if constexpr (!is_same<__promoted_type, _Tp>::value) - { - - - - - - const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2; - __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp; - } - return (_Tp)1u << __shift_exponent; - } - - template - constexpr _Tp - __bit_floor(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - if (__x == 0) - return 0; - return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1))); - } - - template - constexpr int - __bit_width(_Tp __x) noexcept - { - constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits; - return _Nd - std::__countl_zero(__x); - } -# 479 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bit" 3 -} -# 77 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 2 3 - - - - - -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - template - constexpr - inline int - __memcmp(const _Tp* __first1, const _Up* __first2, size_t __num) - { - - static_assert(sizeof(_Tp) == sizeof(_Up), "can be compared with memcmp"); -# 108 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - return __builtin_memcmp(__first1, __first2, sizeof(_Tp) * __num); - } -# 152 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) - { -# 185 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - swap(*__a, *__b); - - } -# 201 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - _ForwardIterator2 - swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - std::iter_swap(__first1, __first2); - return __first2; - } -# 230 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b) - { - - - - if (__b < __a) - return __b; - return __a; - } -# 254 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b) - { - - - - if (__a < __b) - return __b; - return __a; - } -# 278 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - min(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__b, __a)) - return __b; - return __a; - } -# 300 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - constexpr - inline const _Tp& - max(const _Tp& __a, const _Tp& __b, _Compare __comp) - { - - if (__comp(__a, __b)) - return __b; - return __a; - } - - - - template - - inline _Iterator - __niter_base(_Iterator __it) - noexcept(std::is_nothrow_copy_constructible<_Iterator>::value) - { return __it; } - - template - _Ite - __niter_base(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, - std::random_access_iterator_tag>&); - - - - - template - - inline _From - __niter_wrap(_From __from, _To __res) - { return __from + (__res - std::__niter_base(__from)); } - - - template - - inline _Iterator - __niter_wrap(const _Iterator&, _Iterator __res) - { return __res; } - - - - - - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = *__first; - return __result; - } - }; - - - template - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - for (; __first != __last; ++__result, (void)++__first) - *__result = std::move(*__first); - return __result; - } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = *__first; - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = *__from; } - }; - - - template<> - struct __copy_move - { - template - - static _OI - __copy_m(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::difference_type _Distance; - for(_Distance __n = __last - __first; __n > 0; --__n) - { - *__result = std::move(*__first); - ++__first; - ++__result; - } - return __result; - } - - template - static void - __assign_one(_Tp* __to, _Up* __from) - { *__to = std::move(*__from); } - }; - - - template - struct __copy_move<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_m(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result, __first); - return __result + _Num; - } - }; - - - - template - struct _Deque_iterator; - - struct _Bit_iterator; - - - - - - - template - struct char_traits; - - template - class istreambuf_iterator; - - template - class ostreambuf_iterator; - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(_CharT*, _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type - __copy_move_a2(const _CharT*, const _CharT*, - ostreambuf_iterator<_CharT, char_traits<_CharT> >); - - template - typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, - _CharT*>::__type - __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_move_a2( - istreambuf_iterator<_CharT, char_traits<_CharT> >, - istreambuf_iterator<_CharT, char_traits<_CharT> >, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>); - - - template - - inline _OI - __copy_move_a2(_II __first, _II __last, _OI __result) - { - typedef typename iterator_traits<_II>::iterator_category _Category; - - - - - - return std::__copy_move<_IsMove, __memcpyable<_OI, _II>::__value, - _Category>::__copy_m(__first, __last, __result); - } - - template - _OI - __copy_move_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_a1(std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_a1(_II, _II, std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_a1(_II __first, _II __last, _OI __result) - { return std::__copy_move_a2<_IsMove>(__first, __last, __result); } - - template - - inline _OI - __copy_move_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_a1<_IsMove>(std::__niter_base(__first), - std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_a(const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); - - template - - _OutputIterator - __copy_n_a(_InputIterator __first, _Size __n, _OutputIterator __result, - bool) - { - if (__n > 0) - { - while (true) - { - *__result = *__first; - ++__result; - if (--__n > 0) - ++__first; - else - break; - } - } - return __result; - } - - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, _CharT*>::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, - _Size, _CharT*, bool); - - template - typename __gnu_cxx::__enable_if< - __is_char<_CharT>::__value, - std::_Deque_iterator<_CharT, _CharT&, _CharT*> >::__type - __copy_n_a(istreambuf_iterator<_CharT, char_traits<_CharT> >, _Size, - std::_Deque_iterator<_CharT, _CharT&, _CharT*>, - bool); -# 621 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - copy(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a<__is_move_iterator<_II>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 654 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - move(_II __first, _II __last, _OI __result) - { - - - - - ; - - return std::__copy_move_a(std::__miter_base(__first), - std::__miter_base(__last), __result); - } - - - - - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = *--__last; - return __result; - } - }; - - - template - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - while (__first != __last) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = *--__last; - return __result; - } - }; - - - template<> - struct __copy_move_backward - { - template - - static _BI2 - __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) - { - typename iterator_traits<_BI1>::difference_type - __n = __last - __first; - for (; __n > 0; --__n) - *--__result = std::move(*--__last); - return __result; - } - }; - - - template - struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> - { - template - - static _Up* - __copy_move_b(_Tp* __first, _Tp* __last, _Up* __result) - { - const ptrdiff_t _Num = __last - __first; - if (__builtin_expect(_Num > 1, true)) - __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); - else if (_Num == 1) - std::__copy_move<_IsMove, false, random_access_iterator_tag>:: - __assign_one(__result - 1, __first); - return __result - _Num; - } - }; - - template - - inline _BI2 - __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) - { - typedef typename iterator_traits<_BI1>::iterator_category _Category; - - - - - - return std::__copy_move_backward<_IsMove, - __memcpyable<_BI2, _BI1>::__value, - _Category>::__copy_move_b(__first, - __last, - __result); - } - - template - - inline _BI2 - __copy_move_backward_a1(_BI1 __first, _BI1 __last, _BI2 __result) - { return std::__copy_move_backward_a2<_IsMove>(__first, __last, __result); } - - template - _OI - __copy_move_backward_a1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _OI); - - template - std::_Deque_iterator<_OTp, _OTp&, _OTp*> - __copy_move_backward_a1( - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_ITp, _IRef, _IPtr>, - std::_Deque_iterator<_OTp, _OTp&, _OTp*>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, - std::_Deque_iterator<_Tp, _Tp&, _Tp*> >::__type - __copy_move_backward_a1(_II, _II, - std::_Deque_iterator<_Tp, _Tp&, _Tp*>); - - template - - inline _OI - __copy_move_backward_a(_II __first, _II __last, _OI __result) - { - return std::__niter_wrap(__result, - std::__copy_move_backward_a1<_IsMove> - (std::__niter_base(__first), std::__niter_base(__last), - std::__niter_base(__result))); - } - - template - _OI - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - _OI); - - template - __gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __copy_move_backward_a(_II, _II, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&); - - template - ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat> - __copy_move_backward_a( - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_IIte, _ISeq, _ICat>&, - const ::__gnu_debug::_Safe_iterator<_OIte, _OSeq, _OCat>&); -# 854 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a<__is_move_iterator<_BI1>::__value> - (std::__miter_base(__first), std::__miter_base(__last), __result); - } -# 889 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _BI2 - move_backward(_BI1 __first, _BI1 __last, _BI2 __result) - { - - - - - - ; - - return std::__copy_move_backward_a(std::__miter_base(__first), - std::__miter_base(__last), - __result); - } - - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - for (; __first != __last; ++__first) - *__first = __value; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type - __fill_a1(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __first != __last; ++__first) - *__first = __tmp; - } - - - template - - inline typename - __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type - __fill_a1(_Tp* __first, _Tp* __last, const _Tp& __c) - { - const _Tp __tmp = __c; -# 950 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - if (const size_t __len = __last - __first) - __builtin_memset(__first, static_cast(__tmp), __len); - } - - template - - inline void - __fill_a1(::__gnu_cxx::__normal_iterator<_Ite, _Cont> __first, - ::__gnu_cxx::__normal_iterator<_Ite, _Cont> __last, - const _Tp& __value) - { std::__fill_a1(__first.base(), __last.base(), __value); } - - template - void - __fill_a1(const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const std::_Deque_iterator<_Tp, _Tp&, _Tp*>&, - const _VTp&); - - - void - __fill_a1(std::_Bit_iterator, std::_Bit_iterator, - const bool&); - - template - - inline void - __fill_a(_FIte __first, _FIte __last, const _Tp& __value) - { std::__fill_a1(__first, __last, __value); } - - template - void - __fill_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>&, - const _Tp&); -# 997 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline void - fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) - { - - - - ; - - std::__fill_a(__first, __last, __value); - } - - - inline constexpr int - __size_to_integer(int __n) { return __n; } - inline constexpr unsigned - __size_to_integer(unsigned __n) { return __n; } - inline constexpr long - __size_to_integer(long __n) { return __n; } - inline constexpr unsigned long - __size_to_integer(unsigned long __n) { return __n; } - inline constexpr long long - __size_to_integer(long long __n) { return __n; } - inline constexpr unsigned long long - __size_to_integer(unsigned long long __n) { return __n; } -# 1049 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - inline constexpr long long - __size_to_integer(float __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(double __n) { return (long long)__n; } - inline constexpr long long - __size_to_integer(long double __n) { return (long long)__n; } - - - - - - template - - inline typename - __gnu_cxx::__enable_if::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - for (; __n > 0; --__n, (void) ++__first) - *__first = __value; - return __first; - } - - template - - inline typename - __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type - __fill_n_a1(_OutputIterator __first, _Size __n, const _Tp& __value) - { - const _Tp __tmp = __value; - for (; __n > 0; --__n, (void) ++__first) - *__first = __tmp; - return __first; - } - - template - ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat> - __fill_n_a(const ::__gnu_debug::_Safe_iterator<_Ite, _Seq, _Cat>& __first, - _Size __n, const _Tp& __value, - std::input_iterator_tag); - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::output_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::input_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - return __fill_n_a1(__first, __n, __value); - } - - template - - inline _OutputIterator - __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value, - std::random_access_iterator_tag) - { - - static_assert(is_integral<_Size>{}, "fill_n must pass integral size"); - - if (__n <= 0) - return __first; - - ; - - std::__fill_a(__first, __first + __n, __value); - return __first + __n; - } -# 1149 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _OI - fill_n(_OI __first, _Size __n, const _Tp& __value) - { - - - - return std::__fill_n_a(__first, std::__size_to_integer(__n), __value, - std::__iterator_category(__first)); - } - - template - struct __equal - { - template - - static bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - for (; __first1 != __last1; ++__first1, (void) ++__first2) - if (!(*__first1 == *__first2)) - return false; - return true; - } - }; - - template<> - struct __equal - { - template - - static bool - equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) - { - if (const size_t __len = (__last1 - __first1)) - return !std::__memcmp(__first1, __first2, __len); - return true; - } - }; - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(std::_Deque_iterator<_Tp, _Ref, _Ptr>, - std::_Deque_iterator<_Tp, _Ref, _Ptr>, - _II); - - template - bool - __equal_aux1(std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - typename __gnu_cxx::__enable_if< - __is_random_access_iter<_II>::__value, bool>::__type - __equal_aux1(_II, _II, - std::_Deque_iterator<_Tp, _Ref, _Ptr>); - - template - - inline bool - __equal_aux1(_II1 __first1, _II1 __last1, _II2 __first2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - const bool __simple = ((__is_integer<_ValueType1>::__value - || __is_pointer<_ValueType1>::__value) - && __memcmpable<_II1, _II2>::__value); - return std::__equal<__simple>::equal(__first1, __last1, __first2); - } - - template - - inline bool - __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) - { - return std::__equal_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2)); - } - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - _II2); - - template - bool - __equal_aux(_II1, _II1, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - bool - __equal_aux(const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_II2, _Seq2, _Cat2>&); - - template - struct __lc_rai - { - template - - static _II1 - __newlast1(_II1, _II1 __last1, _II2, _II2) - { return __last1; } - - template - - static bool - __cnd2(_II __first, _II __last) - { return __first != __last; } - }; - - template<> - struct __lc_rai - { - template - - static _RAI1 - __newlast1(_RAI1 __first1, _RAI1 __last1, - _RAI2 __first2, _RAI2 __last2) - { - const typename iterator_traits<_RAI1>::difference_type - __diff1 = __last1 - __first1; - const typename iterator_traits<_RAI2>::difference_type - __diff2 = __last2 - __first2; - return __diff2 < __diff1 ? __first1 + __diff2 : __last1; - } - - template - static bool - __cnd2(_RAI, _RAI) - { return true; } - }; - - template - - bool - __lexicographical_compare_impl(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, - _Compare __comp) - { - typedef typename iterator_traits<_II1>::iterator_category _Category1; - typedef typename iterator_traits<_II2>::iterator_category _Category2; - typedef std::__lc_rai<_Category1, _Category2> __rai_type; - - __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); - for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); - ++__first1, (void)++__first2) - { - if (__comp(__first1, __first2)) - return true; - if (__comp(__first2, __first1)) - return false; - } - return __first1 == __last1 && __first2 != __last2; - } - - template - struct __lexicographical_compare - { - template - - static bool - __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using __gnu_cxx::__ops::__iter_less_iter; - return std::__lexicographical_compare_impl(__first1, __last1, - __first2, __last2, - __iter_less_iter()); - } - - template - - static int - __3way(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - while (__first1 != __last1) - { - if (__first2 == __last2) - return +1; - if (*__first1 < *__first2) - return -1; - if (*__first2 < *__first1) - return +1; - ++__first1; - ++__first2; - } - return int(__first2 == __last2) - 1; - } - }; - - template<> - struct __lexicographical_compare - { - template - - static bool - __lc(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { return __3way(__first1, __last1, __first2, __last2) < 0; } - - template - - static ptrdiff_t - __3way(const _Tp* __first1, const _Tp* __last1, - const _Up* __first2, const _Up* __last2) - { - const size_t __len1 = __last1 - __first1; - const size_t __len2 = __last2 - __first2; - if (const size_t __len = std::min(__len1, __len2)) - if (int __result = std::__memcmp(__first1, __first2, __len)) - return __result; - return ptrdiff_t(__len1 - __len2); - } - }; - - template - - inline bool - __lexicographical_compare_aux1(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - typedef typename iterator_traits<_II1>::value_type _ValueType1; - typedef typename iterator_traits<_II2>::value_type _ValueType2; - const bool __simple = - (__is_memcmp_ordered_with<_ValueType1, _ValueType2>::__value - && __is_pointer<_II1>::__value - && __is_pointer<_II2>::__value - - - - - - - - ); - - return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, - __first2, __last2); - } - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - _Tp2*, _Tp2*); - - template - bool - __lexicographical_compare_aux1(_Tp1*, _Tp1*, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - bool - __lexicographical_compare_aux1( - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp1, _Ref1, _Ptr1>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>, - std::_Deque_iterator<_Tp2, _Ref2, _Ptr2>); - - template - - inline bool - __lexicographical_compare_aux(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { - return std::__lexicographical_compare_aux1(std::__niter_base(__first1), - std::__niter_base(__last1), - std::__niter_base(__first2), - std::__niter_base(__last2)); - } - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - _II2, _II2); - - template - bool - __lexicographical_compare_aux( - _II1, _II1, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - bool - __lexicographical_compare_aux( - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter1, _Seq1, _Cat1>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&, - const ::__gnu_debug::_Safe_iterator<_Iter2, _Seq2, _Cat2>&); - - template - - _ForwardIterator - __lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val, _Compare __comp) - { - typedef typename iterator_traits<_ForwardIterator>::difference_type - _DistanceType; - - _DistanceType __len = std::distance(__first, __last); - - while (__len > 0) - { - _DistanceType __half = __len >> 1; - _ForwardIterator __middle = __first; - std::advance(__middle, __half); - if (__comp(__middle, __val)) - { - __first = __middle; - ++__first; - __len = __len - __half - 1; - } - else - __len = __half; - } - return __first; - } -# 1495 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline _ForwardIterator - lower_bound(_ForwardIterator __first, _ForwardIterator __last, - const _Tp& __val) - { - - - - - ; - - return std::__lower_bound(__first, __last, __val, - __gnu_cxx::__ops::__iter_less_val()); - } - - - - template - inline constexpr _Tp - __lg(_Tp __n) - { - - return std::__bit_width(make_unsigned_t<_Tp>(__n)) - 1; -# 1531 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - } -# 1547 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2) - { - - - - - - - ; - - return std::__equal_aux(__first1, __last1, __first2); - } -# 1578 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return true; - } - - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!(*__first1 == *__first2)) - return false; - return __first1 == __last1 && __first2 == __last2; - } - - - template - - inline bool - __equal4(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2, - _BinaryPredicate __binary_pred) - { - using _RATag = random_access_iterator_tag; - using _Cat1 = typename iterator_traits<_II1>::iterator_category; - using _Cat2 = typename iterator_traits<_II2>::iterator_category; - using _RAIters = __and_, is_same<_Cat2, _RATag>>; - if (_RAIters()) - { - auto __d1 = std::distance(__first1, __last1); - auto __d2 = std::distance(__first2, __last2); - if (__d1 != __d2) - return false; - return std::equal(__first1, __last1, __first2, - __binary_pred); - } - - for (; __first1 != __last1 && __first2 != __last2; - ++__first1, (void)++__first2) - if (!bool(__binary_pred(*__first1, *__first2))) - return false; - return __first1 == __last1 && __first2 == __last2; - } -# 1668 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) - { - - - - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2); - } -# 1701 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - equal(_IIter1 __first1, _IIter1 __last1, - _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__equal4(__first1, __last1, __first2, __last2, - __binary_pred); - } -# 1733 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2) - { -# 1748 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - ; - ; - - return std::__lexicographical_compare_aux(__first1, __last1, - __first2, __last2); - } -# 1768 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - lexicographical_compare(_II1 __first1, _II1 __last1, - _II2 __first2, _II2 __last2, _Compare __comp) - { - - - - ; - ; - - return std::__lexicographical_compare_impl - (__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__comp)); - } -# 1880 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1908 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2) - { - - - - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 1942 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _BinaryPredicate __binary_pred) - { - - - - ; - - return std::__mismatch(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - template - - pair<_InputIterator1, _InputIterator2> - __mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - while (__first1 != __last1 && __first2 != __last2 - && __binary_pred(__first1, __first2)) - { - ++__first1; - ++__first2; - } - return pair<_InputIterator1, _InputIterator2>(__first1, __first2); - } -# 1991 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2) - { - - - - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } -# 2027 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline pair<_InputIterator1, _InputIterator2> - mismatch(_InputIterator1 __first1, _InputIterator1 __last1, - _InputIterator2 __first2, _InputIterator2 __last2, - _BinaryPredicate __binary_pred) - { - - - - ; - ; - - return std::__mismatch(__first1, __last1, __first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__binary_pred)); - } - - - - - - template - - inline _InputIterator - __find_if(_InputIterator __first, _InputIterator __last, - _Predicate __pred, input_iterator_tag) - { - while (__first != __last && !__pred(__first)) - ++__first; - return __first; - } - - - template - - _RandomAccessIterator - __find_if(_RandomAccessIterator __first, _RandomAccessIterator __last, - _Predicate __pred, random_access_iterator_tag) - { - typename iterator_traits<_RandomAccessIterator>::difference_type - __trip_count = (__last - __first) >> 2; - - for (; __trip_count > 0; --__trip_count) - { - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - - if (__pred(__first)) - return __first; - ++__first; - } - - switch (__last - __first) - { - case 3: - if (__pred(__first)) - return __first; - ++__first; - - case 2: - if (__pred(__first)) - return __first; - ++__first; - - case 1: - if (__pred(__first)) - return __first; - ++__first; - - case 0: - default: - return __last; - } - } - - template - - inline _Iterator - __find_if(_Iterator __first, _Iterator __last, _Predicate __pred) - { - return __find_if(__first, __last, __pred, - std::__iterator_category(__first)); - } - - template - - typename iterator_traits<_InputIterator>::difference_type - __count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred) - { - typename iterator_traits<_InputIterator>::difference_type __n = 0; - for (; __first != __last; ++__first) - if (__pred(__first)) - ++__n; - return __n; - } - - template - - _ForwardIterator - __remove_if(_ForwardIterator __first, _ForwardIterator __last, - _Predicate __pred) - { - __first = std::__find_if(__first, __last, __pred); - if (__first == __last) - return __first; - _ForwardIterator __result = __first; - ++__first; - for (; __first != __last; ++__first) - if (!__pred(__first)) - { - *__result = std::move(*__first); - ++__result; - } - return __result; - } - - - template - - bool - __is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2, _BinaryPredicate __pred) - { - - - for (; __first1 != __last1; ++__first1, (void)++__first2) - if (!__pred(__first1, __first2)) - break; - - if (__first1 == __last1) - return true; - - - - _ForwardIterator2 __last2 = __first2; - std::advance(__last2, std::distance(__first1, __last1)); - for (_ForwardIterator1 __scan = __first1; __scan != __last1; ++__scan) - { - if (__scan != std::__find_if(__first1, __scan, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan))) - continue; - - auto __matches - = std::__count_if(__first2, __last2, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)); - if (0 == __matches || - std::__count_if(__scan, __last1, - __gnu_cxx::__ops::__iter_comp_iter(__pred, __scan)) - != __matches) - return false; - } - return true; - } -# 2204 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/stl_algobase.h" 3 - template - - inline bool - is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1, - _ForwardIterator2 __first2) - { - - - - - - - ; - - return std::__is_permutation(__first1, __last1, __first2, - __gnu_cxx::__ops::__iter_equal_to_iter()); - } - - - -} -# 44 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/bits/specfun.h" 2 3 -# 1 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 1 3 -# 41 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 -# 158 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 -namespace std __attribute__ ((__visibility__ ("default"))) -{ - - - - - - - - enum float_round_style - { - round_indeterminate = -1, - round_toward_zero = 0, - round_to_nearest = 1, - round_toward_infinity = 2, - round_toward_neg_infinity = 3 - }; - - - - - - - - enum float_denorm_style - { - - denorm_indeterminate = -1, - - denorm_absent = 0, - - denorm_present = 1 - }; -# 202 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 - struct __numeric_limits_base - { - - - static constexpr bool is_specialized = false; - - - - - static constexpr int digits = 0; - - - static constexpr int digits10 = 0; - - - - - static constexpr int max_digits10 = 0; - - - - static constexpr bool is_signed = false; - - - static constexpr bool is_integer = false; - - - - - static constexpr bool is_exact = false; - - - - static constexpr int radix = 0; - - - - static constexpr int min_exponent = 0; - - - - static constexpr int min_exponent10 = 0; - - - - - static constexpr int max_exponent = 0; - - - - static constexpr int max_exponent10 = 0; - - - static constexpr bool has_infinity = false; - - - - static constexpr bool has_quiet_NaN = false; - - - - static constexpr bool has_signaling_NaN = false; - - - static constexpr float_denorm_style has_denorm = denorm_absent; - - - - static constexpr bool has_denorm_loss = false; - - - - static constexpr bool is_iec559 = false; - - - - - static constexpr bool is_bounded = false; -# 288 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 - static constexpr bool is_modulo = false; - - - static constexpr bool traps = false; - - - static constexpr bool tinyness_before = false; - - - - - static constexpr float_round_style round_style = - round_toward_zero; - }; -# 311 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 - template - struct numeric_limits : public __numeric_limits_base - { - - - static constexpr _Tp - min() noexcept { return _Tp(); } - - - static constexpr _Tp - max() noexcept { return _Tp(); } - - - - - static constexpr _Tp - lowest() noexcept { return _Tp(); } - - - - - static constexpr _Tp - epsilon() noexcept { return _Tp(); } - - - static constexpr _Tp - round_error() noexcept { return _Tp(); } - - - static constexpr _Tp - infinity() noexcept { return _Tp(); } - - - - static constexpr _Tp - quiet_NaN() noexcept { return _Tp(); } - - - - static constexpr _Tp - signaling_NaN() noexcept { return _Tp(); } - - - - - static constexpr _Tp - denorm_min() noexcept { return _Tp(); } - }; - - - - - template - struct numeric_limits - : public numeric_limits<_Tp> { }; - - template - struct numeric_limits - : public numeric_limits<_Tp> { }; - - template - struct numeric_limits - : public numeric_limits<_Tp> { }; -# 383 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr bool - min() noexcept { return false; } - - static constexpr bool - max() noexcept { return true; } - - - static constexpr bool - lowest() noexcept { return min(); } - - static constexpr int digits = 1; - static constexpr int digits10 = 0; - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = false; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr bool - epsilon() noexcept { return false; } - - static constexpr bool - round_error() noexcept { return false; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr bool - infinity() noexcept { return false; } - - static constexpr bool - quiet_NaN() noexcept { return false; } - - static constexpr bool - signaling_NaN() noexcept { return false; } - - static constexpr bool - denorm_min() noexcept { return false; } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = false; - - - - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr char - min() noexcept { return (((char)(-1) < 0) ? -(((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0) - 1 : (char)0); } - - static constexpr char - max() noexcept { return (((char)(-1) < 0) ? (((((char)1 << ((sizeof(char) * 8 - ((char)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char)0); } - - - static constexpr char - lowest() noexcept { return min(); } - - - static constexpr int digits = (sizeof(char) * 8 - ((char)(-1) < 0)); - static constexpr int digits10 = ((sizeof(char) * 8 - ((char)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = ((char)(-1) < 0); - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr char - epsilon() noexcept { return 0; } - - static constexpr char - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr - char infinity() noexcept { return char(); } - - static constexpr char - quiet_NaN() noexcept { return char(); } - - static constexpr char - signaling_NaN() noexcept { return char(); } - - static constexpr char - denorm_min() noexcept { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = !is_signed; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr signed char - min() noexcept { return -127 - 1; } - - static constexpr signed char - max() noexcept { return 127; } - - - static constexpr signed char - lowest() noexcept { return min(); } - - - static constexpr int digits = (sizeof(signed char) * 8 - ((signed char)(-1) < 0)); - static constexpr int digits10 - = ((sizeof(signed char) * 8 - ((signed char)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = true; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr signed char - epsilon() noexcept { return 0; } - - static constexpr signed char - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr signed char - infinity() noexcept { return static_cast(0); } - - static constexpr signed char - quiet_NaN() noexcept { return static_cast(0); } - - static constexpr signed char - signaling_NaN() noexcept - { return static_cast(0); } - - static constexpr signed char - denorm_min() noexcept - { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = false; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr unsigned char - min() noexcept { return 0; } - - static constexpr unsigned char - max() noexcept { return 127 * 2U + 1; } - - - static constexpr unsigned char - lowest() noexcept { return min(); } - - - static constexpr int digits - = (sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)); - static constexpr int digits10 - = ((sizeof(unsigned char) * 8 - ((unsigned char)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = false; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr unsigned char - epsilon() noexcept { return 0; } - - static constexpr unsigned char - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr unsigned char - infinity() noexcept - { return static_cast(0); } - - static constexpr unsigned char - quiet_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned char - signaling_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned char - denorm_min() noexcept - { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = true; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr wchar_t - min() noexcept { return (((wchar_t)(-1) < 0) ? -(((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0) - 1 : (wchar_t)0); } - - static constexpr wchar_t - max() noexcept { return (((wchar_t)(-1) < 0) ? (((((wchar_t)1 << ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(wchar_t)0); } - - - static constexpr wchar_t - lowest() noexcept { return min(); } - - - static constexpr int digits = (sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)); - static constexpr int digits10 - = ((sizeof(wchar_t) * 8 - ((wchar_t)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = ((wchar_t)(-1) < 0); - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr wchar_t - epsilon() noexcept { return 0; } - - static constexpr wchar_t - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr wchar_t - infinity() noexcept { return wchar_t(); } - - static constexpr wchar_t - quiet_NaN() noexcept { return wchar_t(); } - - static constexpr wchar_t - signaling_NaN() noexcept { return wchar_t(); } - - static constexpr wchar_t - denorm_min() noexcept { return wchar_t(); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = !is_signed; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; -# 796 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr char16_t - min() noexcept { return (((char16_t)(-1) < 0) ? -(((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0) - 1 : (char16_t)0); } - - static constexpr char16_t - max() noexcept { return (((char16_t)(-1) < 0) ? (((((char16_t)1 << ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char16_t)0); } - - static constexpr char16_t - lowest() noexcept { return min(); } - - static constexpr int digits = (sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)); - static constexpr int digits10 = ((sizeof(char16_t) * 8 - ((char16_t)(-1) < 0)) * 643L / 2136); - static constexpr int max_digits10 = 0; - static constexpr bool is_signed = ((char16_t)(-1) < 0); - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr char16_t - epsilon() noexcept { return 0; } - - static constexpr char16_t - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr char16_t - infinity() noexcept { return char16_t(); } - - static constexpr char16_t - quiet_NaN() noexcept { return char16_t(); } - - static constexpr char16_t - signaling_NaN() noexcept { return char16_t(); } - - static constexpr char16_t - denorm_min() noexcept { return char16_t(); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = !is_signed; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr char32_t - min() noexcept { return (((char32_t)(-1) < 0) ? -(((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0) - 1 : (char32_t)0); } - - static constexpr char32_t - max() noexcept { return (((char32_t)(-1) < 0) ? (((((char32_t)1 << ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(char32_t)0); } - - static constexpr char32_t - lowest() noexcept { return min(); } - - static constexpr int digits = (sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)); - static constexpr int digits10 = ((sizeof(char32_t) * 8 - ((char32_t)(-1) < 0)) * 643L / 2136); - static constexpr int max_digits10 = 0; - static constexpr bool is_signed = ((char32_t)(-1) < 0); - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr char32_t - epsilon() noexcept { return 0; } - - static constexpr char32_t - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr char32_t - infinity() noexcept { return char32_t(); } - - static constexpr char32_t - quiet_NaN() noexcept { return char32_t(); } - - static constexpr char32_t - signaling_NaN() noexcept { return char32_t(); } - - static constexpr char32_t - denorm_min() noexcept { return char32_t(); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = !is_signed; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style = round_toward_zero; - }; - - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr short - min() noexcept { return -32767 - 1; } - - static constexpr short - max() noexcept { return 32767; } - - - static constexpr short - lowest() noexcept { return min(); } - - - static constexpr int digits = (sizeof(short) * 8 - ((short)(-1) < 0)); - static constexpr int digits10 = ((sizeof(short) * 8 - ((short)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = true; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr short - epsilon() noexcept { return 0; } - - static constexpr short - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr short - infinity() noexcept { return short(); } - - static constexpr short - quiet_NaN() noexcept { return short(); } - - static constexpr short - signaling_NaN() noexcept { return short(); } - - static constexpr short - denorm_min() noexcept { return short(); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = false; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr unsigned short - min() noexcept { return 0; } - - static constexpr unsigned short - max() noexcept { return 32767 * 2U + 1; } - - - static constexpr unsigned short - lowest() noexcept { return min(); } - - - static constexpr int digits - = (sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)); - static constexpr int digits10 - = ((sizeof(unsigned short) * 8 - ((unsigned short)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = false; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr unsigned short - epsilon() noexcept { return 0; } - - static constexpr unsigned short - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr unsigned short - infinity() noexcept - { return static_cast(0); } - - static constexpr unsigned short - quiet_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned short - signaling_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned short - denorm_min() noexcept - { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = true; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr int - min() noexcept { return -2147483647 - 1; } - - static constexpr int - max() noexcept { return 2147483647; } - - - static constexpr int - lowest() noexcept { return min(); } - - - static constexpr int digits = (sizeof(int) * 8 - ((int)(-1) < 0)); - static constexpr int digits10 = ((sizeof(int) * 8 - ((int)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = true; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr int - epsilon() noexcept { return 0; } - - static constexpr int - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr int - infinity() noexcept { return static_cast(0); } - - static constexpr int - quiet_NaN() noexcept { return static_cast(0); } - - static constexpr int - signaling_NaN() noexcept { return static_cast(0); } - - static constexpr int - denorm_min() noexcept { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = false; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr unsigned int - min() noexcept { return 0; } - - static constexpr unsigned int - max() noexcept { return 2147483647 * 2U + 1; } - - - static constexpr unsigned int - lowest() noexcept { return min(); } - - - static constexpr int digits - = (sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)); - static constexpr int digits10 - = ((sizeof(unsigned int) * 8 - ((unsigned int)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = false; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr unsigned int - epsilon() noexcept { return 0; } - - static constexpr unsigned int - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr unsigned int - infinity() noexcept { return static_cast(0); } - - static constexpr unsigned int - quiet_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned int - signaling_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned int - denorm_min() noexcept - { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = true; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr long - min() noexcept { return -9223372036854775807L - 1; } - - static constexpr long - max() noexcept { return 9223372036854775807L; } - - - static constexpr long - lowest() noexcept { return min(); } - - - static constexpr int digits = (sizeof(long) * 8 - ((long)(-1) < 0)); - static constexpr int digits10 = ((sizeof(long) * 8 - ((long)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = true; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr long - epsilon() noexcept { return 0; } - - static constexpr long - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr long - infinity() noexcept { return static_cast(0); } - - static constexpr long - quiet_NaN() noexcept { return static_cast(0); } - - static constexpr long - signaling_NaN() noexcept { return static_cast(0); } - - static constexpr long - denorm_min() noexcept { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = false; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr unsigned long - min() noexcept { return 0; } - - static constexpr unsigned long - max() noexcept { return 9223372036854775807L * 2UL + 1; } - - - static constexpr unsigned long - lowest() noexcept { return min(); } - - - static constexpr int digits - = (sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)); - static constexpr int digits10 - = ((sizeof(unsigned long) * 8 - ((unsigned long)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = false; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr unsigned long - epsilon() noexcept { return 0; } - - static constexpr unsigned long - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr unsigned long - infinity() noexcept - { return static_cast(0); } - - static constexpr unsigned long - quiet_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned long - signaling_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned long - denorm_min() noexcept - { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = true; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr long long - min() noexcept { return -9223372036854775807LL - 1; } - - static constexpr long long - max() noexcept { return 9223372036854775807LL; } - - - static constexpr long long - lowest() noexcept { return min(); } - - - static constexpr int digits - = (sizeof(long long) * 8 - ((long long)(-1) < 0)); - static constexpr int digits10 - = ((sizeof(long long) * 8 - ((long long)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = true; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr long long - epsilon() noexcept { return 0; } - - static constexpr long long - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr long long - infinity() noexcept { return static_cast(0); } - - static constexpr long long - quiet_NaN() noexcept { return static_cast(0); } - - static constexpr long long - signaling_NaN() noexcept - { return static_cast(0); } - - static constexpr long long - denorm_min() noexcept { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = false; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; - - - template<> - struct numeric_limits - { - static constexpr bool is_specialized = true; - - static constexpr unsigned long long - min() noexcept { return 0; } - - static constexpr unsigned long long - max() noexcept { return 9223372036854775807LL * 2ULL + 1; } - - - static constexpr unsigned long long - lowest() noexcept { return min(); } - - - static constexpr int digits - = (sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)); - static constexpr int digits10 - = ((sizeof(unsigned long long) * 8 - ((unsigned long long)(-1) < 0)) * 643L / 2136); - - static constexpr int max_digits10 = 0; - - static constexpr bool is_signed = false; - static constexpr bool is_integer = true; - static constexpr bool is_exact = true; - static constexpr int radix = 2; - - static constexpr unsigned long long - epsilon() noexcept { return 0; } - - static constexpr unsigned long long - round_error() noexcept { return 0; } - - static constexpr int min_exponent = 0; - static constexpr int min_exponent10 = 0; - static constexpr int max_exponent = 0; - static constexpr int max_exponent10 = 0; - - static constexpr bool has_infinity = false; - static constexpr bool has_quiet_NaN = false; - static constexpr bool has_signaling_NaN = false; - static constexpr float_denorm_style has_denorm - = denorm_absent; - static constexpr bool has_denorm_loss = false; - - static constexpr unsigned long long - infinity() noexcept - { return static_cast(0); } - - static constexpr unsigned long long - quiet_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned long long - signaling_NaN() noexcept - { return static_cast(0); } - - static constexpr unsigned long long - denorm_min() noexcept - { return static_cast(0); } - - static constexpr bool is_iec559 = false; - static constexpr bool is_bounded = true; - static constexpr bool is_modulo = true; - - static constexpr bool traps = true; - static constexpr bool tinyness_before = false; - static constexpr float_round_style round_style - = round_toward_zero; - }; -# 1658 "/usr/bin/../lib64/gcc/x86_64-pc-linux-gnu/13.2.1/../../../../include/c++/13.2.1/limits" 3 - __extension__ template<> struct numeric_limits<__int128> { static constexpr bool is_specialized = true; static constexpr __int128 min() noexcept { return (((__int128)(-1) < 0) ? -(((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0) - 1 : (__int128)0); } static constexpr __int128 max() noexcept { return (((__int128)(-1) < 0) ? (((((__int128)1 << ((128 - ((__int128)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(__int128)0); } static constexpr int digits = 128 - 1; static constexpr int digits10 = (128 - 1) * 643L / 2136; static constexpr bool is_signed = true; static constexpr bool is_integer = true; static constexpr bool is_exact = t \ No newline at end of file From e6298b1dc3f060ebee5cf2becf4a97a002885a3b Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 8 Dec 2023 14:48:28 +0100 Subject: [PATCH 03/14] fixing syntax error in windows workflow --- .github/workflows/windows.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml index 5f94576..e82f86c 100644 --- a/.github/workflows/windows.yml +++ b/.github/workflows/windows.yml @@ -4,7 +4,7 @@ on: pull_request: push: paths-ignore: - - '.gitignore + - '.gitignore' - 'LICENSE' - 'README.md' From 74e5e35f5a26aa5cff91ca7d211ec3efc4e0f090 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 8 Dec 2023 15:57:45 +0100 Subject: [PATCH 04/14] debugging windows CI --- xmake.lua | 2 ++ 1 file changed, 2 insertions(+) diff --git a/xmake.lua b/xmake.lua index f75c1bc..1a20004 100644 --- a/xmake.lua +++ b/xmake.lua @@ -66,6 +66,8 @@ target("Test") set_kind("binary") set_targetdir("test") + add_linkdirs("./") + add_deps("mlx") add_files("test/main.c") From 218a97e4ec66069bc19dcf2805da230eb9587dbf Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 8 Dec 2023 16:37:42 +0100 Subject: [PATCH 05/14] debugging windows CI --- .github/workflows/windows.yml | 4 ++-- xmake.lua | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml index e82f86c..f5d2000 100644 --- a/.github/workflows/windows.yml +++ b/.github/workflows/windows.yml @@ -68,8 +68,8 @@ jobs: # Build the mlx - name: Build MacroLibX - run: xmake --yes + run: xmake --yes -v # Build the test - name: Build Test - run: xmake build --yes Test + run: xmake build --yes -v Test diff --git a/xmake.lua b/xmake.lua index 1a20004..7048f27 100644 --- a/xmake.lua +++ b/xmake.lua @@ -15,7 +15,7 @@ add_requires("libsdl", "vulkan-headers") add_rules("mode.debug", "mode.release") -set_languages("cxx17") +set_languages("cxx17", "c99") set_objectdir("objs/xmake/$(os)_$(arch)") set_targetdir("./") From 890e301b78fa27b4ca50ba0a9f254db3964e5ba8 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 8 Dec 2023 18:09:08 +0100 Subject: [PATCH 06/14] fixing cross compilation issue --- includes/mlx.h | 6 +++--- test/main.c | 17 +++++++++-------- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/includes/mlx.h b/includes/mlx.h index 09e7a15..3f083a0 100644 --- a/includes/mlx.h +++ b/includes/mlx.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 16:56:35 by maldavid #+# #+# */ -/* Updated: 2023/12/08 14:09:31 by kbz_8 ### ########.fr */ +/* Updated: 2023/12/08 18:07:40 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -72,7 +72,7 @@ MLX_API void* mlx_new_window(void* mlx, int w, int h, const char* title); * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -MLX_API int mlx_loop_hook(void* mlx, int (*f)(), void* param); +MLX_API int mlx_loop_hook(void* mlx, int (*f)(void*), void* param); /** * @brief Starts the internal main loop @@ -141,7 +141,7 @@ MLX_API int mlx_mouse_get_pos(void* mlx, int* x, int* y); * * @return (int) Always return 0, made this to copy the behaviour of the original MLX */ -MLX_API int mlx_on_event(void* mlx, void* win, mlx_event_type event, int (*f)(), void* param); +MLX_API int mlx_on_event(void* mlx, void* win, mlx_event_type event, int (*f)(int, void*), void* param); /** diff --git a/test/main.c b/test/main.c index e1e107b..12e13a2 100644 --- a/test/main.c +++ b/test/main.c @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 17:55:21 by maldavid #+# #+# */ -/* Updated: 2023/12/08 12:23:07 by kbz_8 ### ########.fr */ +/* Updated: 2023/12/08 18:08:13 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -22,12 +22,14 @@ typedef struct s_mlx void *img; } t_mlx; -int update(t_mlx *mlx) +int update(void *param) { static int i = 0; int j; int k; + t_mlx *mlx; + mlx = (t_mlx *)param; mlx_put_image_to_window(mlx->mlx, mlx->win, mlx->logo, 100, 100); mlx_put_image_to_window(mlx->mlx, mlx->win, mlx->img, 150, 60); mlx_string_put(mlx->mlx, mlx->win, 20, 50, 0xFFFFFFFF, "that's a text"); @@ -41,8 +43,7 @@ int update(t_mlx *mlx) k++; j++; } - i++; - if (i == 5000) + if (++i == 5000) { mlx_clear_window(mlx->mlx, mlx->win); mlx_set_font_scale(mlx->mlx, mlx->win, "font.ttf", 16.f); @@ -79,17 +80,17 @@ void *create_image(t_mlx *mlx) return (img); } -int key_hook(int key, t_mlx *param) +int key_hook(int key, void *param) { if (key == 41) - mlx_loop_end(param->mlx); + mlx_loop_end(((t_mlx *)param)->mlx); return (0); } -int window_hook(int event, t_mlx *param) +int window_hook(int event, void *param) { if (event == 0) - mlx_loop_end(param->mlx); + mlx_loop_end(((t_mlx *)param)->mlx); return (0); } From 19ce912afef81ce7394c581c09bcdd483fc4aa7a Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 8 Dec 2023 18:56:33 +0100 Subject: [PATCH 07/14] adding symbols to dll on windows --- src/core/application.h | 5 +++-- src/core/errors.h | 5 +++-- src/core/profile.h | 16 +++++++++++++++- src/platform/inputs.h | 6 ++++-- src/renderer/core/render_core.h | 5 +++-- 5 files changed, 28 insertions(+), 9 deletions(-) diff --git a/src/core/application.h b/src/core/application.h index 007e525..b113f06 100644 --- a/src/core/application.h +++ b/src/core/application.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 21:49:46 by maldavid #+# #+# */ -/* Updated: 2023/11/23 14:25:43 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 18:52:47 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -24,10 +24,11 @@ #include #include +#include namespace mlx::core { - class Application + class MLX_API Application { public: Application(); diff --git a/src/core/errors.h b/src/core/errors.h index b11db46..943b39f 100644 --- a/src/core/errors.h +++ b/src/core/errors.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 17:42:32 by maldavid #+# #+# */ -/* Updated: 2022/10/08 19:06:41 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 18:53:11 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,6 +14,7 @@ #define __MLX_ERRORS__ #include +#include enum class e_kind { @@ -25,7 +26,7 @@ enum class e_kind namespace mlx::core::error { - void report(e_kind kind, std::string msg, ...); + void MLX_API report(e_kind kind, std::string msg, ...); } #endif // __MLX_ERRORS__ diff --git a/src/core/profile.h b/src/core/profile.h index c5e45a2..2a6f307 100644 --- a/src/core/profile.h +++ b/src/core/profile.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/11/10 08:49:17 by maldavid #+# #+# */ -/* Updated: 2023/11/10 09:05:56 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 18:49:38 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -41,6 +41,20 @@ #warning "This compiler is not fully supported" #endif +#if defined(_WIN32) || defined(_WIN64) + #define MLX_EXPORT __declspec(dllexport) + #define MLX_IMPORT __declspec(dllexport) +#else + #define MLX_EXPORT + #define MLX_IMPORT +#endif + +#ifdef MLX_BUILD + #define MLX_API MLX_EXPORT +#else + #define MLX_API MLX_IMPORT +#endif + // Checking common assumptions #include #include diff --git a/src/platform/inputs.h b/src/platform/inputs.h index 030171c..b6d5acb 100644 --- a/src/platform/inputs.h +++ b/src/platform/inputs.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/05 16:27:35 by maldavid #+# #+# */ -/* Updated: 2023/12/08 12:14:39 by kbz_8 ### ########.fr */ +/* Updated: 2023/12/08 18:54:03 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -18,6 +18,8 @@ #include #include +#include + #include "window.h" namespace mlx @@ -30,7 +32,7 @@ namespace mlx void* param = nullptr; }; - class Input + class MLX_API Input { public: Input(); diff --git a/src/renderer/core/render_core.h b/src/renderer/core/render_core.h index 94b8c56..ab43baa 100644 --- a/src/renderer/core/render_core.h +++ b/src/renderer/core/render_core.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/08 19:16:32 by maldavid #+# #+# */ -/* Updated: 2023/11/20 07:20:43 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 18:53:36 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -24,6 +24,7 @@ #include #include +#include namespace mlx { @@ -42,7 +43,7 @@ namespace mlx constexpr const int MAX_FRAMES_IN_FLIGHT = 3; - class Render_Core : public Singleton + class MLX_API Render_Core : public Singleton { public: Render_Core() = default; From 5dcc2045d61a340dd297ca73757537527b5ed5ef Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Fri, 8 Dec 2023 19:13:25 +0100 Subject: [PATCH 08/14] adding symbols to dll on windows --- README.md | 1 + src/core/graphics.h | 5 +++-- src/core/memory.h | 5 +++-- src/platform/window.h | 5 +++-- src/renderer/buffers/vk_buffer.h | 5 +++-- src/renderer/buffers/vk_ibo.h | 5 +++-- src/renderer/buffers/vk_ubo.h | 5 +++-- src/renderer/buffers/vk_vbo.h | 7 ++++--- src/renderer/command/cmd_manager.h | 5 +++-- src/renderer/command/vk_cmd_buffer.h | 5 +++-- src/renderer/command/vk_cmd_pool.h | 5 +++-- src/renderer/core/memory.h | 5 +++-- src/renderer/core/vk_device.h | 5 +++-- src/renderer/core/vk_fence.h | 5 +++-- src/renderer/core/vk_instance.h | 5 +++-- src/renderer/core/vk_queues.h | 5 +++-- src/renderer/core/vk_semaphore.h | 5 +++-- src/renderer/core/vk_surface.h | 5 +++-- src/renderer/core/vk_validation_layers.h | 5 +++-- src/renderer/descriptors/vk_descriptor_pool.h | 5 +++-- src/renderer/descriptors/vk_descriptor_set.h | 5 +++-- src/renderer/descriptors/vk_descriptor_set_layout.h | 5 +++-- src/renderer/images/texture.h | 11 ++++++----- src/renderer/images/texture_atlas.h | 5 +++-- src/renderer/images/vk_image.h | 7 ++++--- src/renderer/pipeline/pipeline.h | 5 +++-- src/renderer/pixel_put.h | 5 +++-- src/renderer/renderer.h | 7 ++++--- src/renderer/renderpass/vk_framebuffer.h | 5 +++-- src/renderer/renderpass/vk_render_pass.h | 5 +++-- src/renderer/swapchain/vk_swapchain.h | 7 ++++--- src/renderer/text_library.h | 7 ++++--- src/renderer/text_pipeline.h | 9 +++++---- src/utils/dogica_ttf.h | 2 +- 34 files changed, 108 insertions(+), 75 deletions(-) diff --git a/README.md b/README.md index a7fae86..b46ab02 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,7 @@ + diff --git a/src/core/graphics.h b/src/core/graphics.h index 6c19aaa..f79fcbc 100644 --- a/src/core/graphics.h +++ b/src/core/graphics.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/02 14:49:49 by maldavid #+# #+# */ -/* Updated: 2023/11/25 09:59:39 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:04:59 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -26,10 +26,11 @@ #include #include #include +#include namespace mlx { - class GraphicsSupport : public non_copyable + class MLX_API GraphicsSupport : public non_copyable { public: GraphicsSupport(std::size_t w, std::size_t h, const std::string& title, int id); diff --git a/src/core/memory.h b/src/core/memory.h index 5e8c3eb..6fce3fc 100644 --- a/src/core/memory.h +++ b/src/core/memory.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/12/07 16:31:51 by kbz_8 #+# #+# */ -/* Updated: 2023/12/08 12:56:21 by kbz_8 ### ########.fr */ +/* Updated: 2023/12/08 19:05:15 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,11 +14,12 @@ #define __MLX_MEMORY__ #include +#include #include namespace mlx { - class MemManager : public Singleton + class MLX_API MemManager : public Singleton { friend class Singleton; diff --git a/src/platform/window.h b/src/platform/window.h index fa445ca..362a7ca 100644 --- a/src/platform/window.h +++ b/src/platform/window.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 21:53:12 by maldavid #+# #+# */ -/* Updated: 2023/11/25 11:33:32 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:05:31 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include #include +#include namespace mlx { - class MLX_Window + class MLX_API MLX_Window { public: MLX_Window(std::size_t w, std::size_t h, const std::string& title); diff --git a/src/renderer/buffers/vk_buffer.h b/src/renderer/buffers/vk_buffer.h index 3cad686..5c630f5 100644 --- a/src/renderer/buffers/vk_buffer.h +++ b/src/renderer/buffers/vk_buffer.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/06 23:18:52 by maldavid #+# #+# */ -/* Updated: 2023/11/16 13:56:19 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:05:50 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include #include +#include namespace mlx { - class Buffer + class MLX_API Buffer { public: enum class kind { dynamic, uniform, constant }; diff --git a/src/renderer/buffers/vk_ibo.h b/src/renderer/buffers/vk_ibo.h index 92f8c09..7109eba 100644 --- a/src/renderer/buffers/vk_ibo.h +++ b/src/renderer/buffers/vk_ibo.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/01/25 15:05:05 by maldavid #+# #+# */ -/* Updated: 2023/11/14 03:25:59 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:06:07 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,10 +16,11 @@ #include #include "vk_buffer.h" #include +#include namespace mlx { - class C_IBO : public Buffer + class MLX_API C_IBO : public Buffer { public: inline void create(uint32_t size, const uint16_t* data, const char* name) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, name, data); } diff --git a/src/renderer/buffers/vk_ubo.h b/src/renderer/buffers/vk_ubo.h index f1ca457..9a63aaa 100644 --- a/src/renderer/buffers/vk_ubo.h +++ b/src/renderer/buffers/vk_ubo.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/06 18:45:29 by maldavid #+# #+# */ -/* Updated: 2023/11/14 03:26:10 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:06:28 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,10 +16,11 @@ #include "vk_buffer.h" #include #include +#include namespace mlx { - class UBO + class MLX_API UBO { public: void create(class Renderer* renderer, uint32_t size, const char* name); diff --git a/src/renderer/buffers/vk_vbo.h b/src/renderer/buffers/vk_vbo.h index a8c942c..22f89b9 100644 --- a/src/renderer/buffers/vk_vbo.h +++ b/src/renderer/buffers/vk_vbo.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/06 18:27:38 by maldavid #+# #+# */ -/* Updated: 2023/11/14 04:53:36 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:06:45 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include "vk_buffer.h" #include +#include namespace mlx { - class VBO : public Buffer + class MLX_API VBO : public Buffer { public: inline void create(uint32_t size, const char* name) { Buffer::create(Buffer::kind::dynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name); } @@ -26,7 +27,7 @@ namespace mlx inline void bind(Renderer& renderer) noexcept { vkCmdBindVertexBuffers(renderer.getActiveCmdBuffer().get(), 0, 1, &_buffer, &_offset); } }; - class C_VBO : public Buffer + class MLX_API C_VBO : public Buffer { public: inline void create(uint32_t size, const void* data, const char* name) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); } diff --git a/src/renderer/command/cmd_manager.h b/src/renderer/command/cmd_manager.h index 4920d69..5298157 100644 --- a/src/renderer/command/cmd_manager.h +++ b/src/renderer/command/cmd_manager.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/02 17:48:52 by maldavid #+# #+# */ -/* Updated: 2023/04/02 17:50:48 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:07:00 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,13 +16,14 @@ #include #include +#include #include #include #include namespace mlx { - class CmdManager + class MLX_API CmdManager { public: CmdManager() = default; diff --git a/src/renderer/command/vk_cmd_buffer.h b/src/renderer/command/vk_cmd_buffer.h index ee6d8df..7a44d04 100644 --- a/src/renderer/command/vk_cmd_buffer.h +++ b/src/renderer/command/vk_cmd_buffer.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/06 18:25:42 by maldavid #+# #+# */ -/* Updated: 2023/04/21 13:20:49 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:07:11 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include #include +#include namespace mlx { - class CmdBuffer + class MLX_API CmdBuffer { public: void init(class CmdManager* manager); diff --git a/src/renderer/command/vk_cmd_pool.h b/src/renderer/command/vk_cmd_pool.h index 5445150..f64e42b 100644 --- a/src/renderer/command/vk_cmd_pool.h +++ b/src/renderer/command/vk_cmd_pool.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/06 18:24:12 by maldavid #+# #+# */ -/* Updated: 2022/12/18 01:08:31 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:07:22 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,10 +14,11 @@ #define __MLX_VK_CMD_POOL__ #include +#include namespace mlx { - class CmdPool + class MLX_API CmdPool { public: void init(); diff --git a/src/renderer/core/memory.h b/src/renderer/core/memory.h index bb3e2b7..336613c 100644 --- a/src/renderer/core/memory.h +++ b/src/renderer/core/memory.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/10/20 02:13:03 by maldavid #+# #+# */ -/* Updated: 2023/11/14 09:46:32 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:07:34 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include #include +#include namespace mlx { - class GPUallocator + class MLX_API GPUallocator { public: GPUallocator() = default; diff --git a/src/renderer/core/vk_device.h b/src/renderer/core/vk_device.h index 4078c96..e8b8885 100644 --- a/src/renderer/core/vk_device.h +++ b/src/renderer/core/vk_device.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/08 19:13:42 by maldavid #+# #+# */ -/* Updated: 2023/11/11 01:51:26 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:07:49 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include #include "vk_queues.h" +#include namespace mlx { - class Device + class MLX_API Device { public: void init(); diff --git a/src/renderer/core/vk_fence.h b/src/renderer/core/vk_fence.h index a72cd02..abe6c60 100644 --- a/src/renderer/core/vk_fence.h +++ b/src/renderer/core/vk_fence.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/02 17:52:09 by maldavid #+# #+# */ -/* Updated: 2023/04/02 17:52:59 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:08:01 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,11 +14,12 @@ #define __MLX_VK_FENCE__ #include +#include #include namespace mlx { - class Fence + class MLX_API Fence { public: Fence() = default; diff --git a/src/renderer/core/vk_instance.h b/src/renderer/core/vk_instance.h index dc6e216..a8948cc 100644 --- a/src/renderer/core/vk_instance.h +++ b/src/renderer/core/vk_instance.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/08 19:03:04 by maldavid #+# #+# */ -/* Updated: 2022/12/18 17:42:08 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:08:14 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include #include +#include namespace mlx { - class Instance + class MLX_API Instance { public: void init(); diff --git a/src/renderer/core/vk_queues.h b/src/renderer/core/vk_queues.h index 5ed1b56..ef3d270 100644 --- a/src/renderer/core/vk_queues.h +++ b/src/renderer/core/vk_queues.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/08 19:01:49 by maldavid #+# #+# */ -/* Updated: 2022/12/18 22:44:37 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:08:25 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,10 +16,11 @@ #include #include #include +#include namespace mlx { - class Queues + class MLX_API Queues { public: struct QueueFamilyIndices diff --git a/src/renderer/core/vk_semaphore.h b/src/renderer/core/vk_semaphore.h index 8c1371e..f16e074 100644 --- a/src/renderer/core/vk_semaphore.h +++ b/src/renderer/core/vk_semaphore.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/08 18:59:38 by maldavid #+# #+# */ -/* Updated: 2023/04/02 17:55:10 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:08:36 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include #include +#include namespace mlx { - class Semaphore + class MLX_API Semaphore { public: void init(); diff --git a/src/renderer/core/vk_surface.h b/src/renderer/core/vk_surface.h index a39de21..9d6933a 100644 --- a/src/renderer/core/vk_surface.h +++ b/src/renderer/core/vk_surface.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/08 18:57:55 by maldavid #+# #+# */ -/* Updated: 2022/12/18 19:34:04 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:08:49 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include #include +#include namespace mlx { - class Surface + class MLX_API Surface { public: void create(class Renderer& renderer); diff --git a/src/renderer/core/vk_validation_layers.h b/src/renderer/core/vk_validation_layers.h index 8fb08c0..9b6ca8f 100644 --- a/src/renderer/core/vk_validation_layers.h +++ b/src/renderer/core/vk_validation_layers.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/12/19 14:04:25 by maldavid #+# #+# */ -/* Updated: 2022/12/19 14:05:19 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:09:02 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,10 +14,11 @@ #define __VK_VALIDATION_LAYERS__ #include +#include namespace mlx { - class ValidationLayers + class MLX_API ValidationLayers { public: void init(); diff --git a/src/renderer/descriptors/vk_descriptor_pool.h b/src/renderer/descriptors/vk_descriptor_pool.h index 115cecb..9779593 100644 --- a/src/renderer/descriptors/vk_descriptor_pool.h +++ b/src/renderer/descriptors/vk_descriptor_pool.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/01/23 18:32:43 by maldavid #+# #+# */ -/* Updated: 2023/01/23 18:44:40 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:09:20 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,10 +15,11 @@ #include #include +#include namespace mlx { - class DescriptorPool + class MLX_API DescriptorPool { public: void init(std::size_t n, VkDescriptorPoolSize* size); diff --git a/src/renderer/descriptors/vk_descriptor_set.h b/src/renderer/descriptors/vk_descriptor_set.h index 0d39d72..0959235 100644 --- a/src/renderer/descriptors/vk_descriptor_set.h +++ b/src/renderer/descriptors/vk_descriptor_set.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/01/23 18:39:36 by maldavid #+# #+# */ -/* Updated: 2023/12/07 19:47:07 by kbz_8 ### ########.fr */ +/* Updated: 2023/12/08 19:09:31 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,11 +15,12 @@ #include #include +#include #include namespace mlx { - class DescriptorSet + class MLX_API DescriptorSet { public: void init(class Renderer* renderer, class DescriptorPool* pool, class DescriptorSetLayout* layout); diff --git a/src/renderer/descriptors/vk_descriptor_set_layout.h b/src/renderer/descriptors/vk_descriptor_set_layout.h index 4066a1f..11ae849 100644 --- a/src/renderer/descriptors/vk_descriptor_set_layout.h +++ b/src/renderer/descriptors/vk_descriptor_set_layout.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/01/23 18:36:22 by maldavid #+# #+# */ -/* Updated: 2023/03/31 17:54:03 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:09:44 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -17,10 +17,11 @@ #include #include #include +#include namespace mlx { - class DescriptorSetLayout + class MLX_API DescriptorSetLayout { public: void init(std::vector> binds, VkShaderStageFlagBits stage); diff --git a/src/renderer/images/texture.h b/src/renderer/images/texture.h index c324dd6..f35c7e9 100644 --- a/src/renderer/images/texture.h +++ b/src/renderer/images/texture.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/03/08 02:24:58 by maldavid #+# #+# */ -/* Updated: 2023/11/25 10:01:35 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:10:09 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -21,10 +21,11 @@ #include #include #include +#include namespace mlx { - class Texture : public Image + class MLX_API Texture : public Image { public: Texture() = default; @@ -61,9 +62,9 @@ namespace mlx bool _has_been_updated = false; }; - Texture stbTextureLoad(std::filesystem::path file, int* w, int* h); + MLX_API Texture stbTextureLoad(std::filesystem::path file, int* w, int* h); - struct TextureRenderData + struct MLX_API TextureRenderData { Texture* texture; std::size_t hash = 0; @@ -78,7 +79,7 @@ namespace mlx namespace std { template <> - struct hash + struct MLX_API hash { size_t operator()(const mlx::TextureRenderData& td) const noexcept { diff --git a/src/renderer/images/texture_atlas.h b/src/renderer/images/texture_atlas.h index 74c7c90..0d39c6b 100644 --- a/src/renderer/images/texture_atlas.h +++ b/src/renderer/images/texture_atlas.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/07 16:36:33 by maldavid #+# #+# */ -/* Updated: 2023/12/07 18:50:53 by kbz_8 ### ########.fr */ +/* Updated: 2023/12/08 19:10:22 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,10 +16,11 @@ #include #include #include +#include namespace mlx { - class TextureAtlas : public Image + class MLX_API TextureAtlas : public Image { public: TextureAtlas() = default; diff --git a/src/renderer/images/vk_image.h b/src/renderer/images/vk_image.h index 8fba630..3d04dbf 100644 --- a/src/renderer/images/vk_image.h +++ b/src/renderer/images/vk_image.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/01/25 11:54:21 by maldavid #+# #+# */ -/* Updated: 2023/11/18 17:10:05 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:10:38 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -18,12 +18,13 @@ #include #include #include +#include namespace mlx { - uint32_t formatSize(VkFormat format); + MLX_API uint32_t formatSize(VkFormat format); - class Image + class MLX_API Image { friend class SwapChain; diff --git a/src/renderer/pipeline/pipeline.h b/src/renderer/pipeline/pipeline.h index b8e6cf8..8533d69 100644 --- a/src/renderer/pipeline/pipeline.h +++ b/src/renderer/pipeline/pipeline.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/12/18 21:23:52 by maldavid #+# #+# */ -/* Updated: 2022/12/19 00:27:29 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:10:51 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,11 +14,12 @@ #define __PIPELINE__ #include +#include #include namespace mlx { - class GraphicPipeline + class MLX_API GraphicPipeline { public: void init(class Renderer& renderer); diff --git a/src/renderer/pixel_put.h b/src/renderer/pixel_put.h index 0742fa5..66688fe 100644 --- a/src/renderer/pixel_put.h +++ b/src/renderer/pixel_put.h @@ -6,19 +6,20 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/03/31 13:18:50 by maldavid #+# #+# */ -/* Updated: 2023/08/02 05:27:27 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:11:43 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ #ifndef __MLX_PIXEL_PUT__ #define __MLX_PIXEL_PUT__ +#include #include #include namespace mlx { - class PixelPutPipeline + class MLX_API PixelPutPipeline { public: PixelPutPipeline() = default; diff --git a/src/renderer/renderer.h b/src/renderer/renderer.h index aaf3646..699e97c 100644 --- a/src/renderer/renderer.h +++ b/src/renderer/renderer.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/12/18 17:14:45 by maldavid #+# #+# */ -/* Updated: 2023/11/20 07:26:12 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:12:06 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -31,12 +31,13 @@ #include #include +#include #include namespace mlx { - struct Vertex + struct MLX_API Vertex { glm::vec2 pos; glm::vec4 color; @@ -77,7 +78,7 @@ namespace mlx } }; - class Renderer + class MLX_API Renderer { public: Renderer() = default; diff --git a/src/renderer/renderpass/vk_framebuffer.h b/src/renderer/renderpass/vk_framebuffer.h index ac1d3c5..aa30e9a 100644 --- a/src/renderer/renderpass/vk_framebuffer.h +++ b/src/renderer/renderpass/vk_framebuffer.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/06 18:19:44 by maldavid #+# #+# */ -/* Updated: 2023/11/18 16:44:16 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:11:04 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,10 +14,11 @@ #define __MLX_VK_FRAMEBUFFER__ #include +#include namespace mlx { - class FrameBuffer + class MLX_API FrameBuffer { public: void init(class RenderPass& renderpass, class Image& image); diff --git a/src/renderer/renderpass/vk_render_pass.h b/src/renderer/renderpass/vk_render_pass.h index 2caca3a..4ca66a9 100644 --- a/src/renderer/renderpass/vk_render_pass.h +++ b/src/renderer/renderpass/vk_render_pass.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/06 18:22:00 by maldavid #+# #+# */ -/* Updated: 2023/11/20 07:24:48 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:11:14 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,10 +14,11 @@ #define __MLX_VK_RENDER_PASS__ #include +#include namespace mlx { - class RenderPass + class MLX_API RenderPass { public: void init(VkFormat attachement_format); diff --git a/src/renderer/swapchain/vk_swapchain.h b/src/renderer/swapchain/vk_swapchain.h index 4369a55..15aab51 100644 --- a/src/renderer/swapchain/vk_swapchain.h +++ b/src/renderer/swapchain/vk_swapchain.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/06 18:23:27 by maldavid #+# #+# */ -/* Updated: 2023/11/20 07:25:30 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:11:30 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,18 +15,19 @@ #include #include +#include #include namespace mlx { - class SwapChain + class MLX_API SwapChain { friend class GraphicPipeline; friend class RenderPass; friend class Renderer; public: - struct SwapChainSupportDetails + struct MLX_API SwapChainSupportDetails { VkSurfaceCapabilitiesKHR capabilities; std::vector formats; diff --git a/src/renderer/text_library.h b/src/renderer/text_library.h index fd1079f..b7459c2 100644 --- a/src/renderer/text_library.h +++ b/src/renderer/text_library.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/10 11:52:30 by maldavid #+# #+# */ -/* Updated: 2023/04/12 11:38:57 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:12:24 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -20,13 +20,14 @@ #include #include #include +#include namespace mlx { using TextID = uint32_t; constexpr TextID nulltext = 0; - class TextData + class MLX_API TextData { public: TextData() = default; @@ -45,7 +46,7 @@ namespace mlx std::string _text; }; - class TextLibrary + class MLX_API TextLibrary { public: TextLibrary() = default; diff --git a/src/renderer/text_pipeline.h b/src/renderer/text_pipeline.h index 5f4c32e..7f0f78b 100644 --- a/src/renderer/text_pipeline.h +++ b/src/renderer/text_pipeline.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/06 16:24:11 by maldavid #+# #+# */ -/* Updated: 2023/11/24 19:08:04 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:12:40 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -20,10 +20,11 @@ #include #include #include +#include namespace mlx { - struct TextDrawData + struct MLX_API TextDrawData { TextID id; int x; @@ -40,7 +41,7 @@ namespace mlx namespace std { template <> - struct hash + struct MLX_API hash { std::size_t operator()(const mlx::TextDrawData& d) const noexcept { @@ -51,7 +52,7 @@ namespace std namespace mlx { - class TextPutPipeline + class MLX_API TextPutPipeline { public: TextPutPipeline() = default; diff --git a/src/utils/dogica_ttf.h b/src/utils/dogica_ttf.h index 01c13fe..a2907d3 100644 --- a/src/utils/dogica_ttf.h +++ b/src/utils/dogica_ttf.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/11 16:20:25 by maldavid #+# #+# */ -/* Updated: 2023/11/25 10:47:10 by maldavid ### ########.fr */ +/* Updated: 2023/12/08 19:13:00 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ From d16af1c4a85b5f2b3c83aa73e0439eaa6e7c4b91 Mon Sep 17 00:00:00 2001 From: kbz_8 Date: Fri, 8 Dec 2023 23:33:26 +0100 Subject: [PATCH 09/14] fixing windows dll issues --- .gitignore | 6 ++ Makefile | 1 + includes/mlx.h | 10 +- src/core/application.h | 2 +- src/core/bridge.cpp | 97 +++++++++--------- src/core/errors.h | 2 +- src/core/graphics.h | 2 +- src/core/memory.h | 2 +- src/core/profile.h | 19 ++-- src/platform/inputs.h | 2 +- src/platform/window.h | 2 +- src/renderer/buffers/vk_buffer.h | 2 +- src/renderer/buffers/vk_ibo.h | 2 +- src/renderer/buffers/vk_ubo.h | 2 +- src/renderer/buffers/vk_vbo.h | 4 +- src/renderer/command/cmd_manager.h | 2 +- src/renderer/command/vk_cmd_buffer.h | 2 +- src/renderer/command/vk_cmd_pool.h | 2 +- src/renderer/core/memory.h | 2 +- src/renderer/core/render_core.cpp | 6 +- src/renderer/core/render_core.h | 2 +- src/renderer/core/vk_device.h | 2 +- src/renderer/core/vk_fence.h | 2 +- src/renderer/core/vk_instance.h | 2 +- src/renderer/core/vk_queues.h | 2 +- src/renderer/core/vk_semaphore.h | 2 +- src/renderer/core/vk_surface.h | 2 +- src/renderer/core/vk_validation_layers.h | 2 +- src/renderer/descriptors/vk_descriptor_pool.h | 2 +- src/renderer/descriptors/vk_descriptor_set.h | 2 +- .../descriptors/vk_descriptor_set_layout.h | 2 +- src/renderer/images/texture.h | 8 +- src/renderer/images/texture_atlas.h | 2 +- src/renderer/images/vk_image.h | 4 +- src/renderer/pipeline/pipeline.h | 2 +- src/renderer/pixel_put.h | 2 +- src/renderer/renderer.h | 4 +- src/renderer/renderpass/vk_framebuffer.h | 2 +- src/renderer/renderpass/vk_render_pass.h | 2 +- src/renderer/swapchain/vk_swapchain.h | 4 +- src/renderer/text_library.h | 4 +- src/renderer/text_pipeline.h | 6 +- test/Test.exe | Bin 0 -> 632320 bytes 43 files changed, 121 insertions(+), 110 deletions(-) create mode 100644 test/Test.exe diff --git a/.gitignore b/.gitignore index 6bc8987..7bf0577 100644 --- a/.gitignore +++ b/.gitignore @@ -5,10 +5,16 @@ *.so *.out *.dll +*.lib +*.exp *.json *.tmp +*.ilk +*.pdb +.vs/ .xmake/ .cache/ +objs/ build/ test/.gdb_history test/Test diff --git a/Makefile b/Makefile index f5c7986..a6d8efe 100644 --- a/Makefile +++ b/Makefile @@ -13,6 +13,7 @@ NAME = libmlx.so SRCS = $(wildcard $(addsuffix /*.cpp, ./src/core)) +SRCS += $(wildcard $(addsuffix /*.cpp, ./src/core/**)) SRCS += $(wildcard $(addsuffix /*.cpp, ./src/platform)) SRCS += $(wildcard $(addsuffix /*.cpp, ./src/renderer)) SRCS += $(wildcard $(addsuffix /*.cpp, ./src/renderer/**)) diff --git a/includes/mlx.h b/includes/mlx.h index 3f083a0..57dc761 100644 --- a/includes/mlx.h +++ b/includes/mlx.h @@ -15,13 +15,9 @@ #ifndef __MACRO_LIB_X_H__ #define __MACRO_LIB_X_H__ -#ifdef __cplusplus -extern "C" { -#endif - #if defined(_WIN32) || defined(_WIN64) #define MLX_EXPORT __declspec(dllexport) - #define MLX_IMPORT __declspec(dllexport) + #define MLX_IMPORT __declspec(dllimport) #else #define MLX_EXPORT #define MLX_IMPORT @@ -33,6 +29,10 @@ extern "C" { #define MLX_API MLX_IMPORT #endif +#ifdef __cplusplus +extern "C" { +#endif + typedef enum { MLX_KEYDOWN = 0, diff --git a/src/core/application.h b/src/core/application.h index b113f06..a877086 100644 --- a/src/core/application.h +++ b/src/core/application.h @@ -28,7 +28,7 @@ namespace mlx::core { - class MLX_API Application + class Application { public: Application(); diff --git a/src/core/bridge.cpp b/src/core/bridge.cpp index 9240ddc..854d9f5 100644 --- a/src/core/bridge.cpp +++ b/src/core/bridge.cpp @@ -15,6 +15,7 @@ #include "application.h" #include #include +#include extern "C" { @@ -31,29 +32,29 @@ extern "C" if(app == nullptr) mlx::core::error::report(e_kind::fatal_error, "Tout a pété"); init = true; - return app; + return static_cast(app); } - void* mlx_new_window(mlx::core::Application* mlx, int w, int h, const char* title) + void* mlx_new_window(void* mlx, int w, int h, const char* title) { - return mlx->newGraphicsSuport(w, h, title); + return static_cast(mlx)->newGraphicsSuport(w, h, title); } - int mlx_loop_hook(mlx::core::Application* mlx, int (*f)(void*), void* param) + int mlx_loop_hook(void* mlx, int (*f)(void*), void* param) { - mlx->loopHook(f, param); + static_cast(mlx)->loopHook(f, param); return 0; } - int mlx_loop(mlx::core::Application* mlx) + int mlx_loop(void* mlx) { - mlx->run(); + static_cast(mlx)->run(); return 0; } - int mlx_loop_end(mlx::core::Application* mlx) + int mlx_loop_end(void* mlx) { - mlx->loopEnd(); + static_cast(mlx)->loopEnd(); return 0; } @@ -67,57 +68,57 @@ extern "C" return SDL_ShowCursor(SDL_DISABLE); } - int mlx_mouse_move(mlx::core::Application* mlx, void* win, int x, int y) + int mlx_mouse_move(void* mlx, void* win, int x, int y) { - mlx->mouseMove(win, x, y); + static_cast(mlx)->mouseMove(win, x, y); return 0; } - int mlx_mouse_get_pos(mlx::core::Application* mlx, int* x, int* y) + int mlx_mouse_get_pos(void* mlx, int* x, int* y) { - mlx->getMousePos(x, y); + static_cast(mlx)->getMousePos(x, y); return 0; } - int mlx_on_event(mlx::core::Application* mlx, void* win, int event, int (*funct_ptr)(int, void*), void* param) + int mlx_on_event(void* mlx, void* win, mlx_event_type event, int (*funct_ptr)(int, void*), void* param) { - mlx->onEvent(win, event, funct_ptr, param); + static_cast(mlx)->onEvent(win, static_cast(event), funct_ptr, param); return 0; } - void* mlx_new_image(mlx::core::Application* mlx, int width, int height) + void* mlx_new_image(void* mlx, int width, int height) { - return mlx->newTexture(width, height); + return static_cast(mlx)->newTexture(width, height); } - int mlx_get_image_pixel(mlx::core::Application* mlx, void* img, int x, int y) + int mlx_get_image_pixel(void* mlx, void* img, int x, int y) { - return mlx->getTexturePixel(img, x, y); + return static_cast(mlx)->getTexturePixel(img, x, y); } - void mlx_set_image_pixel(mlx::core::Application* mlx, void* img, int x, int y, int color) + void mlx_set_image_pixel(void* mlx, void* img, int x, int y, int color) { unsigned char color_bits[4]; color_bits[0] = (color & 0x00FF0000) >> 16; color_bits[1] = (color & 0x0000FF00) >> 8; color_bits[2] = (color & 0x000000FF); color_bits[3] = (color & 0xFF000000) >> 24; - mlx->setTexturePixel(img, x, y, *reinterpret_cast(color_bits)); + static_cast(mlx)->setTexturePixel(img, x, y, *reinterpret_cast(color_bits)); } - int mlx_put_image_to_window(mlx::core::Application* mlx, void* win, void* img, int x, int y) + int mlx_put_image_to_window(void* mlx, void* win, void* img, int x, int y) { - mlx->texturePut(win, img, x, y); + static_cast(mlx)->texturePut(win, img, x, y); return 0; } - int mlx_destroy_image(mlx::core::Application* mlx, void* img) + int mlx_destroy_image(void* mlx, void* img) { - mlx->destroyTexture(img); + static_cast(mlx)->destroyTexture(img); return 0; } - void* mlx_png_file_to_image(mlx::core::Application* mlx, char* filename, int* width, int* height) + void* mlx_png_file_to_image(void* mlx, char* filename, int* width, int* height) { std::filesystem::path file(filename); if(file.extension() != ".png") @@ -125,10 +126,10 @@ extern "C" mlx::core::error::report(e_kind::error, "PNG loader : not a png file '%s'", filename); return nullptr; } - return mlx->newStbTexture(filename, width, height); + return static_cast(mlx)->newStbTexture(filename, width, height); } - void* mlx_jpg_file_to_image(mlx::core::Application* mlx, char* filename, int* width, int* height) + void* mlx_jpg_file_to_image(void* mlx, char* filename, int* width, int* height) { std::filesystem::path file(filename); if(file.extension() != ".jpg" && file.extension() != ".jpeg") @@ -136,10 +137,10 @@ extern "C" mlx::core::error::report(e_kind::error, "JPG loader : not a jpg file '%s'", filename); return nullptr; } - return mlx->newStbTexture(filename, width, height); + return static_cast(mlx)->newStbTexture(filename, width, height); } - void* mlx_bmp_file_to_image(mlx::core::Application* mlx, char* filename, int* width, int* height) + void* mlx_bmp_file_to_image(void* mlx, char* filename, int* width, int* height) { std::filesystem::path file(filename); if(file.extension() != ".bmp" && file.extension() != ".dib") @@ -147,32 +148,32 @@ extern "C" mlx::core::error::report(e_kind::error, "BMP loader : not a bmp file '%s'", filename); return nullptr; } - return mlx->newStbTexture(filename, width, height); + return static_cast(mlx)->newStbTexture(filename, width, height); } - int mlx_pixel_put(mlx::core::Application* mlx, void* win, int x, int y, int color) + int mlx_pixel_put(void* mlx, void* win, int x, int y, int color) { unsigned char color_bits[4]; color_bits[0] = (color & 0x00FF0000) >> 16; color_bits[1] = (color & 0x0000FF00) >> 8; color_bits[2] = color & 0x000000FF; color_bits[3] = 0xFF; - mlx->pixelPut(win, x, y, *reinterpret_cast(color_bits)); + static_cast(mlx)->pixelPut(win, x, y, *reinterpret_cast(color_bits)); return 0; } - int mlx_string_put(mlx::core::Application* mlx, void* win, int x, int y, int color, char* str) + int mlx_string_put(void* mlx, void* win, int x, int y, int color, char* str) { unsigned char color_bits[4]; color_bits[0] = (color & 0x00FF0000) >> 16; color_bits[1] = (color & 0x0000FF00) >> 8; color_bits[2] = color & 0x000000FF; color_bits[3] = 0xFF; - mlx->stringPut(win, x, y, *reinterpret_cast(color_bits), str); + static_cast(mlx)->stringPut(win, x, y, *reinterpret_cast(color_bits), str); return 0; } - void mlx_set_font(mlx::core::Application* mlx, void* win, char* filepath) + void mlx_set_font(void* mlx, void* win, char* filepath) { std::filesystem::path file(filepath); if(file.extension() != ".ttf" && file.extension() != ".tte") @@ -180,10 +181,10 @@ extern "C" mlx::core::error::report(e_kind::error, "TTF loader : not a truetype font file '%s'", filepath); return; } - mlx->loadFont(win, file, 16.f); + static_cast(mlx)->loadFont(win, file, 16.f); } - void mlx_set_font_scale(mlx::core::Application* mlx, void* win, char* filepath, float scale) + void mlx_set_font_scale(void* mlx, void* win, char* filepath, float scale) { std::filesystem::path file(filepath); if(file.extension() != ".ttf" && file.extension() != ".tte") @@ -191,31 +192,31 @@ extern "C" mlx::core::error::report(e_kind::error, "TTF loader : not a truetype font file '%s'", filepath); return; } - mlx->loadFont(win, file, scale); + static_cast(mlx)->loadFont(win, file, scale); } - int mlx_clear_window(mlx::core::Application* mlx, void* win) + int mlx_clear_window(void* mlx, void* win) { - mlx->clearGraphicsSupport(win); + static_cast(mlx)->clearGraphicsSupport(win); return 0; } - int mlx_destroy_window(mlx::core::Application* mlx, void* win) + int mlx_destroy_window(void* mlx, void* win) { - mlx->destroyGraphicsSupport(win); + static_cast(mlx)->destroyGraphicsSupport(win); return 0; } - int mlx_destroy_display(mlx::core::Application* mlx) + int mlx_destroy_display(void* mlx) { - delete mlx; + delete static_cast(mlx); mlx::Render_Core::get().destroy(); return 0; } - int mlx_get_screens_size(mlx::core::Application* mlx, int* w, int* h) + int mlx_get_screens_size(void* mlx, int* w, int* h) { - mlx->getScreenSize(w, h); + static_cast(mlx)->getScreenSize(w, h); return 0; } -} +} \ No newline at end of file diff --git a/src/core/errors.h b/src/core/errors.h index 943b39f..d8f5ba1 100644 --- a/src/core/errors.h +++ b/src/core/errors.h @@ -26,7 +26,7 @@ enum class e_kind namespace mlx::core::error { - void MLX_API report(e_kind kind, std::string msg, ...); + void report(e_kind kind, std::string msg, ...); } #endif // __MLX_ERRORS__ diff --git a/src/core/graphics.h b/src/core/graphics.h index f79fcbc..2680162 100644 --- a/src/core/graphics.h +++ b/src/core/graphics.h @@ -30,7 +30,7 @@ namespace mlx { - class MLX_API GraphicsSupport : public non_copyable + class GraphicsSupport : public non_copyable { public: GraphicsSupport(std::size_t w, std::size_t h, const std::string& title, int id); diff --git a/src/core/memory.h b/src/core/memory.h index 6fce3fc..b4649e1 100644 --- a/src/core/memory.h +++ b/src/core/memory.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API MemManager : public Singleton + class MemManager : public Singleton { friend class Singleton; diff --git a/src/core/profile.h b/src/core/profile.h index 2a6f307..45d6ed7 100644 --- a/src/core/profile.h +++ b/src/core/profile.h @@ -41,19 +41,18 @@ #warning "This compiler is not fully supported" #endif -#if defined(_WIN32) || defined(_WIN64) - #define MLX_EXPORT __declspec(dllexport) - #define MLX_IMPORT __declspec(dllexport) +#if defined(_WIN32) || defined(__CYGWIN__) + #define MLX_PLAT_WINDOWS +#elif defined(__linux__) + #define MLX_PLAT_LINUX +#elif defined(__APPLE__) && defined(__MACH__) + #define MLX_PLAT_MACOS +#elif defined(unix) || defined(__unix__) || defined(__unix) + #define MLX_PLAT_UNIX #else - #define MLX_EXPORT - #define MLX_IMPORT + #error "Unknown environment!" #endif -#ifdef MLX_BUILD - #define MLX_API MLX_EXPORT -#else - #define MLX_API MLX_IMPORT -#endif // Checking common assumptions #include diff --git a/src/platform/inputs.h b/src/platform/inputs.h index b6d5acb..332d8e0 100644 --- a/src/platform/inputs.h +++ b/src/platform/inputs.h @@ -32,7 +32,7 @@ namespace mlx void* param = nullptr; }; - class MLX_API Input + class Input { public: Input(); diff --git a/src/platform/window.h b/src/platform/window.h index 362a7ca..8923564 100644 --- a/src/platform/window.h +++ b/src/platform/window.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API MLX_Window + class MLX_Window { public: MLX_Window(std::size_t w, std::size_t h, const std::string& title); diff --git a/src/renderer/buffers/vk_buffer.h b/src/renderer/buffers/vk_buffer.h index 5c630f5..783c486 100644 --- a/src/renderer/buffers/vk_buffer.h +++ b/src/renderer/buffers/vk_buffer.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API Buffer + class Buffer { public: enum class kind { dynamic, uniform, constant }; diff --git a/src/renderer/buffers/vk_ibo.h b/src/renderer/buffers/vk_ibo.h index 7109eba..ecaa21f 100644 --- a/src/renderer/buffers/vk_ibo.h +++ b/src/renderer/buffers/vk_ibo.h @@ -20,7 +20,7 @@ namespace mlx { - class MLX_API C_IBO : public Buffer + class C_IBO : public Buffer { public: inline void create(uint32_t size, const uint16_t* data, const char* name) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_INDEX_BUFFER_BIT, name, data); } diff --git a/src/renderer/buffers/vk_ubo.h b/src/renderer/buffers/vk_ubo.h index 9a63aaa..057e24e 100644 --- a/src/renderer/buffers/vk_ubo.h +++ b/src/renderer/buffers/vk_ubo.h @@ -20,7 +20,7 @@ namespace mlx { - class MLX_API UBO + class UBO { public: void create(class Renderer* renderer, uint32_t size, const char* name); diff --git a/src/renderer/buffers/vk_vbo.h b/src/renderer/buffers/vk_vbo.h index 22f89b9..7b52c76 100644 --- a/src/renderer/buffers/vk_vbo.h +++ b/src/renderer/buffers/vk_vbo.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API VBO : public Buffer + class VBO : public Buffer { public: inline void create(uint32_t size, const char* name) { Buffer::create(Buffer::kind::dynamic, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name); } @@ -27,7 +27,7 @@ namespace mlx inline void bind(Renderer& renderer) noexcept { vkCmdBindVertexBuffers(renderer.getActiveCmdBuffer().get(), 0, 1, &_buffer, &_offset); } }; - class MLX_API C_VBO : public Buffer + class C_VBO : public Buffer { public: inline void create(uint32_t size, const void* data, const char* name) { Buffer::create(Buffer::kind::constant, size, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, name, data); } diff --git a/src/renderer/command/cmd_manager.h b/src/renderer/command/cmd_manager.h index 5298157..e6a13be 100644 --- a/src/renderer/command/cmd_manager.h +++ b/src/renderer/command/cmd_manager.h @@ -23,7 +23,7 @@ namespace mlx { - class MLX_API CmdManager + class CmdManager { public: CmdManager() = default; diff --git a/src/renderer/command/vk_cmd_buffer.h b/src/renderer/command/vk_cmd_buffer.h index 7a44d04..0b4e742 100644 --- a/src/renderer/command/vk_cmd_buffer.h +++ b/src/renderer/command/vk_cmd_buffer.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API CmdBuffer + class CmdBuffer { public: void init(class CmdManager* manager); diff --git a/src/renderer/command/vk_cmd_pool.h b/src/renderer/command/vk_cmd_pool.h index f64e42b..cacc651 100644 --- a/src/renderer/command/vk_cmd_pool.h +++ b/src/renderer/command/vk_cmd_pool.h @@ -18,7 +18,7 @@ namespace mlx { - class MLX_API CmdPool + class CmdPool { public: void init(); diff --git a/src/renderer/core/memory.h b/src/renderer/core/memory.h index 336613c..671a90b 100644 --- a/src/renderer/core/memory.h +++ b/src/renderer/core/memory.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API GPUallocator + class GPUallocator { public: GPUallocator() = default; diff --git a/src/renderer/core/render_core.cpp b/src/renderer/core/render_core.cpp index 13e46cc..aa8ec23 100644 --- a/src/renderer/core/render_core.cpp +++ b/src/renderer/core/render_core.cpp @@ -24,7 +24,11 @@ #include #ifdef DEBUG - #warning "MLX is being compiled in debug mode, this activates Vulkan's validation layers and debug messages which may impact rendering performances" + #ifndef MLX_COMPILER_MSVC + #warning "MLX is being compiled in debug mode, this activates Vulkan's validation layers and debug messages which may impact rendering performances" + #else + #pragma NOTE("MLX is being compiled in debug mode, this activates Vulkan's validation layers and debug messages which may impact rendering performances") + #endif #endif namespace mlx diff --git a/src/renderer/core/render_core.h b/src/renderer/core/render_core.h index ab43baa..8319cca 100644 --- a/src/renderer/core/render_core.h +++ b/src/renderer/core/render_core.h @@ -43,7 +43,7 @@ namespace mlx constexpr const int MAX_FRAMES_IN_FLIGHT = 3; - class MLX_API Render_Core : public Singleton + class Render_Core : public Singleton { public: Render_Core() = default; diff --git a/src/renderer/core/vk_device.h b/src/renderer/core/vk_device.h index e8b8885..c2353af 100644 --- a/src/renderer/core/vk_device.h +++ b/src/renderer/core/vk_device.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API Device + class Device { public: void init(); diff --git a/src/renderer/core/vk_fence.h b/src/renderer/core/vk_fence.h index abe6c60..342ce78 100644 --- a/src/renderer/core/vk_fence.h +++ b/src/renderer/core/vk_fence.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API Fence + class Fence { public: Fence() = default; diff --git a/src/renderer/core/vk_instance.h b/src/renderer/core/vk_instance.h index a8948cc..d5de82d 100644 --- a/src/renderer/core/vk_instance.h +++ b/src/renderer/core/vk_instance.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API Instance + class Instance { public: void init(); diff --git a/src/renderer/core/vk_queues.h b/src/renderer/core/vk_queues.h index ef3d270..1716999 100644 --- a/src/renderer/core/vk_queues.h +++ b/src/renderer/core/vk_queues.h @@ -20,7 +20,7 @@ namespace mlx { - class MLX_API Queues + class Queues { public: struct QueueFamilyIndices diff --git a/src/renderer/core/vk_semaphore.h b/src/renderer/core/vk_semaphore.h index f16e074..9ae964f 100644 --- a/src/renderer/core/vk_semaphore.h +++ b/src/renderer/core/vk_semaphore.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API Semaphore + class Semaphore { public: void init(); diff --git a/src/renderer/core/vk_surface.h b/src/renderer/core/vk_surface.h index 9d6933a..24dd3ec 100644 --- a/src/renderer/core/vk_surface.h +++ b/src/renderer/core/vk_surface.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API Surface + class Surface { public: void create(class Renderer& renderer); diff --git a/src/renderer/core/vk_validation_layers.h b/src/renderer/core/vk_validation_layers.h index 9b6ca8f..a956674 100644 --- a/src/renderer/core/vk_validation_layers.h +++ b/src/renderer/core/vk_validation_layers.h @@ -18,7 +18,7 @@ namespace mlx { - class MLX_API ValidationLayers + class ValidationLayers { public: void init(); diff --git a/src/renderer/descriptors/vk_descriptor_pool.h b/src/renderer/descriptors/vk_descriptor_pool.h index 9779593..7a97760 100644 --- a/src/renderer/descriptors/vk_descriptor_pool.h +++ b/src/renderer/descriptors/vk_descriptor_pool.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API DescriptorPool + class DescriptorPool { public: void init(std::size_t n, VkDescriptorPoolSize* size); diff --git a/src/renderer/descriptors/vk_descriptor_set.h b/src/renderer/descriptors/vk_descriptor_set.h index 0959235..d9c51d3 100644 --- a/src/renderer/descriptors/vk_descriptor_set.h +++ b/src/renderer/descriptors/vk_descriptor_set.h @@ -20,7 +20,7 @@ namespace mlx { - class MLX_API DescriptorSet + class DescriptorSet { public: void init(class Renderer* renderer, class DescriptorPool* pool, class DescriptorSetLayout* layout); diff --git a/src/renderer/descriptors/vk_descriptor_set_layout.h b/src/renderer/descriptors/vk_descriptor_set_layout.h index 11ae849..23d2ef2 100644 --- a/src/renderer/descriptors/vk_descriptor_set_layout.h +++ b/src/renderer/descriptors/vk_descriptor_set_layout.h @@ -21,7 +21,7 @@ namespace mlx { - class MLX_API DescriptorSetLayout + class DescriptorSetLayout { public: void init(std::vector> binds, VkShaderStageFlagBits stage); diff --git a/src/renderer/images/texture.h b/src/renderer/images/texture.h index f35c7e9..e15b5fc 100644 --- a/src/renderer/images/texture.h +++ b/src/renderer/images/texture.h @@ -25,7 +25,7 @@ namespace mlx { - class MLX_API Texture : public Image + class Texture : public Image { public: Texture() = default; @@ -62,9 +62,9 @@ namespace mlx bool _has_been_updated = false; }; - MLX_API Texture stbTextureLoad(std::filesystem::path file, int* w, int* h); + Texture stbTextureLoad(std::filesystem::path file, int* w, int* h); - struct MLX_API TextureRenderData + struct TextureRenderData { Texture* texture; std::size_t hash = 0; @@ -79,7 +79,7 @@ namespace mlx namespace std { template <> - struct MLX_API hash + struct hash { size_t operator()(const mlx::TextureRenderData& td) const noexcept { diff --git a/src/renderer/images/texture_atlas.h b/src/renderer/images/texture_atlas.h index 0d39c6b..59a0edc 100644 --- a/src/renderer/images/texture_atlas.h +++ b/src/renderer/images/texture_atlas.h @@ -20,7 +20,7 @@ namespace mlx { - class MLX_API TextureAtlas : public Image + class TextureAtlas : public Image { public: TextureAtlas() = default; diff --git a/src/renderer/images/vk_image.h b/src/renderer/images/vk_image.h index 3d04dbf..7e0e865 100644 --- a/src/renderer/images/vk_image.h +++ b/src/renderer/images/vk_image.h @@ -22,9 +22,9 @@ namespace mlx { - MLX_API uint32_t formatSize(VkFormat format); + uint32_t formatSize(VkFormat format); - class MLX_API Image + class Image { friend class SwapChain; diff --git a/src/renderer/pipeline/pipeline.h b/src/renderer/pipeline/pipeline.h index 8533d69..6dbfe7a 100644 --- a/src/renderer/pipeline/pipeline.h +++ b/src/renderer/pipeline/pipeline.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API GraphicPipeline + class GraphicPipeline { public: void init(class Renderer& renderer); diff --git a/src/renderer/pixel_put.h b/src/renderer/pixel_put.h index 66688fe..503bf62 100644 --- a/src/renderer/pixel_put.h +++ b/src/renderer/pixel_put.h @@ -19,7 +19,7 @@ namespace mlx { - class MLX_API PixelPutPipeline + class PixelPutPipeline { public: PixelPutPipeline() = default; diff --git a/src/renderer/renderer.h b/src/renderer/renderer.h index 699e97c..42b8db9 100644 --- a/src/renderer/renderer.h +++ b/src/renderer/renderer.h @@ -37,7 +37,7 @@ namespace mlx { - struct MLX_API Vertex + struct Vertex { glm::vec2 pos; glm::vec4 color; @@ -78,7 +78,7 @@ namespace mlx } }; - class MLX_API Renderer + class Renderer { public: Renderer() = default; diff --git a/src/renderer/renderpass/vk_framebuffer.h b/src/renderer/renderpass/vk_framebuffer.h index aa30e9a..d8c92ed 100644 --- a/src/renderer/renderpass/vk_framebuffer.h +++ b/src/renderer/renderpass/vk_framebuffer.h @@ -18,7 +18,7 @@ namespace mlx { - class MLX_API FrameBuffer + class FrameBuffer { public: void init(class RenderPass& renderpass, class Image& image); diff --git a/src/renderer/renderpass/vk_render_pass.h b/src/renderer/renderpass/vk_render_pass.h index 4ca66a9..c955800 100644 --- a/src/renderer/renderpass/vk_render_pass.h +++ b/src/renderer/renderpass/vk_render_pass.h @@ -18,7 +18,7 @@ namespace mlx { - class MLX_API RenderPass + class RenderPass { public: void init(VkFormat attachement_format); diff --git a/src/renderer/swapchain/vk_swapchain.h b/src/renderer/swapchain/vk_swapchain.h index 15aab51..b6b8374 100644 --- a/src/renderer/swapchain/vk_swapchain.h +++ b/src/renderer/swapchain/vk_swapchain.h @@ -20,14 +20,14 @@ namespace mlx { - class MLX_API SwapChain + class SwapChain { friend class GraphicPipeline; friend class RenderPass; friend class Renderer; public: - struct MLX_API SwapChainSupportDetails + struct SwapChainSupportDetails { VkSurfaceCapabilitiesKHR capabilities; std::vector formats; diff --git a/src/renderer/text_library.h b/src/renderer/text_library.h index b7459c2..aa124c3 100644 --- a/src/renderer/text_library.h +++ b/src/renderer/text_library.h @@ -27,7 +27,7 @@ namespace mlx using TextID = uint32_t; constexpr TextID nulltext = 0; - class MLX_API TextData + class TextData { public: TextData() = default; @@ -46,7 +46,7 @@ namespace mlx std::string _text; }; - class MLX_API TextLibrary + class TextLibrary { public: TextLibrary() = default; diff --git a/src/renderer/text_pipeline.h b/src/renderer/text_pipeline.h index 7f0f78b..e1e29ec 100644 --- a/src/renderer/text_pipeline.h +++ b/src/renderer/text_pipeline.h @@ -24,7 +24,7 @@ namespace mlx { - struct MLX_API TextDrawData + struct TextDrawData { TextID id; int x; @@ -41,7 +41,7 @@ namespace mlx namespace std { template <> - struct MLX_API hash + struct hash { std::size_t operator()(const mlx::TextDrawData& d) const noexcept { @@ -52,7 +52,7 @@ namespace std namespace mlx { - class MLX_API TextPutPipeline + class TextPutPipeline { public: TextPutPipeline() = default; diff --git a/test/Test.exe b/test/Test.exe new file mode 100644 index 0000000000000000000000000000000000000000..9fea3c520bc088503ac2d8ddb67b3fd027b9abef GIT binary patch literal 632320 zcmeFa34Dy#_Xj*#MkXO9mJn10K`NFIG{lmLOg$kX_MH&>P9~Px5|fbem{uvJRaLE8 zs$3eI^@z{r&pi-p~7aqo1C+_nvdlJ@?#m&pr1% z&rD+aE!MbcG#YpO?{H`|yYb0?;R5~};G)r#t+BVPW~b+gn!8=1Pt@!&YIK7Cq$v|e zP8l-ZKYqxB2@_5JLx=lMNu1z6dV+ssm+t=KCk`9l$lKd1z{z@TLaUJL<$J{C|KB{W z_mHcoH;?N&WTNIqL z!-klKXf$v1h8D6x+XtWf@mb_wILxP!N~TF}0z|N%tccXpR-;-7aSZvVx&fs2(dIdz;pQ)KTkKfTcn|fL8JMA z_*~$rnsg4BAvhx6S83 zx1%DeKfHx*d#?J%gVnMj0K-xM?rsO-=PBTl zL2T?4h_-{H)f&dW%h301EZS=8!SrS@sxiHQ2<``vN8*ds04~o2gV;`B@LmEC`_oW; z_zS8#%Yjuw2b5|pLR;5&feoz(F6}O(TV1k0(Gpl633N4<0Zf?)I`6S4NymW*`jg|% zN81UqdORCF9IH@mK~@iwPzsO%E=>cdn*cClCg=hVqTAKUAZfc8)t(X1ecVsLcDf71 zl3#(i{5ufizQPzY-v*+^5(w0@FUM#L@M?Pu)VVF%KHCVAAIGCq<4u%0_6DoIQ&IIF z11^s^t(#j=YIqNAlbWF0(v>I;<)m#MV3j)q*bhpf?erW}ANm4J=i<#xLaBT$ls@YP z?5c9$oNx^c2DzYb%*&9}v>esiyHMR!7R1eU0BdMw@iN*zZ-;JuDaNF5(9PY5YW*mb zJO@Lnlu-azX_!-j(8HU`ZZ;gC+5{l#H%8kLin}2f-OP0{c*m+>^>8Q z+krJ!0XCSUb(({=s<%#ncw`vB&ofY6_Z>>VvhSM~kc_y6>3h}zA}|I6 zIX(h*&d;cBlmW+Z_+OrsKYje=;2?h9zGqP~LnkZEBj40LplH>LTgA}g0 z91VUqj{uDC0mK73fUC>FWde=nYa^<;rNKFK659Tnj%vnBVC8oWZG+zcgSC}WjUqoE zoFTS}1JE|%3Wx_T#c0wMv{gtz+nkN)`wEU>n>(j)Y!IrijRW1EbRNH60ciIL5Jzi( zUraYtH~fJyK3a>m&pEe0*P|_$PG-kj;5_9O4Ee+t#Ea-bUVRB*%t2t^It-=<)}cqW zt>`oz3sA8#=sHaU$poCrwv5kF{k0hwglSP76M^c5Lny8I7~mLpN~0|( zwQK`K&QX-~Apmbo1;5L0qpfucB*J4uRF{kauzm^l(__HpQ6%VU?E$FL0ad^0;8J@U zfETyv_v{fk2c>gOFvhM;ptH?JRiOjz;sef2FQMf9G3Y+#8l8KGbU&i4=NgoHP?HlY zpvMxr*V)0K+sR#f=@zQ4w4BRtlV2r({si+|V~lmbp%gv~GPi$<9w(clRHZ3;Bn<}G zLT@&dCa}!{2^LYOcRBs0bSNh}qx#Yoj2qS#tUBHX;@an^Zm0o-jKIX!i*q~3(b77A zLGN`y^y6tYy90=0Zvou3pl!@m@cTXtTq@E@FZDx@rVD|%9Skro0@cc0fpuL3>`w~; zlIZ5v_XFaGQ{Z=kr}O4bsBWRR9Xc9dcqZC%4uh^kFZAu!6cW5eez|n(XJXOzc{kAY zq|4aMz3Oojh(WbcZI}zu{I~-?_z{SO^MHt==WnKR=@TI8{)D#AXbg`v0FE8tQtAs3w|NU=Yz;y+p)=@C4g=PE3HqM@3~hSu z>7UzyT z?P>gfQDN(N7=9(8G!ap=?LM8`I<8yNcz|!v)s0w9?Tn#X{H;7wtGa0$kTYCfByC=Xx8>-hD0qjo4xaW-Mdx)HG??78c zx~d?$`YByd^`#E7&SRj%3_m)udX3tR{sweo`=MJUE`^1ot>IML&0rh(JtX2mCzRYM z+LhhF{@QF$Zcq$2PPrZG-BBksz@;(B@wUs!O0h?ffIEs!u>>MRCIHM{`cHG-}Q?R4jElQYuRON@Jk?1a)+%2GcOlyo=JVaUl7OtOk??gKCulp2h>Z41^+rIf`VrN7w1`IE16*SO^q@JwJKex)r~xuR zoQr|BdSTp;D8X7r@Rv`cZQO9s)q4!^Gq=HvY9R5ihw6F_N@FOCCr_)^WcoW}Ti1i2 z8%Qs@>OEj<(^1SjiMA$mJV}dz82LWhBIZG=a+A?*RW!iT_koQV1FR(#65Qh<{L2;q z*DNso-hsBQ^i4B60*vv%;Cn`b!9Du+{+&Q~p95712DbGkaLL1k(AKXbIFI)R@aqNQ zu@twe72q~K|8bhY(rQ3NaK3diP};c_r5hA?f-A5`=A$k5DwwwCXc1KGpS=N^akUoY zq4bmy-l;@X?*&1sa}<06jsI)9-03O6cKH>u+#HCiVJAvi8vx`s==-@I#0?qOrSa}! z_5|_v*5J}y_?%KG9pfeLW*X=Y5)7c=ml((`Uj^c*`5faQK>xu&ETO&hiwS%X2_?A{8W| zG|Z8uQECwb#O>zjd#fCV+(H|_!db2(s8}C#y&2ssVbnbQ6%fy2(6M7V5I4U;^#r{@ z+IwgV`V)Pd{tASx9EJ?2jUMN?^FIFurQ1m;wQhwT-_m@3;Q7&<%VP=w;+@SPxqk`O zgF{g*!&qv^a&UQ_?7b(Ts!0a6gAYn`reUCUwa{bp40?LG!LMVt+&B>L zAgfxZKw|R-zcO_29$#Wc{qAzyG8p&ca~#7P-6k{!@gCkp4x9qrJ3L`O`3!w0^A^46 zH4x9`)_9pq_67ICPU^s(h;A*i0VWRsb^t>cM^lho-;C1Ny)atqKfr3RA4-*OfUavQ zuv;11CXlXQ2I#6E1vZP9DL3x7F&v}%B@l;mj5k-Jt=|KXT&s_9R}4hou?awQ=BC^8 zJ4y#=)Rij$TZsp~k&ZFvW6-%VYAL$_eG_@d*-fxM2PAb@1MwMeMXfskRO5`Aav2RX zK=Ku@GFzD1_B{l-KPc>8>+zSz0&^8cYsUT6tq3$CHTkIsP=CN?2-Uh2-SD1K?2`7sD^Wb9Ui0a6;8p1RKIOl1CWHc z0eh03wQm+mqj;*l(*#`F4noOB;;)#{$ZQ2xpL>8y%>(G0au%iaF6hxQ6(t)DGu8&; zgo+^krU8iWWPvW2fl}{{09B*W=E6%z_&pE@aq*Tv1tNJLs=M>h*Krx8>+=9EOaa}G z9DGM3RNHbrw3#6Gn}BW|XhUOOM`;-kAn7Y`mbK_HbUlch|H(FPdp&oaR~sOj4+e40 zTR?1i0&s{2?q{!pc*Ps2dQh=*%&6Ak0t7STb!GuTzq_bzWX9pgju>NRS&#^RwkTA` z@h;xJBHI3<+w99Y`)q%dI@JPpK5qoWYog>wJ21C`UVdYk+@u)<8pkWV-V8)rW)dD& zM_VL4!x?IFLL{nPy8s(KA6Pp#VttxG6?(m94*~Q{4Xx(=_Z5mZ>H+A?3^hh@GCg&W zdGlhF4%frD9k~FBl>s!I$^@PL%Gi2g%B0Fx|jZ-KE#S`RQn2 zmvND^$-W(}>63dv96XJ-TRes4K0sU3TvTHopgJl9)h|Cswety7znBdMFHJ!;^F4s; zLs5O}DcJv5lXO+U>gG|DER0{I7>u!n=l&*M`iE>o4|krSTbQNm$Jio+8Ii0tsOFh~ z?MKz6u0yvtF3%P^#wEN;C*K2!KWEvSvDE6LD1Gq+h#wh^G-kJ5jAY*Dr28;P=$-}9 zdeH=~jR#36o#3}L$1AOXs7`ks&Af#?6C~vu1Ch!p%qmAZBe1o2Q_mpDPDW6VcrWX< z9Hl>#G43!1vz2!MJBOeS55tdnM6c%=I)XM--5;g2Z~%{%K)5bNY5YJCKfVa;qffx< ze^9^`AH}ljpSDe-9Bv$u$I=@bqmBe&Rnhsh5YR- z=(Kc}N+7EJ9{~*Ft;oom<}6ONb}iUY3tkmGvr&y^EI)Gqq;jR}(^B_YJuuMH?f_R9 zI2`-}bbb|3`rstmK4H)?keS6`8q!QAL*CV*G`TZMXSqg=Uk31E*f@k%H{c!irPI1e zN6|bQK*K0#WL02ae-GWNbMZDeLEBQ^buV^9X$beA`%{pdc^|Bra-cTff%Ahu(3aqa z(yk9cl5qpr&BFjZ{6R9bDiB9_3I!iQ_3)qIH-=36a;xdI0N?roySyRVhQ9{TnoH5{ zF~A63k_=R=UnItOhZgn?BdF%90B+4k)lO@l+5*+D>4MJAg#=62p){2Kui;7{0)|6^ z_P+y635J?3^V0g`E)3+xQloD`cY&^I)(rHmMrCi}o#Zpdv01!+>4$^(haWJ|Ixn=1 zV_V~~==(G6xjGNmXoeMI$!h9fkg6dw<++?-|Jvv~Z#kGwW@cwrPgHBz0Z!6l*Bu8* z%5UI2jajfUQDAlCU9bvf^qR@5;Awi0hGzl787rH6q4Y-!5I66FZWWoT3$mcvnHQ(G z7=}b@<9N9C{~4w02DDjMq4X;~%`c@f z+994>mpg(%F!TKFnTpu70a#-%bW5XXatJ1Ks1K^Ai~s{#13Q?mWf1ND{Tg84^Af<9 zerVf8&UYGt-(nsUK~%(*PH6L{FG=@BsRl_degzOS6C@u~`YqIWRbF$q(HC!~qd4ON z#MC=rdYOlk#sq}pKKq6N5yiHY%D{#kLuvnHVE-hxBH3p$68xDdpNI4+Yd!=R%UJ%6 z-ayP|G#5+u3%DM8sq74PTfrr(M(x((Xm@CT?o1`V_clNy9?aJ6z>cbdZa1Ey^g~^= zeMaNjOskv8362RzbuvwPE6;%Mc+jurxaD{*#C8EIc_~VBq5v*)q2l%dJ9aKWi`xLh zY3M&X06NS9XvBQeXIDV{U?EDE_}rxC%HlL5LnrlK_CJ(POf<2-nVJ`F|NPd|gM4}I8GhPC&3 zIZI}u(ftFIJ}M2)*SU-tuK@d10KhR`GT-Ik)-WJuG2(7N0&Nkmq3!Dguy4=@bdTt5 z>n;b$WZnp($!c&lU{6;E=-Uh=*}Pzl`~Y;XG2`%reUs>~YV*!iD-Wd;R)9&-Ao+#M zb7&8$%a|YEFcqc4FQMDJjCW5ZqWWu9fNFl|yNOPwI`4F&DgzsI2G#ikfUq(_;?n}) zmlfc0k%ABD3HHISgKi%$PUY!9SMp@vc?fg~3`onaLE8`>kPj%mgPWu-z2i>|y!!A? zH3DC@-Q^9fsvX@DsjFMdfEYO)J+3enF(VrY%{;W-pbxwF6o@}t zf^O%2wB`K((2>`^J+Ff}m`2l{xyUJaRlv4v1_m1D4KTPS`mWxHwvA6fGTz7Q}-<%p?aCv+)e<~7;bIix%xh1`Q1OD^r#ZpPvy?5&W)2!llrIv z=uW?a>NTo8U<$yr^N{rVFaTe!%&0(s9lijo>4CR(2S{HCkQWZnRzVLd55pC%;PNSt z-Vx_eeMmoD#7l?_MQR>CPZ97nUK>0qUi#$#1Y#t7#*~5YD9SbqOVPt-a3)=b|+WIqz zwS=?Wm<#rybftRcR5vw6-&dI7Gi?XSKHjW!CDy5K29+gWpIdLw-9A(30`<14c4CdI0eobIn@X_{R|2#bD2?K2Rge3!{ArZFm<-}rO6t)RZSxp5_T+tQQZ2O2 zWwjQspuV{%NnHK09Q=>27&o;HzyKyMDlbOgcQ1ndZQei9Nph9%R-ELid*W4)1A z+)@38%JF2>^09)_)n4eki?@zcUM@b?qZ-0T*!P#A&6@ zs*iYSSj^WE4$|v|a|-REA;DgEAWo%&WJ3a29V4q&F9G41jJBO8P`b+;%4-MFBb9q* zC+(%ecpx^>Fjtb*kF`Ovl$(7j{mX?h=zF{uNFFhq?l=J?qkRFkZUe$G9VDme1uR)$ z@R-jq8uO`iSzftC&S(IiI90Zx$C4z_&0su~`zKf(`vz_M8Qc1{0=U-!Jw|e6S}@Kr zP))fbK|JvuN^R+5XE2Exc@ic4eb9MP(t!-i(wP12Ph^(F`xSKEVt}~zIuHsYt-NdKvGyt2 zJo|%b>sx5+&P(A!f>Xhu3*}0W9FEcmhK(*KK$6Bp#rpYZySNUZYdZj)8RPEbHDh^2 zu)33qA^W%i>{x>yR}KJc+llIcuR*e}HcC^ug__V$N|Z0ek7Mv2e~?>pjRjm5@CA@s zY^(VON-KH*B=kV_I6dH7ElLp;xmr~mT` z!QfxF14$q+4eLqw8?%GW2Z8+}zNi#31#O?Fg6?1vN-J)o+X9{+n-~RUj0Sj{{$)pX zv^AxVZ9|Wwuo|)u)o%At{b?V@n8Zxh`j^q>N^3vD3{@Jf>C#@X|KTn4Sa%w2zfyH! zl%fnSgG`nO53D|J;q|!uyj^ zO8*5U)p$?-i#MRzOiFC!1BC^g{)EPmxgqmr?mR#8*zKDG=iZpl8A(Pq~IyPf;|Cl_$}H4R`cC*AQ1NFH7T zVnu0iN#IFxeKm;7G3px@kLvHtV07k?E*5~7$l!2)bX(0?R;Pby#tTux%jnT>7fALn z`xeY~yUGQ4%CqcGy4*z#(c>fPc_>euZDWB=zYe-~9HXfQZ5ye--Ap@-oCNF}6wUj0 z^xeQ02(L1+@Ocopcr!F;P4=a!p}j0=dCo*$L60*`NIuO&+xz{&`2Z#Ol8*6b+R(Le zKs+9f>Lb1+u~57l#lvA3-+UCgkva6X)`gHIl5Zu3@CS@f!Wm z5r4EvL&3QoWjRgGcg6wHjH!qPOzBm(VvMu(Q8Lq%ckxm8Wybg8M9y~~+UAF%n+qR{ReTHyb|j)S zlv?{K4A{jK=)Lj)yV?TrHLo(kCjr{gJ9;%j50_?O5Ws{`Jx}OmHN8sIXpFJB1F+vQ zE;+=Mg=Ig$aUQe!7ARf$o%7(u$)C@eI?*<2-30Nq_ki_pj?xzT&N*at#0#a?)MO3D zqMy+5Y`cL{Y)7=Y*)Vu7ZXA~-XiM@yX(m$<^Sc9d^#Fs`R9Ggb@cA`Vw`lkJTAcn_s1w5G{S`NY!J&Se8}r8P>I`OZmP zLm)olw0h;B^cnRR$|U8|&HycVK#r#Q#H|6C$pG!*1Rzqmk1Em}k8yKWS^{7g4#eg* zCh^4dV+5K z7T5O}BmJ8UH1BX)8&;riJr2J17>E;j4(5_1Xd4hC__+H0sbG*s?^yYcyGDEwp#+p@ zphN>D8Ys~~i3UnEP@;hn4U}l0L<1!nDA7QP21+zgqJa_(lxUzt10@D8Ys~~i3UnEP@;hn4U}l0L<1!nDA7QP z21+zgqJe*}0m(8Tz(=x-3-FUHrU3umhF*r=lKEEnUVO7g6D>cKWY3UGk@9}h1v`8{ z>*lGEO##jHyX?_&uKZ}R_08P#4oC7spL!b2)J9RVK2kmwo;E8WE>b=eo@NRd5+(l- zo;EIE=%L7f_?2>GK%6Bqz~A9J0F2Cs-5rO_PlwGa6>{H^Dch4B;j8dRE;dW@fPhg^ z@*znc7cfb}aMLC8fpEiM!=S;L|9(crDKM8n^TSsXJtf)8;adu$hNOdAU_K+xOUL;` z38nx)&OJCkpLUkhO!0<3uw5rj14)b69?0e&U$BP1eplsna;pE!qTp zwn?jizZCL{5Kk`c@LeD4sky87sXh{dMq9N$LS8W+hwoD0xDesc7uG@II>bVA!T)>> zim%Au*SKD(N1V&m8!{AMuH#%U|DL^6JC$#NJkH_U0d#xuT{ld^yZ=}Zjj&f^jwEL} zd_V1id01m|j3Md3?)VytwHOu25*^?#$=Q+|ljHEcK^nQIB3aofCI^IZM;s2rZY@_t z)qkd-Auc8~+G-4!tiBoyl;P(TYd5n8!j<8Qa&7>HoHlb zd@eFAvFRaW$V%B5tcsr78GG%JyW_CgF>IDch{KT?Dc?7;@F|<|4zNeyd z&VfcbgYs!$vC)><4;;Q};G?PsYO?z7c%Ku?bT&GCw~12E2PAR$j#X>9YHgre6O(rM z)+^}aD@v;ZHegV((s5#&4;q-iKmXoZ{#US$I(aeJP<18?cvZmf1w1U^9sxfU@O=T_ z6fjx91ObN&*jvCT0mB4rC}0ghh#uY@=If8I%xN^rzO4?2q5#NQ%10|vZu~jQ=M}fT z4u_zy_$fIbIUFhJrUYg7c3831`|%FY-QNUoS?#Dj>~N%}Cw5b2eTc?acd}+G14?-f z>hnlG_aH#fCjjfQd>E|929%p)FmTo?D^{U)kg_ZRA$XO-miOqo#hbrfO zR<2+YMfS01+dyd+2^r{*ZEu0b$y?xEzr-AgD20(#gwt1>0(^vH0Fmc`jpzh!mV^XteuD^Y8(cRqM3helC03uSrj zrvJ2EPziqTD+sdiS6!6)V0l>E1if8>wClomxrnhA9#ekahp9Z?MVEbEGKXqRFT?XF z_n=tlv^*S-!5Zrtazv8d9KNeYdTNw2y9;S6k~T}FFp*biO2H z&?8ztEXikNow5xJ3)6`ILJZI|Jmr2ORu0`lPH%Hj_N)gs(_RG>29+W#X%@CIXf}RI zlW&g+IV$G}4=Cj1Aw>nT@4##b- zkOUmX`g7_1m1eM0>gUfrs($LhTJrV7`2~ZC|6tn!7+G;qgwfbyK4ZJO|CEE+K~UC8 zETF}Y{rWqdkC3ScNS!j3US7ye;09qKgtSASQ_mmlf#AFIvuU?hdW*JclE3x)kp%p#WE}<%iqRhqQf$#c*zmisnKES zQ?Rf12ikvueWacimRZsKdVpp&ZPW|6vEj_{t6h}``p^Kd_$z%hOf-!ca7Fe7fEMjwao{cuFR=~5Gxuc&2f zjK5kx%DT}X-F&2s9DgYURlpV7Fp}J6`J1HbnPz< zR|bJcSZ1QBh=gM>ZlQ!dibxp#jD&&zp@e%v3WtKaGq4kuZGi~zFOrm(jp`g$|NTUY ztTBr`J@DfZ!q3E}6&iJ00SGTxCB4 zPAneEq*KfE&!ZM&jm^3MW&c~E;0k$*xcQLumfFRi>oh!+C>#3Qe#!4|)gH_*o9he* zTPI)M$$LuH%>m($z%%()I-G%gVNYdD$>CccGV^4SkDYjBj~l(jPY6)37p*b5hTYlj zXt;qmf>np_!M0qq_Z5&y)@As`H`I@5{hr>jYR|Vj=J~UGD0qX4E*gx0fzw!?&!l`klxJ5@=BStBSh>}Fj;XAL5r{;cS zzyO!sybq7i8!=PJ!yfAPFBsCc#wz@Uut^aIIDC7cH3A z#V3r0NNbyqgLN8vd0Z8!gi;RQas8nWbEZxT`(=u) zFtU9{lSN}=@S4^{@S5JVI4}SIkQev8B)j0Efd8$&Q32$p-CqYEK}V&a{fH5#xg0MP z0W@_~n$^W-wo? zfV7=l6<*HKxHwuE8S$!|n zA|B^ndQwza`qZjulGxd*%@93bqyXoN7VvndI1hjDa94TEF2>_U3IZ>oe=#?wOdX2z zYXar%WD`$bZGEtW=Ab`ZB82ir^(|E10F+;-ynLClqE_wonw)eNZ8-ze&eFe=uNX=8 zKGFy5tiJme!pjP+EpsCC_l-|M>eMGBJ>-afZKRxGWDe`JAvt$~Y4|up@*kro439#l zO3n>AVz9P%F_zBOuQep!=`egkqQyPHSo#$9pS%1JURG!65l|+vzhw5FxB)>%o!oW~ zy>wXH8x>8GM$;y}l#9j`*e0%&tHxBb%_M$Q)oy+G*kOL)KP^DQ1&{y12kJk{NT?Vo zYs>A`X$4$rnSv_o`=tm$7sP z`W{7>!`iI%YWg73;(ZWB{oWfD^=AB`9Ss_`qG2D?6_)B7Ra~`%8K8J6Apz`NvZahG z{!-~|2@~{}kP7#&mDwsYu{UzGpf+de4r|Atz$49~9fgwNex|=E)STsiSlbm)aZzr^!AMzzQzc675FRZblzZIuiIPu5$}yTKx3dfn0)Yu+!QbIqqXm*o zSLY)XK5T0a7?N(=2F_9PH2wV6)LG4AOXM-mDq%*X+|%7)zT$6+ zG=>~WJ#7j_A~?n^JwlGmbeF<%r}(pk11UG568iW=w2aL3Ni2mbSUO0N?6%D%#_fQ?k?lAvR|xw{KQ9g!0DWumYwp*$Q{*GqsM}{hwsj&>e*WXSzBgyH}Y15 zTLcm&x1UkjacOUz+O<-CUG>K?9J`+O%KBaDQM-502jG7xBs)sKC0lZ2EOdccUFBUo zL%~&df8n5168=TYKSo*l>!K`UeWEN0e!YwPKbMgEaD377oy9b})FWWOTN8)@tX(}v z&~e~t*Gc3r5e9sR4_uByjzn47?^ZJ3py&_SD~0zL=5R3o@X%%+iFpi9{UmD_WL2_~ zTKXrJ2~TSxIgUtX#U=4~$vO&mm>3_$ibMpH;vhEYd*cDzba<`r^shwnYIS&oelEP- z_tA2WvKeC`>lmZo*4CtzNt+ zFz-4ttp^?vn{P?UErl2FZk~aQL5ythZ|JXGS_SulY2lJ=2RH!~#l=D@AhPxTK_< z=A(ux&bvwlaaZw{+ZTv5^_eTmZse9EOCNu6NBLB(1S;PqsoSl{NQFh1zYk?9*fUB3 z`^m9=?4DA~swP}jx?w7(6aTPAFvE*9RYF$#dp(1$z?pFy&oPxxZWq%9pI*uBxD=*Z z_6o|+@SEo8!J0Wb>D&nmg$&ze>^`Cl|F&W!MT4kbLX6c;dwB&c%+7D z`(v&q2ooVzI+zOzB}ZUEK^6YM?$2~WAU2nG#HWbCM5t#)yr-PRBRGp2BkTjgFU+{A zDii054+S)*gI7T+MYKNv540nKDBhl)U}J2k3e>Pij`YgE-%W- zC?~fP20g?4It)5NjwrC6X(KqzXt`S`Zs28NtP$?fZW$4B#d4{q=d_Np_VtO1*L02_ z;NuSe7G=)#iE+Ca9dt>*OZS?7R~bJ;(2+zP+=UU3-Rv;+@{XfX=5%a}x#F5ZLlI}Z z{jSny!QU=JFmn4mKzv+Uk3Etiz$-bvkOF zi}PQ!e#^xXQThp(%LBcBff>y7H4t58b&wa$)8u+;V%&}z9G9aleeXnC`aT>1@FX&= zuOkyJf1vUgTb^c)Q2*u21LR$_KN6JShx$F#AG6n=#dzf9GrO-c0>OjK#Uu3N(jk!l zv@*z-yWEY?&y94+%`~@Z{~m4%`guR$q=*jFwnc4fB^27AFwOhE_NCA8oKm0q+f#?* zz}4A)=`NUbl=*UvD6UWJUcDgCy*Vu}T>Ja!!nVAu7YJ?I5puH(Y4-qQPA6PzNEaV2IR~H4)f{{)Vk$?7$eEC^Yc<0qB<#nUVUWwY>YBN8&C&|yER4}JN&Q%?eymYHwyGcL>PNQv zkt04_a$(5oS@7b${Qrm6BL0Y}1|AcBk%+~7q7G*;oUrRuEsPNHILZb7?M3kc0t#_P zBNtY^1HuTauYLv&im?5r+C`r3T9|>A!X%$5r2utPJ@$B`p?G$V@wfKEYv3Us>SRqP zn+#K60UOaLT8{9E4hsh(K;2Z=6R$|-R+>b7J}+I79H*?ED>z@k;W)v`IT)Nf0F_&FdW_?n&9@!hUe}u4&N&EJT(?K2IWPrFa_}q z?>P5xpL)R^NA^V8_-b8|HZFdDdFFmnlo9?y41kmV4zOU(A*xxH2i69W_k0hoUQZ`r#m7@HqDOd-6ClvQLI59+;JqY)8$ z$Z6$=)tGeZB~wLky#EO~o;Trzlw-|zmP*Y1!Xhv)rtT_Nt;`Eo;!0h z&UbeF&25gpjig?p2T~G?VSWx@xegxZd4GXcyv~t_9HV4D>Ik_{>m8}`#BE@p?7b8e zN>j*)aXRl!LSJjgWMwoG?6UVX;GEZt0KC+vlvc?Qn`Sx{hY0K@Q)K0yxhTXu`WD zdd!pdj+g3|qMcD8#L-7Sz}p6YZ{cFyv43VF8{mf(v}j)kOY;MVsSfsi+jU@{rIg0x zpr*2iwI8BEH6Xl(@w>_4aK6p)+$6|X_HIO8Fp)A!7rZ!N_O8wu6v-^8-BgcZ^RVE{_qj+A{Fx{h3bWr zC0CBmcqn_%Fg=KLd-0Mnb z=aVLZ%*_rH4a0UWuus<_=c_zReRs|<=x<@{;@mQ?u7`2-{t8cp(_Xixl;RlmY6jmN z_z&D*zUXT1uFyZfSoWo>i_5Niq3pNdz5kW$KP0KMRb`Kl&0moJp6qxaP+a%8M^4y} zC()HUd1&;n;H_&(zN7D#8*&=YIs<=3CS}eY<-0TlujyEkuiwXE8-E_}nJKSAJP@Gg zj~zWUf{w4B$yt1#w=Fh5;|ckkB%f4vOvFs!(ZWS!h8LFgfgI;Q{SwME@(Lj_>~Ib% z=_kPS@8nBLsg;`f(&`JPwcx;2rET=Qw2QH23#HZm_oO|3TzuUGn*k<q#P=@{247g{idWGm3R#baw>o5MfM*TJ`#0+1p@~Rpjn{n3 zX!g5NHa)gfi9HCcvWf>pd6u-zh`>SU&Xe|a% zs=9oRmvUA-MtC-Kdq$rKbmc!ReZl4-J>_fG?tInN{w{p>*xAg*r1QvNJlZ?PLlb4u zEbOdHvbiQbbdmJ0-Hn3Bw7cO&GCXO+yO32c-9M9b)lIY@*pIeo(guU`KfZOqlUXC4 z!cRw9qICSe6W+_~?4dF0J7k#ua*0ec=%VySEFnYAqW;xsH`JtP7COQH(pFmlqYF8} zC&;0Ac_SJRu$xEAr=u-+Ua>za<7PW)CGwUC7tUShTp4=p^<$#BS}VKm-zYaS(^G6rSP z#w@rUi1;!Zac0PIWj8K4*zDndlP-V8TAVR8=hJC^(fOR_e40gD@LKo&NXFvwg-ATn zY4%U0r^L+)B|eu>T;fvyNMfwnGB}lDi)8kM3b0}h?fez_UI5Qv`WSF4j1o>T__S#I3fNmEmn^InDq*SCpoS-)9+LU;1Kjv#G|SIFEdavi@p@r4q2SI`+#k>tEEG>GpWVvHXE8?q zcYfgbq8Is*XZ^r^hU%6kupP@}aW8CR?L}9RvmCAT=n-NG(~e&8tr zb`cVJOO}v=cnINlB`GImSx0CQN7_wu(>3iCDuoL zf%lm5Cz61i(|>aJ&EE^^TBx$|B%9lYQbCTyYCNV&>%WQBDUA@{*#oevqr^`FTB|fc5bz?E<_{%4i|ZqNq0onfvoKOP&Tu4MF|9#T%O-eVgCqppmH!@y$o=XL4@d#31O6|R-JC0;=0 zQkk0b5r?T@U2ZSt{CWCg{)mwDn7iCX2eXvoD_A?aSV|+1Is*g!PplG);ASd|GqttL z92|l*HHhAdhHdII3?vS9>WR!NE5ZPSKmNxJ+u+9|*m+nxeT;bqj#P+^ba<4H9dA@) zo3@8I?R9wm(U9kBC-m&(hersBSD5O4HpZfVw0f6q@1a@fp3fU;13y`N@l8Y$@%!_# z@lGI=I~IQfcY}+`BSP=vzTf^*N7xLu?H9;_pQ{ zZ4)or@C*L=FL7GO1?1ox2mW}ZENf#hxH05*kTx2HkV_WhDx4G1cxN*lxlc(+jpypd zjEa;Wh`SD+jzEYzK+LFXE6 z@vyZotI+`Ql!&@~IM)ZJ6$6FfYi5j+V|iM{@+|sjj>BQAsFFV+InMaXvIe|tPw|Y+ zDBmz7|H^ll^(jYj#WKk0Mmf)rd|iXWpbQ4GmXH9$mK5+@ntbNH%^#W;O8{+uzs z&6k^eMNtauH<;n?VSjPJIU!Iu#5V-EV%>Ewu)jLRmBk-gi#q0?m8TuXa5 zN8yw$@6`PayoiNYQS~YKBkLMvB_xfm$zRn#JRvA7<{XP!HCGV>fz#DNh zD#+FM2$-Zy5gs#}LWC<5`(e!}qtbqg!;z<*YQ>D8l*Cbdm1Ytm0PV;y>T}0UyiQz z#0X>v`+yr0)IFdzvKCSb{=v$-JaL7rZQ=W6?~{x0yd~q5l9#;!Uou~d&T>YE;;vSg zQn$kjO+Oh8O!yT8&4+?>)DsJ-_r{O-h7e+Vn&k5&9et3=_~&*HY`<8~|Qz}bDtP78J~<+IyZ&;>H7d^Y6ctob;a zBt;c?Nb8hNpE?hsk|p>23|U)C#tn(sNcO)W>ZtJ?N|%} zO`_BXgU|zvFE$Qv%B120jm1ED+F2G=Ppp}u4uU4@YT_>!ZR1f?}z(> z-6LAIQy#oejv3@C5BhVtbWomTiAl2t*g|L- ze8LsDzRF03?uv?_3!rXtogUyMqAmRVOS;&Nz$>5Nnq%17Kp26#QX_^7lCA27)hH?X z6g_=-6Y8L%*Qn?mWjN669ft;c*Ze&&m=cK}l(A})TD(A_=m5UC1L2e~RV0-mMXDe; z_RJCDKsMzpf;q-uVo@DEu&9lSuy68W_IyQ%>_346B{h95)N`r1QyAg7oa&+UU_Qy& zWrMgpImdewP;cI$R8p3txOl?uggf1(U~v2Yj3G611fSM;x|LmQ#Vr`F>DQ@i*9^% zSp1j|x4+$;Xm$L$IGsetmqf=(&v#-ESz8uDMaqejG89)KlRjnJLy8oGfa!=nFD<#}JmCI0A+>KSUhCq4`H}u-Ft%1H&K)FNAr;D%zpN;tTT# z?l*2z#uq(vlnS^nu_4x(d#HkQ)`ma-j>zk99nE8nCM=_fAj9EUZM}dEDH4_$nz zbQW*p71jp`$S^C0YWlYiVrG$gqhgQ`;=Aql;e`>P;T*jO9k}HpQq!mGz_js2H~D}e z?7aT%41NVZHNzCbZR8IWW_!Hp3-@&XrfY&Tz_uWtOY$R4IZBex2&&QU00Z(1CckIh z71ZV2iV7U9eY}tbT*?>a!dHhrb8=}6F81A+SYkN@meX+vd(xV0A=ve)_e~@7859*G zu~L3(F}7jP?PGss9HdYWx%|T=R=qvpKn=z~p~9x{^0crH;SpTXMGbRg<8(FBF;1t| z8dGoUQ+~ykm9<^W2zM1vHQf3`Xv--7Zb-hym`1!^OiuuVg6e3F#tfVs-KaI-xeC8E zdEqMLd)CXsRg2RPu@_zIZiJ`|a0-Q1Mf%m`$)O+>UZc2g8f~zqY98mu>ivnri0aU= zDGqJ^`=QlCr0CFXUO2R@?KqE0@KBX-9L(jI>G;VZ`CRgqbkxj$g$onL?6aKji}_(_ zD!~(Id%ut)$$urG1RbFpj2>2=--G(1ncNRndz5Am{9X&*BPX>H2P?NnzGgxBqmxq1 z@_Dn&*X#nENUA|Fs-O42XV>rd< z*N%55pM=iT2WN*VwETO<$8p*e7yYB>7;_jnO%Ds7?W_ujgI(~=uH*v@I19eP_W$ay zoE1%Yl$1*}P@;if$2Ye+u%bPUXBSDK;dnm4w;!~bsM5{* z}AaHXjI>bz)M1W82O(*ye^)Xk5wPvU7*n4;K;y8+HUIj`jjbXNDA$z zPZ^B@4oLTq`*yGG4frge%qSshJwb|eBafR%{Wo}_D?OV}|MUx13TEE7nI9IxmP7jx zWyRhZSDcwh9KD%C3Ue5S^ucd@;ekgvKJXy-8p!L}GKjWRV0NOt&c;BOG+~nZR79Wh zAzGYy`D4t<<42m1iMMLqU_bc@`Fbpa;RS@=_5_x0<50DamgF|$oPzlmu1~O7A0>3K zm|G_j1mPLt1D82?cdpVaO8f4dH2z${0_AXqu9t5!SCHF4RA}6W0a87DM$3Fyh@-)S@a0?G0lPjisO=(Y9C$6rm<#*9It^JX?QOse1r7-*ejlvjiFybGjSp~J(%{uo{C<;K z7m=n2J5ns#w(4-qi`ZX6XQwFW-;A8e%BuCP!!3^AO@bh*6jhjFR+kPt>p=Mb((fV_ z_?`7roeNXwcPa*{erKHUILZp-%C`4c%e@h)s%~c3`6}7Vf1&Un|~+ zRevi4zetySD~Yqi{7rnygu(IX?@nZBs6HhUj#L@h7daU@7ul<{HK^-T-UZC-pktZ< zzmSZq`Rom*`iG6XMGC{Jy;oHj;#Sz@Rv05bW7g0hw<_J>N$v3l`H;bJ66fn+jG2Hj zF_fvh$fo8fpY^1LfGxXi1?%0+hSf$#kqu)y3(qnFVHk$3uo7B+Otx|}mO3MDjZ(?L zRP+XyIqyWbY-bwk6x4)YGyt*uoxRoez@qGx!+g?!TZ%}Pfj2KYYMxEy{RVk6=_Y5v zN32mci}hiibq!Ag;|3ttVB~bg3Ps5=S(0o_*YCBJwsZzjDcfc!H@amje67c-osB(u z*qEi}dXP=UT%e)!?Sa%!HpSwMm1YGZ2@<6xhQ!#IpO|mD!pATManpB7rj)|0DTuv( zaqTGz&c*^#&S{050Xet!hNu`(0CMIwHK zko&se%*)T@v_!HrCR^{r-`zCkD5YRtI6a?C)@c^v_a#iD#0#I^ zw^45$Yzl7O)a2W`d174AfX0@>-N7V#Gx6+&R+g=7Z3|NlJ#18XCSYaXsUeI$ha+N1 z@fnlNMa@wL!eQ8*zj4E!0gwy*oSWs0|G(;22mN45*$lLd=Mi-jJ%#_f%kZ2p=z-Vc z#jjJwMa$ZsC-Et>c*FdmQNPRInDVPWWicL3L@@>&n2tB<_JIT`Tg$*KgM8fD-NRsh z+(*B_SNMk~P>K0rr)g774a~Oorh)h}jj0bocY@XguM+qZRO1g-r(Q-E!){fVz8^s+ zwtlD>cB|QUUn^TA(E=%;Z{GyAv=A-MUVYgTfQo#|d^5&0+I*A40K7z?C-5TB@+C5p z`LdfW3~S*0v3slU2reLZaVYeT^}#a|)V1}%RkCnB3)VGVUDs4($!uRkzycO`!NRsy zv^Zr-u8x+)XfZz=Y-%254ac(_ZPG-Z*$7qUz=oLXuh4E3& zU51}Kq4w5wRXw$wWiw$S>Q6fnaRHYq+Z$kNwndpjC`b*0s)Zt5z-+LxE*!mAfp}M5 zMm46On#pQgR12)d%9aLX{IG|9!8Dnx|n>$)F-Rs9AUrTP&Vvl zMi3*v!I?5R`9?JR#1f9!m@=bO8q{JZEA~*HH_8ALObR@UV2z*#a?7UOYy~ z7tB{(@tT7v0zX8lh451$n^=MAI2-YO*2u%g^Xj~`BZ$lJP5ApLd};Fw(k6i<%7F*(+NtC4qU#+bj8$xJVC}ogI4BL7UOb&i6wx6RSs;?s@?}$FJSnyegmzSWSOM?4Ic5{Z@hw|SDE{&c={TsNgOR}$BpLWRh(vHC^Z%}W&Lk5+d|dnZ|31ysV|f94w8#z*3C!EWy z6`l2Q8jH4GV&*EZn24AKY7FF<#f0Su?oz>BCXSAN$E8pCMavWUtZ?I4@rcqo@Hvd) zKU9#=F&CyW7iJZEqwYS{ou-ge9$=H|hUhRj!zN>gY3>-bIcUDc5J7(HqSXsH)N)c; z0T-Uo=ejcdnLfJ+7=+KQG&hOT>Lk2i*AXEb^(xg=E`3K)4qkx4So(-4b1XoJvm2F4 zUY{fg{h>H0sX;)@&lCw)8OvQukD?r}xs%ti)OsTS_=0v1^bBsn0f)y3HhBlOv&D_5 zY@@!MHsc!3sQ(3-bilL%p<5B;84X7=*!Tybwv;hl138w7hZ32TJ_c>EdJIuQnr&Q- zwV6TFrarPZeaNmv?*`>N1$yo?OSKtLNZ&a&B|cE#2J;ce0s!j-+}HmV{8*9^KYs0W~CDWfFd zj#_kV{D;yt@samuX*(j$bhD`xa{dwOmAKV-(s=`I>EWEv(W20e%kpg4AQuaA;|--) zuql<+q`_v3waHx+e-mC!zD-j%+EvzQJgA}aDU75wABJi249q-BJ=8F0b0Y$#1tMfJ zots3wjR(L5b4pHR0che?aIFHcfotJ24uNE)>S~s6L9$YfWJbeWxEb)oLwWNk;340YFSNM z?2DbTKE~l@n@gSQ1Vq5rSg-<515|bD@4_^(+Ylpq3?(=c?Gqe3M}to%5|ft27g-r= zEWTxtdiD_6B6AqFt~smJWILxIBE!E(MGnphI|bn8TZk7b?6S??%lb#b;*57&4cE7xf4MkQdrqQVF|QgZxjrIA*_DXdOpNmHaW)9Ija zwv;cZ$Xj_@;vGZ?7}=W_p6e~w%V?;;8=bA?<$-8L{8HJU>iING_ImcxqeuL1Er#oY zVu>;-NkeOzDkKB##hy&}|CsdtQ>S!3z{8!$;tgEMv`k0rZH)SY@gJVv8a@8HIgCG@ zw@huM24U%~a+$w^S4#^Ii&rnQ;C1#=%KeQNm>pOy_fdt0rJ?JMsbVE_X@|uild;oG z=~lf{=>jls*_@JMt03VEXkW>fDCmrX3tEo8(_xRG(Xg4a{AML&rOBwT=fz{rbv5h{ zUmh$UQWCo4v0?#ym9(wOOK7ZGg27;r(`j0%B+=?|b~NdWMX8!mA!(kIu@~y|JrW>= zO)RqEk(At8)fg7~NyPfa|1Cwz2F3 z{80)OM8z`OrT3$0Iv!1RG?g!l7wt(V%kR_d!5n{iwIeiDL(0<-c7;d!%L_xpAnjN; zpEvdh@FHeUcMS^Bkv@uuv=a)ftKS-I0fAMIWB&im=fv3>DChO209{tcdXf0ERN$nr z#GBNxi;<<39E}vAtHt1OU|JkM&%p8XY+st==l^WkzB>2+pB$eD0emOREsRxznu4)W zTk(6m)gQY|@vG$E1e6liT8Jh8#cJ*8GOtCgUv=PlsdU*pECW97ka9iB^cDJd72Bw_ zWiF%sY1W&%vWr5q>&nK8VI9&9)YR9)p~aWW8mHBvZLn68$l@yxwuT3=ow9^(&Y><@ zp4q9G>qYWti5)K-O5QujOFAtkiaDRnwbLOH>P%QfLe{24P%4QcWeF;-GHrtcD%R~F zG4;MTPW$sxZ?djH_(|BRbvs+*EcGlr&OlFQYEbERkX5;d5G$yjzqF)^%- z=;36mw^VjH*TPYu1=&4Tv>=aNG3_YN0 z_>d4^;3RsQuo#%^O#ECAUvROo!nu!SsK1@Z3MhQ?10(^P@H+PbtWTmRVL8RZj^>d; zEZ^aW17>(}5EitjvFx4P87|K=5G;q#{G z0JAQnU;elmZj>`T^ba}RJ z@~49RNc<8oJLtj$TXyX&G&#anejoO+$GCscy!y_j8GS%2B8H zZXsunoxJkNsNV)NxJ-1z>IJgaDK6Hoc8P)5*-uCjvtRijg8wqvc4kphnDj zat{GfRx*D%WwU6cw23JpWYDbrH&!Kn-g0?Rd{=n|CsC&r+XAGTN)8mu1>*S+RJ$DR z#t%J>Z`74v8qP!0_&C!me?HOPva`cjmpMOX&GJTPvfy-!3y0R2aeC>H+?iKnR#YgO z$;ghg$T6B6^{<7_W-waS<+6#56-9;#ct!l(rp`t%Y>B^{1buoi+qgih2~XuB96wny z*hhnm1cn$$zC-=liLy`ekD;C(I-85lQ{wvsTh(W^; zp-%b1R%X8Ge4NaUF1m6WU8!G-_m$PV5XyApo`AMYWYlRwXnf$$=mS?%9Mmf1zkXwj zW!mV_q7!KmOHEzbgz)gXSs4?;9C4R}xlR`!5ah{?fwcEFO;$1zCt2%R;xZTZTYrk| z$+|UPjvR|5EP%mWHy-kyelR($J_%YfMwT{YjPIW-!0zgf;~*L1H1GqZ5GWF+R)(4; zRnVkOEEX&+THb<|Kvoo4Vr0aG>a{B0`S6~W+TU_7QE(z7GcJJk&>Ic5)a|=6e4Xhm zrO;-Dg(Y;sG5xt#Wgp}h`v)n2)p)SvrGe8*6O*%M0sN#u&^ixfav2ODWy%(+gYfHW&x{D2%zE8v|p>Xv;~&do3*NU zg<;WLhD?xlRRBp!nU63*cIX))n)S*hqFS$9nmCi%=1AEn!n95&R&<@bA_y%C5b!Lu zHj9v&KAPqWIThW~(r9H%{P%ioboNIe<3&p+v$>h51MuXZ{c7Q*VCC#lGO+1bna;OW zF=^hdk~Lr(Yk#XFGHI)jcB6g=Bf*4;>?jRgEt>Ny2RVWm zaLUw)KSN$%SKt7M{W^5Ddy_d>u%&=m^cQ&*5WhemrA7xU{|Eu3QCHF^EdrUyDs?e0 zb@8)zHSZ0Nfa$Yk0?&|w5hO3+rT+Qtovv3eM6_o<2Sre9kd>xWdZC0elx#zw964Rx5^k;6L$;|2nh=-%@v-A@)-3~ z;eiM-i!Rh56RP8unfl%YjO89oTa5Z1gt>;`05O}+F1D$W=1g&sn!ocBmt+2# zR!rJ2DMO&vb2iCI^=&=}bP!bSnPE=5Ysa zuvL5;pouN|eI{nB-$h815_jD~<7}-tW>`H%B7o85Ovd)RB;_@6!&xTgp1Z>%KjvgV->~7 z{aP{z2Mt?97a!zR%Qq1|P5B36)7M*7I`cG&;n7;taO4nCXKtNOD968ajO?!HK| zBT~ZvWQt)BehW9LSA~cmwJe3bMlzyhq#~nnTcS)YOCr)I)R^C5hpIcFLv~W5KdZA( z6~sc}Edpqk=FvlB);?5H2W*91&>VOVVZg=y$tFa9{pvQz9sF9SuGKAm5Ko<^7`pdI zv1xkGe3f~YQOT`CM)X^-H2GJuc*R{Z$ztwS*fJ!s%>-Xy(mX>B(RkLjs+9=(9~}o`=YzhoD7VM`oQPV&&)bna_=C*73}Pt0SLy!h=6D z3fR1pek$n?^iX+5s-|N*Yr2n`@cEdyzmcxwU&YE=&vnR^&+p(W#7!w?LN z4A7N`o_MS{rz{oo;;%j`UmkZm#!u@9yXXdg0s=1<5DQcF9-~=&v1kbQdCN`>pB#vt zclZ7rsPfGpu#wu%1m7OS))Nbfzo7(-|B*Qi&wc)otXp&I$|o2NKOn+bes<*j^R3nQ zB|js!|J3kFloonSe}QFg1_PGyB{t$yVHkTxHYO9fk^Nc5o#V(K*^iE`iU3a7yyiRR zRjxqv<}EbgO=!=W==e>Z$lIAl{b;>ryJ_JEpD{r78#M|!&)<~;WAg#qaaNH^T3p=? zCQw?wTbRIZYBsp7BNLA$8UwniW9)`$=MQT@fW(RFKGGmM$qF5%OD;ID zcjAP4RxiF90i==JRkQ3jw9A418Um4%ErjT(C`B$_9s#+iW-YgkLUIGq z0p92oJb?PmkHznBEZAFJ4rmDUS4Ti$yH+jec#+f&*9F4s%Do+xTj0;pmACS3jXLK@ z0GB_KT1`P9T$w=1-QH46eDI{o)A89)t3HA>isn)STT9)E#)VoKpSeB?K ziK?5ssbdh#;3f-N8+)|qaR_eG&EBf<&1%5!$!a=RS6U;ZeH*Y5I!C<>qm(K>MjG&Q z4dscV^#Y8+#U$LU?5!=h`iceD1?p$y(6zs$2Wq2KO%Bh=)b2N*ORVxnZxQEAoISHc z>`TuQ8o3x;wrFBXU*P_azTnG~l&_pJ-Ige)pNwt#j*2^1%v|v+mUT`OTL+{8Zfu77 z{jAO9uxr9OSq3Nk_P3N2>vM?OkEGmZV)|VeUcspsSw*DXk2jI*(AL!TX1b(~eVsTt zvujEg4JIY53s+c<0>^aq$)bK%_D*}JRHwP8)>8muU3)1dcwCL%f~0kjlLVSK6d#7r z`Mn}b7Q29=5<0B8IL+n|;_M&{z*co9i}oCF>T-s$1sF+q08C6=!gRT`}hXJL|jYx1S3r@ zUzXmb0%dV87?G=6xOU~;)F>bRSFj{@F>QQH+|TZNJ%y-x3@FmM#Vs&m3?_t!AW5qX z<4LJ06WTmL@4ll>mMW+#b_wjQRe2!!-VS|!Kan535kB3;Vna4H^i8Eh6g9Go=DT5jO8o5Sxpwt zaXbkd3+wi|!>1Grnp1*5_xx;&pdv`MZ&3|_HNgw zh|IlmVh0PLN<7#t&#H{wkl`_RBNFfK&-$}3di*^kH(Mfm{Kmo^@N`D~&v-`mlo<=_ z3513SUo;pDiNtYM_fs&%GjM}ZFUM60gpQX7cM5I@9Vw5V^2qg6Y`}619ttV(WlYK) z=lHV3|D*adBY-l5%Y|E60(!Non<1eAGq@xuUTqW%6@n9ujo35)O@`}Gf|I`@Q-oDn zV)2)4>X|cjA#L1`tm40-5c-X{ac+x<_KxA5I@?u}_2IE0d=mQD%4aq&Th&d7LoJ%# zCedmdWkI9mrAgh~Lndap$rn5RkAghV$SR+iqYX*rZqO;OaVY1)@DOj=q!z#hNK)*^ zyiwf7cFJ%&&T^rI!Mwme&lQQ6liC-Lg zT+sHn^7yqpelCw6%i}?L+$WDkAa%%0xDgYF>WMJwXTvq?!1Pq$##Ept6}U1Lz&Zqr zC8roF&9gmOUKGzHk}26a7rPCy=Hf_Wp_Y?bhZXje&6^Y|m3jD>Y~JFfA)mBpxI8YD zN4Y%CmB(4~IE|);?>CkYPexQv1OSLa?6clCYy(zVt?DO;0OIxg!54di_KaWkslc~9 zG%FI%35|}#Gt;K_aZ+m9)P|nYZYjPf@#9K!l~(6+fB@>i!Dd8SdGL^J@Q{d_bc*E8onR8_JGO+O?R>TWFiOLyaro>H7-H@7fRnp7d1o_G)4=rKmU!2%0t zQ9F=K2Y#6fyu-4kW8@-HM#HE#Q=jf25ZRk!G{}_bf<7(f7W(*%g>uF!)ISpUgieyd zJ7AeUM&gQeho|a77|W*Yc&icpIbwsa1|jY9v~?@eJc5L*^#Fj9oWtLtj;?FHRw%WpW?7FdjZb{= zCxW7WqaNk11unK}5(s%UsL-KU(FhZ)(Od{pTe#Oi$ils!m4SQb7!5Os5h3A4WQ)(D zXd3}rJ9=LJN@ve+IaYUUGMTl&e_-Pajq4!aAq=-68>gS5Kab?I)#af&VdD#2O1=eC z$S}lKAaM%ObO*%_CuFw9Z`wyTdkPlCx9my1VJq_T=ipw27I`{fzkq@;_NM$^%s?B* z)K8pr<`GJ*+gobfwTNDEn|P})vd?Km?vS@EE{+fyb`z7uy_!bdn3-6qZgAMpQ!zOSq({Mi)w9$bhBmnKN&n4g=C>hU_cE+5)O-OC? zwBjj`=E-D$CJ53jQJ)I%ghW3IldN4f>a)!13AV@CRh+x;3mMTOly+1&R&-UO9KEC*nU4_y<8CU1#cMonAUfRvW!VO}UHc$FX7dYjLq$N2%Aw zo-QsQQ3f{4dt9$pN7TNAHM-RKbMkII-gmjZ8~Kv~znjkW+6AA0qUIxm%K^jvTr z)20`4JuMIlYfWdn`jm}uC#N~OgI=_$9+XbGhF$K_mKMUH+btYK>gZ1wCo#6J3Z>*X z;4#FKRanPJft6YggL-jk9rAm92Y*LaaaZx z)_sIUlhd@`=y2PVJ}bV4cVA=$#wkTNk(K60_Kq2`pzN4n?L_M5q~a+|I3{jfHYzSD#x>inow zAh=#V1ggX@koJ&(2&=r8`Kq>nQSsySrvm|24ML^?>&MMtR#Qa$R8|dj9bnS2F z$~Pv5jN_@y8AE4tzW(N+CQ7cRK`jX%3AK?8{zy{^wQ;FEq25ApD;6ODBI?|H7H5=4 z>Q*{Oye)JV&{{r!xJQr;=ZosWz5?HWM>X$PS_u!HXRIABo~dV;SS#%lQ{EZi0T&n< z^$UPB=Dgt>tVQJ!Nmq^qV0Bw~04&L!2qUo1VMisbCv;wnceQy=o0?z90FTrN=c5g?k{2%3^%Zp<=Nt7{Rxa@HKq9oCDj| zx1-V;CFXW-ysj&gv5!xNizVuDD@yPtKAWhzvTUCMeU#BTvb1v(tbA&~I<)}UfCvP8`y0zz(fuPA1 zLU@th_Mw|aV6|6YRSR_x3v(Z;Filv6CvQ`OVPU0F9nHATZpLJZt=1gDXkYpGws5b< ziqjng93uvQ=cS}p*Gj!_>X)IVLohEWOOmIbRZ8XSvTBftNjD6L2 z^fKZ#7EY7MsB`zJLUT(a?|ZB@Y&-8-i$8+zrc?1MdSi692<*a3AI8w?c)lEcxl)n1SdWn$DDGUuEs!NT7a5z`7k04J+GXbpU^haVQcfurm2jo@S; zcE;G3a*&^&?P=U4@Ib!?#!jOWeVSn{1MV$5FT{H&pTJZCXa}I7f$|GNv(ZH_*7j9v zDj(L2Xe?L?YAn{e7PlG*=WO{gTLP)ECEzj`$U>H)YZmkF3&c5?xOG5LR^=r$R<#_L z%GRV~)dnr-=8lxcT{^FL8ljczP7ykLkYaPB{Ke~E>u`qx#>3QyoQqf<{Q$)0eWx4 z*>293Ob5fz)=fdtInF0eZh#5LCOG#8uR#$s>^?CZv1SZ;Y}oWXS!ggCDT@eKsqIBF zn0+uTOE@jnq>vZ5uE~+}dDLS$s;i;T?aHH9GxiFG*tBs|(r>6pP5@ZfFI^CSn$`>FNvE+Wk2)`- zN^(w9GhxtmNtPo6M)+fZp$A+aW|T26q&D{x8S($J3lW}aY~5{{7lp?N5Ti~frHOnd zwwP+wVEA0CfF-<20j<3RES=4x&zno^KA$LsCY>vIkBgr#N@M;+~~ zWBphlnxAhUBV~&t{=8wQ39ZyVLO6K43EC;^@hx2!x%mRRJdPL)PJE&QB51Llp9+}j_)UXet zFcF*7GIky*-7ampPo}FZ9d=s+m?X^7EbljcHZp};dMw0F#jWXR{(xf3&=9BBH^@A8 z-Vd>5{wFROw0X!yVYg)(kVz^%k<>6*e-1QhIYSn&Kd_GKu3i}}mhyndy#w&QmScYf%zww8TSw%j&qS@`t9Ze!RpDZ7o%{g=Lg6rgx;(L^S$ zYDLL>h4_s_ZOxE7l0`kp1}k@5UrbM?W%z1eQQy~H)7IXDQXL3o?<@ zr6mDl28hj-00jecG1?O0Af1$seTds6VQ5Y6bL?t&)q!u|#9l7v)n%lzJx#U%vlK5} zT-!Pt`ar8N#u~<7-D&%WuHE)FlAGGRtdR;weBPDnOvPb%BAK zJ&oDjJ;~+;8K7}xMa%RL^fj~x_FMC^ZtFhKrA?rJGa6nFmSnXG&SMN^NrXQ;&Qi1) z^(%$0YF;-^9J(~4L6`w+7yiqRj~nzy_EU1Z-=MX!pj;=}#KPD4J3jglu};V9wl%f3 zf3{!ifuL9FHNvcUjdqoxzA4?_5mvq5)*rMkZ#(+7V|>XL%DkFbeS88N`Bs_6S&9Bu zdXLlwO)r*h2CQ22|K@?d%Mcv&GVldGsdYv4k0a;$C6jW?xFbXtUX*AsF7c}g0 z-+XFMAxC-^9SdN&`nSODkHhZI;ErQa8(WZ@ejB-TLsJ;LF6Vf1WMdqb0X$isXG2X6 zuA@*Slco15^Yy%;5+9>aJ!EaYu!jj7-`h zr~XXK32^n$afP|gE4AIdAJI1!R9;uj?`lwf0{1%#k##E z;giZnWrUA6mXFF5_or2n_}QVd4&nJg#Ll7fX~N#4g;F9oWOb+;ToU2{Q?S1;TJ#q2 z>I1mH#Ce`SAYQr*DPz$FA`|O;vEf;X?sc=Xt_UwDj8&fVaX!SCNfTnh3se)kWG_dz zX(2V-&o|$|m9WGZ?S;2!-~AOdbtdtVirmmyV)8UQCCs^-SXIbS%Qm~0FIwu2Qc#y` zbx9tmtWSn}=o4DoRWD2GAab4U>V$XpCvnsp5*D&ywGi>7EkM`}0Ob$?zrpRoKXy|s z2&)n~b#vd$m{(bO4rhVqeqhv3l-;T+CkfaxegMn7+Nt_rFD5*s9?h;iWLGO9A-R$M z4%x>fHg>_of8~p~YJw-31HabkPHt++BJfiSflTLzyqqYl;f z3sq*9wvUh!SBprsv+a1~vKtwH-)^MLmZO-b9~24v9b%0E@SJVD`pgEc!;Lyu=r_HS zbS@{XNe)8O=oyRUOY}lk=IaR92VZ5bSeS)8bq0p{vs0FKp7H-b^1CX$4)_`>>7%i! zs|~F4oeVlW2#XuhJ96p@X>0y(ddZ3|KGp4WKR+PCY>(_2VJw^o1{(FNct-Y|Z!CPD z!8ht(<0(qfCVnIDBc2seNaX#D&|rBCh`gW4x#ImeNxXq&OnC2VvA&sPzZ?l##K+n% zud?@ukK(1S+>McPvY8ExrFqIfl2))F&T1AOLT_c3=q-)8NfyE->SL%}ynw8aox%pF zjTzg)F7jt7Ieu3rw+!KlCTF2eBcjTiYdozs&u?3bco5Ad$^D9aTm3fQ zCfnbhW=9eqXTRi19|F8Y_E#AT`w+l}2w+RCBZdBDght6@ggmG}3zz8PbiJqKk2zc5 z69JeUdyj7w5+L2)#fl>mVq>A$4NLuhWyDs;No<=R5$Hg#-be=_p^h|ukVHNANl_2NlG-fq(9vyC_1gh#c#vDJi~ZydG> zj|2Kt6ZRI;gzp@#2@mX`eFC&mX*Dc7d<~bT)o{Pm(ED&ToS&*8uFWH?KAb@fo+Wby zq=K36ph{2pg#)K0lZ8ISoO_q+p%vc+@y`%S2}WFsp9RL|5_t@lhgTjKiHXGEG#M2F zBcG_Q25nINKN4vM+jxZb+y&8PRl^?y(#ym~tN*%nXh5!PG71sVSv+$Fa)b|HL1?9H zuSzE3b3<+us z$)N~h%;{@E z$|H6C&Y{xML*nKcG&dbLg)OsjQ%qFW#wnByv|(qr|SW+RbQSQGt1h-zx0 zBe$5%fq{RBm!3|X?39hAj{J%*I@>3m5}$Mc1OC?b+`3H-WzqW_`IwXn2Ar5D+}u@R z*pMc;xg&VBWVFq~r=^KrEICmA&K|JM%VabMZRQMkI3NDOV{V37-@+Gh3BZ~EKMgtB z_-+<#f~Rf|dxPGY!cu!sS2-UeQ6*bhkGa+p*?XR`Z~*kOa?ooMuD?OTV$UG1l|@a~ zAl3x_m=D!X{w#6^%;viCs&G#!%nu$!^RFkC<4=)&L5@!pbK`9N^JIw)TlVYESf&u; z?zLf$Ruyns9K8Fx?ZASec zbuQ@k&r^YWQ-O#Tz+3j-{P1$?1{4nsscdw4u)&@a^v1^hozQvnhBF2)cw(cR&2PDS zted~qu>gAV0!LBuJ-b$97~U5=k-y|{luEp?=kd%o8g2q$2|2COEm09!=T4mO*|kmg z0*%CTQ9!F}{Y!iIgGP#giJLO*Hm_`VoIhHx5 z5c*h$Y6vBCsF=`Ogh1Q4usee`$At&d-r(XbI>dUVeJz5&<>6j5Y}sd&2flsiqTvF0 zzEoIW98>j|t@5Q&zTg33^X^yYuaI#|%m!jcWz6>{t9Or)%3Nmwy4eEs-ad1$Fjp*d zP-l-;kDSo%11rDBh2i3!0;Az05IK>n;hqKDJ(0I^LZ>iyGDFAl%nlXs(32Uxtlk_nsB*HmFH!W#uh1)OWY@ zlx~0@ZX8XJ>CESa9d4NYI6LVC(zK#XqI6L#u)o$#(3StGH(3wEEZ0Cs(Qi$PbDeKg&iT#yyz(V z>dhXBN?Ie<7P3EqRNo+J?c>B(K4J4@G&21}aV7gmaT(@ZwiI*7QONePEOy|q$BOlU z+wyQUe)yOdXIn+PvQUF`2cOOb+Tv2ZJm!%z#r=%s%}9kK%H!v7v9A`j7kZAOH6#xR zGa`Ayn^2@uj_m_Lpk1bFMdqZHpnS|oymeSa)AL%huJhlm69|~jNz`xv=4^h_!koPt zbApT2H6P2?6=Sr8a&zfpvtdgYtL|EDnBR~5!aVFa2ciobaIrkNI3zD5$(E>M@@h08 z%lpt6K_r43U>-Ghy9fD0!gg@8EmKAVi`R!=Cvt$b+OM)A+tk&v+dR^W{GAoquEww- zN)^A5;t>no!#8Q|yi#N{p>B_z9uLTFE7>d;Ugn3boQu`P(gL$`u{Irh_>d|c(-uO{ zUsXrH{{fZ@DSgQ{b()?{>E0bu_{{ajc(=?jhq*MO3i68SvN(v0IUjjkhUx%>y;jUE z^;8`5Hw!xO-P1Sf8A|BV48MiMswdB_+-HS!i+ib(O_{P^u zb#J!W-DKAVUD~A1(0V85Rb*=%&Bl$AgqhKe6_!_*1^*@OyFh&=5@%^XZ@T%GQ;H8k zbjvuQw|r2$0khr?RgaWzsi)Xj38qrtJNU{4C_9qfr0CQLye6;naM-bMCitrB{FWdt zcLD!iw;%46!LF3{_fNIIf4o8xzFsxHpi~*Tx&hPnOCM* z%=tDbWPx?JRd}$QvLxVWZ$vGVL@m=*AA=dC?V0nitIa>>W2fA>`bx2YoLcf!2Rb@` zmq_i+F9?|V-`U>{KE4$XxdC%0+$eeX+hT(HS;xrXCJxM#B`oQI;^GpN9Ud;TYh)gu)y1s_;?HGhih7te8S8oSE!Nb z0nE9`n#T8!KVsqLv%eAZ^tGO)M=-jc$oga>zF9-Y-~x^t(57TlW!B1Y!gwOrc*0T9 z0=FD<{*)|hD&Ooy27jdaNN5`8F;m6JWi^K_!f5zR@F?aqtzzV80>$Jr_@dR@0%mQI znSuAKeBWn4L1bFHoqmE2x5#<_N3xs8dx?PKvJB^aCK!dE6UFjM03|l}14t$kk z4ZGES?=lc99hT5xx4II4)QL;&J{DuFQf?jgA^81&kpBx6rsulbY- zakOO-SVfpByQw3gPI{pGh%M`2pLt$CK1D9f4V@{*pr@u3N+XF?YeY~W@8L~Xr4(l{|Y3cLR!mhNu zp`N=vE(a??$f=zn+s)DCTHmq{{HDt`Qf1VMC#D}s15!Sl@ClIc zL%nx9Yp7W7Vnrn|k{5(hY!;nfX;9R8p4~3DYS&b}GrMKfjSfTmo1&_V!mn^P%pGpk z#}V4PVDQ&}NyiWIEyO7EU$D|xcB88YLmYN)k3~DOlYGddVrahP$?XsgKUpNcI_C(eu z69sx1Fa~GZlx#(1R|E{2v-`u9f6#Jm>c)1B5hkr-3k$@=r>d%HI z5tdXLK5ig5yu3uV!`yy=q~WsaE2L(u9omKMn;qIwBOi^B2)r^`7H{Si3Y zh#7U>NDQ3NZTtw%-@)%{=aoDiYOCHv2sTdSU9hndX-18Nqea)rkGW37_$-=75HpgP zWYN)!1R;wCTd68KQ(++NJdW1{9QR7!{8chRKW_|DWASBvzYs4=aFQ>Hz>Q5Q+<+r{ zIfWZJaQs?y_to*zcPF;D7{?y;Yi2Bxl?!TX{mP=vJBG%0|0)N|R`keq1UQHi0Tt^~zI2Da|0s;~1%C6P-Lr=0 zIu;4@oac*tg00xY)RCAJH2<)>bvKN{WP$_#=Ye@Ko%-zl988&z0db zys_ckNCm)3e~A_A^(^Ax<5BD#bnawPMrXcreSq74XT7f07g>|-tN6@l5C>oIRF;f3 z?c(8L&jk2y7K`=%JMXfxz;}VI>#?V%dayOIHZ?e3^Yf_fq)r?_@x22hri+td`k;# zZwi{vbij5~3bwD`+yUDwl0~=hmIhnA&lbJ(b6}gpCM6BFh{u1?nGcoSYTA3Gw6_Do z&t>~7-i_ZNf(yBdXXwX|qbm<`NEA+Er4BjHPJnI=O1*)8YcKi z{C*3GsDVD{VG`rEf0SIk!_IgL48}AJ(qflQ{5?;-^k_jHa?dni$1x@g83-HXK_IoE2{Y!F#jHcBETU6VmMWE zW3uS%j(oCL65P}^%bvgjr$Z-Lndm9aNPV^-2Rk*DgIhq(Et(inM-;>Sd`;vf+o51{ zc?y9+SiCj_IIK|7nwtClKK!*k_y2z2-2biMr_BAoA2j!e0v#Jx)00J;{;Laq3arlk zDX^Lh%b$jyz{=T~Z?HZ0b+unG_W{k=4$QiS6<{SOZDpi<3(61D2*2lDIzABF{3X;($18q9$8UaBcU%M}f+Xvu?N_st z%pofSFK?eS#vL+eh(-ZLX#$j7tO<}yioW_2<}RH^8`n|n=moUMu3`pF>TG^T$ST+5 zx`6y`l$N4d&simJ`%><&aX@xJ zxj#xPciogjHCV61dewz*q|p;837Qovs+C%73OQ1WznJ2&Xn|v(<*sDWFv?EkB#UmN z+{12}HEitlp1q2$jQt6f^_I%0)tN&;NM)=jPpTDyt6s%1nZEBr>g&Ot0Q~>1Rpkda zq^e{>+wONeM&RH;2QQN1Jxu2rJGwb+KIGj2>WOvmJJdpNrc#Bv0RG4>#&>6a25CEP zp)v{(?l;31W_XMO7r*|34h%cow?nNLvX;92W*nEcnrYvu?nHJc>(ew}bnG;rIl-mE z5)&O;qy4jvEmM$n(R)v_g7pQzg*uQ!Nj#|-+mx5X?=@Y?^9GA0rRes zI+`=+HM^Iabm!=8)Hh2yYyyKWUER5yu8z=^{NuW6;j+0Z5cL%YqHbtn6|~Xkk~=*a zux*i=7PbPuHohtK)E4@OY-X&90$ptJje3_HFm}@~M?wtR-9UTV=Pgk}W4=^9mmXNp zuOeTu9)wqjJ_a=*3f?Cy`c5lJ_DqP`MOGS#_*myv^F>@_WY z|6go=C(rz_0Ys072F4~N%}>I=*$#|CXBdf~nF~MnORPGH)=h+&M4shal!7(0lCx@eN{0Y3M zu+$h3W!{gD;f(P6G#D+|(I^Zd1$ zLEy>BNpBg_%5c@Lm6@SYber=rsd4R6G~?@cTn626b+5DT5JxUwBI|aU}=S>>a1aoR$}mjb@AA+$$dD&3($l z1|(?qDq*HXdvgGAroVPXLF|$w7YfAkqQ2O13;bCVTopHE-~N}1n_Tl=_j7cc#l8w& zG+FfAwOFjw4ljVM%<|&##T=FAH9_;Wq2B&j71uvx`YTq1dZ5~jtmx&bSUdea9y5O6 zH?z57EidY?4J;_2Q!K~upV!EqPa|`UFpRQ0XVdrfb}y{OjJiLXAwb0Wwdn(RurzrY z{%9_XU^)sNxW089BV<27gGscd#6m4h~$?Umw(NjB>N zxEX{HzS^q`yk?8nR37scFD^hv#q#R>v23#<)F=D)9GS8C zbkJ*>JBn3pm3zYYD(9}IZLKuh2klZndTKw%WsO0b!APTig&rO;Zzu}>k4(prea!XV ziuO6j`kGZSfq6$XtTkW7Wt?}L6sil9g&0e%Ly+viz$WG-R3m^k34L1UlHHZGACT_2 zFPV-3LsQ?BZIxc)sd&L?@FQqRuBL;szh@GyPt8I|$SXhiawMd4uOU^rt3}}d z7DDqjMi620nzb-Y`V583frILs|7tpNlEaGk>aa1D4;{hj!UD)mLH|Ku0pIdcwo zp__`G_Z*!pT0TxTd_hAj29AKwM_ArQz2AU|z(FvKa2~HK47c6=PlDkuwHl=>05xFD z%3B1GodERp37YO=f7ZpWU=|i}wUsyUefyyR>x%}T)Z?PTN@+Ok*I@1f-)qNq!uPRf zzDf9|rbOg=sR4_I?$+!wGhiaqB7C(gv?mAQzXK?81F_?qzt5y#L%{|iZD}~#X0DF5 z7*ur>bIFk4n75)mB>N0n}7+R;kQ^VssR zy=wOwDQMQ%@OkQ837S=7h2!Y&<8Db`#Xgk(NT^Wa9F=%at(OG4;12T<_5N=^j}Z_) zRz0B0WLp^NaCoER>#X=GY4IKXQ?*t-nicF69dv#lZhe=`Y0}U5u3zb<#NW4mEnWgn zcnUI%X~oiG7@u+MgZGLenSC*Ao!TwhcP*hAU#50gFH_W8S|>lcOtjkOYH_ynyf3S& z2Jry`DOtHoWp%fh65)u|)v^Py*x0E;g+mCQ5HlTaf14VRL$tFdQuAjA?Tpm4@zWlu zd7G6b9;s1|NX@&%jB~AabBQxuP#2`P|Fl&5Pqf>wIfVeet@TEl4MmoZ#*KtOb*Tl6 zoJgLaZCXq-k=u49{WNWnVfEZ1Qs(pOR&+m_!GODfg}AAhv${~XuW?}-O<{f>j-A8 z^CaI|xhNpJY?s$~^5Q(N@x+*(fv5xV)nsqfm*-tj)swY1lW!z=;^OXno6JY=0$=x) z#*^JAM_nryncc}dEL*u$!=Itt?VdyB2#2b-+lpSH>GXY(|F#_!#Wt@j@^S-(GNVK(74ow%B@;AKsd*H~lj;qwTr<^Bm9ZnYnWEA|P-uytV_c z?E zC2yVZlDBkt8Nc15LDm)D1QoF|xE0JEyGdhqBkC#UOQy`1shRC0r~_k+@BTMW3$qO{ zyC5C2CBd!VHu`!U?1-6Z#w}wCcwAM?<9czNnalsB1w6(T^SF-9^DP&)Vw{?h=+$LCFi!Op z7^mjyqL4cjw)y7A1qj4XGfwrhFY^|%PYV>f{mHdNRuRem&0EN3E>KuZOerzN5>sFl zV4#B#i4X zuI*Lm=d#X5E`~rSA)~j102Ze*z6fv+-KND7l+aW@QY9gQIcuXyx0<&5Y zSx5riW#1_<>Mtir`D|C%RbFAlM#@XYobDv!K3_^|-<4GtI>)msr$CI1otKIv2xKZw z7F{tJ=>>4AKZ`s#4>amekwBD8Er|)7W(^(dH-iJfMfF4$D$dD8Ztvx?-Aj~TXx&PS65k)Y!liz#&3SY5J*S@X+xvtJ zf9)Q2*uVtH8!JjQM^-=qQIbN%IW2N?DDrfM+>khYf;BaKwoN>OI3*1>F4l~kOl zkUXIq#Vz7Qu&z)&s3&U+Dvv%X2+Bko>1oU<$;KyG3Yf{WM>PcXZvwyw$2QV$YK{+bXx0and5HZ15lQz+=spf2*04eW3%lJi)L0jJQgQv zhv@M4PzH2#_-`yHpVQ${_jl>=)#=%O+nKGi!#}w1^E=!JCE3@(8JlMiyCKeOq-j%Y z0_OjgGzm430sl)N=7R`h7KXNJi{IR!)PvH?yYvYjdh0X)P|_l)S&@6{BPFef;FMe% z>?74yJ|P4%%hfeM5`bKi7sO2<#~YUL0UF$RR|(P#WM(ffz-uby2RJ?ClXFCFw0mW| zl*)|=2=LGmDEDJBRUax@ELkF}YOGaV^v_>g`|`En@G)rn#c=q^L2$U7Ne&ze{x5Kt zj`{943=$^YQ7UEd5%Q2P!-(N;W|Z^U;S11-ZYAv6-S>B3v$} zfaug1#hV{M50B8Y1|jH9bs_`j6+fU!kf6B#wBl!SgPasyzg~*E*D9JruS3)V!W2@b<`J-LjD3-s zGKYGwRJ>h~H80t*oQj7H}!O?B{TM0i#Qe@`f_1;(9= ziKrZu^p?-dLuLoa&4$I&=UDYpExV2dx5~LGI#XO}u2#3uAETghtLTYaCL1%hx+WX9 zH&s-&8xe8i5a7}{ugQft(O@0g&K8cP`f95RJTTN^-M|^xKrFkFO>{P#Sin)hMf8#% zSB;B39A;Q}z8>?+#kRWLSlEw1`~CR=U(%EEPU;6z=ZjqU%dpJJGpul2EmzJ`ic<6~MVoY*>5y5Vb_db7fAz z9A4_HMF`Hh*5DrT(Gaa%pnOk@g>|?e#)_OxrJ(F&3*}90XqvamlU!9vH6gbzM&AjP@oj+w zAWd@Fqt+rY1ZoB3E`fy(r6zLq4xA z9*wZ-T{)^Ygri1GS-fG~fabhFH0N7|9L!%OD@^Aqe)ag3T){(Eri(0qkykI>D}kcH zKV}7zcQ?i&8&s|-&v$4U3ZY{4x&*Mnor1ON0QGL8d~}d8ou~Ov_{&4!09x?BB_f1} z94ydFgY&&#rN{yE^pEWt2{>T#3%$n_&p40)4ui4&2cnY}v;1o^5Hyu~f%zS|-RCg( zgnFy~kMJ^U)_$X5K7_!$-52>FGtpNS*wLY0%1O|iHA{W=oBhc(?pe&LWCV9`cU?+) zHV0U>#he3X?oWnJ_19hjD|$tmscnX>n$JkLdz8&##U3NZ+SfsOR?&WIVHOAeT^44! zsn(`EKO(5Yw8N%6Q-xeil6Rpz*XTe8<(V=--HXNF7ZaTYQc7Q|R84e_B&>-}cLM1| zr{8IvM8`AGB08rF(Gho)LUbU!5FKt8!yaAT1IbDep4&PI&$I&x&jk52w;g%O3q|XF(d(X)+?8ffhm*%*sVvd|yZIDUg?ueJ1-X zy0V~Rjj?c$;0_jCfPbOhEt(?=pl~cwy4lp>QtkzecV%(qptrpk!A+!~sUqjt1MI09 zQ@5ZG^3uX>p_OAlB&3YO;8rzTmWV@9nd?&@pfX-_2o{gY+Xt%vu|i$~W}9`az19`T zdJD+4uy(1+KWGvI$rAG7Np2$3y!Bod`-vneR?B|LzBIW?x6fNKv1Dp!TwJsujSbRD zA=4bOo&~ooRECu-jnHVS0-+Ho(={P9n!c0~Xwg=Gn#kze=G3H*$c46shFO66nN~ z3LM?uaRjpxnUXtnsXhp?QEfuHC?4HK=93sA=*8`=&kA&)8~5|HAfRz;qR@@!00wkp zi;x^3X7#_C8LFI^2Uuj|ddS8!Asat|>xOK|N^}UaQGueIVOpSm_}>yJ%KCvO8w*tK z<3bZQ*UR&F4520)za$WdGFg}D_>HmuP>e56BR(&swV&!ZkCMK(j7@2Vh%|u$^UGPa z;6-=J?!nv{`j$EdDXG_-1p7Ak28O)A5eg4ln=IO_uXf+6J`oXM`PhQc1kd~ngQJJH zg{~klX87~Z``zV}S7Wjk=wXbZQ`p9}Tf0eYR z6Or&^PH{eqeg7To`>%xWVRS5l9~i^KE=-_-jLR-`v&WqdMiW!ydEei*|y zxi$Dt@ZuwB;*%Y`_?koT;+MmVSL5eN^Wtkf6|0PevcV$X8jBZiGZxDHA!3uyyw)X= zzR1dVr6|mi8+}=?MrLO_LT3bOZ^~BhF$4Tr&xMYyY0BsA~`pdd*)f;j`C#R*#y-;j09Pd&=$fsIM*%8KU5@ z*GAzX76ymT)pSUk@lYgZu)P44?MDiKCkiVL8CLJY6hIIgGN@Bbg+M=c*RQCbKMW@| zm-Y3#-S{HdKLFB75*&SykBhQNxkw#})Br?XB#2s3FTMt>3Jzgun=BD_Fv z>gi$)q}<&>%IiEr%eM;{v^6%wT>MXpp%OLL*^OEv#C%2_-8I<+<8qSS+fp@8L|b-* zIo^u9iMU82gM+Q&m~y_Tqn@6u^6(O!elmg7Kq<_Pv|Zj43Kz!s_q~ z%oz`vtm|PKIYEe;=lNWCUX0_$m(V~1@woxy85MS-Lv(@gXFn2A1tc}*yGU$*DU+v6n z^#&hUD04(Nwch-wY#a(W;rDlSs|$7CRq4PZ^&`BJzEC|TX_0K!j%2xP7meLV>L`{l ztwpI6EuODpXJ}OUglrNw93pXCT2Wh>&B=g*Ko&D#L;+kH?AtKoiC&I@>+rywY~miq z_mG*2ljZUyne~-;g4)&1#rZc;&=JfC9ZfJ>g4vvnsm}>z*LMp!#7;ob18)ot2?b^^?SU zFxcSPgAvtns8rJj!^L3i(VA@;xz5DbNHe~|U<|beBZt;Z~S=7}n)-+KkvF}z->f!5S0f_W&~fFxLw(FFOPX~OG1I&68eW2N^+GTaU`#gZ#TrXk z52JoIagk^A;cmG7o2?YZq4DLt!+84~QS6h$((BdR-(%SqS@2Dys2Gkc_<91Ii4yBw z^A)tgY6MM=pH3`II>Bp>F2f%@88jzWF^U{o_h^nDkU+qPu_fg`uii$e6yL2|ljjHz zOSM{LaMOE5W*2h-u6haS9GsArzZIuaNWY9bo+YO_JSCA66tv(H{uVIFnm%Rzykbds z>jdasX=D}`v{$Roq&Ral+ezec9Kp=m9C8~^+*KliGB`yv9SaDd%Ms}sY7S9~EFwlM zSW3~8Lt+Q``U6Ws$b-t>fIXJ_R}d-8$WoZGJh<2NttS z_)uMg-c0S34WRi&JwhjY%d^1b*o0J2^4=Aqj{$8tAjQ6SW3#yv_>5K1sD>fRj31rgj z`O8Rl)hD-s>!%SVUG;LP)1D#aM16@;IxOhHKP8 z(_^bH{CUv2g^&o3nI2k#U}+ZZ>9M|Jda%t%7F|6&H9cCb{CYb=Zo3=`u%^d)riWBv zO%K_k3`p41L%a{x@d@+zV$9>2d~%hQJ~26ArCK}p-)({%W@g66F(N_-BJYm%!Poja z7X_9YYYhc6(1%F>DnJA#Ny6|`Ekt-a%Di%TJB zW&XeS+&hz*EF=>qO8vs~kh%BVbI(2JJ@0w<^PYkp24`hyBwX;k3VdE0>0Bce7wa%1&cb<%C?{X#ghIn#)J7MVWj& zi-=sZV{kmy;0#HZks)+4d7l?Sy6rR2{?+&%A=!5q%5S)WeT`&Q3=ZY2T}Y0e>l~3~ z{(BM7=S(*q#*cVN*hds=O%HsbAcJ~$sd{AnAdjB9Oq%^zJgMNS`euHY-)xX?c8zPa zyW?`{inMEe6l}I&WWlWad?X!VN?Rejtw3vTcr{{#8V=?Dgz{g<%h^#bNUb)=k6;@u z@R1#~3W+DT@5QB>S-Vw}?Z{)yGaym}A5F8|B)vm>)ZF=wC@oZbFICBA;-ka zz)H4eaVEvfYJ%ql_C+N{N&dI$ z+-CT-W%?)UPWs>_p`);waguSip+iqyMPFguHSzv6mYW70g}C zh1Zycy#{ln`G(jv*?z1C8i^!-VvN{ZG}` z=jg$^R3}LsN4XMbNJ(P4SZB353CF@!<|;C3bBx?bzBhCMx91lbm*yD5qlLfWjCVKkJ{>1Df)^BL+?K5D zWg*l`v;tDr7W2C>c|2SGaSi8+;^#jpu!z8z5;U|}+|2^^hY-YfB=$B;=0mKWyn^q{ z{2DNm^owR47vet=!&{k7T))Q{q;JT{WUbI&!TLD~7Ab|rg2|u!KlJ1nmR*Lm_d(#u zYO&pnpxMt##DL@-eZ8O==0W$;8TIbbGaC87l>c|}{~rF|XZpnYXt>b0Km)VRx&!x= zN@gKmn`*or-+=jIAY@_U94=-_^@YZyg=%ObbM(e{gcK+x8_h6}V>84UT* z1d9a-V6pTi!*`5@J3mC{7ff;OAB9cMniqGgg~IJ07G%~v==gsj4xqZ}Z#|>#wJh0o z)Gg-o=A%H@E2#S$G3NyrmYP4|g1+yhqx9YUCbxE^fnadMTEP{NSQ49FbLATI*EjVo z+Oq#~UecsUzTsA~5Ig%>F=aWuX`n~(%+S7&3Ke+bB}AKg_rE6sOdj75K)$&E1fOEPArMCL43<*?vEiT-Q#5*8fxA zezrrglB%|Af#M8pxe)g1%1r+iTHxlQoF|1SXe-5}=Rb;VI>p-9)vWvlP6UfmPo-9B z40XDn2@aJvO4S?w(VF3*+EX0LxS-GzxVbFDKis?t6Kimx3x&NZw$*}Qi7vNGbsBlQ ze4!a_HAbsB5l&%jC!{ae9I4t}$f8q1N~adxkTJZ*7!@ zyfgQhzo0Fmb#o_&a&{TxGnKdV8wq8B+cI&v9&Ij4DAQ+Nm6>DCmXho>3P_Nl%L$^v zN+~_L&JQW7Nq8aFNM%Bq)yN6$jcCiW>60SL8_j>t6W7$!W+swF1oP<66h{!!ThCC0 zQqK{BSt_yseJ%+P1JdSWko~~IvW!K!rsx$>UBKXT0D{FO?cG~LtO+w}Z<(!+I>;cj4kyY%WzUaT1;vU-lwFy zNI~FdB`vgtd}5X8p+;3;$rwb|5iQhSQY*1`)Af) zg?4f>V;Nhd?Vx_^mCfd_c)^&6=ZgSwd5vC{sb0GAOEUa9 z=y*4rKx&FEe;QNhmH_TprQbn8BL(gE7x0o$0aW@J15tW^CoYoM+vMwZ-lY2ap*e<+ z1{M>my4`oEc`JSsArk)6jcbWekT}&@b`b>PYA%iG3(aZ#+5{rj4b=m4-WT_4RVHWP z8p-LzQ61RVAQ~5Yg?IF5C?!d5C#@=5?1>@{|H)EkBgS?t{mt5 z`rX`^r{5^}zRhD)mw9K-80HDA&GBZxVUB7qM#UqJ^7J93QCxJ1K6AYu%BhzHJ>6{k zvaqA8LHIV$%$yQEyUqLxMG^}+UA%KMYjUW3kHoiUZ!{ag0(ky#ExJ{{LUW6sh-7Qa zGNbFO$bom)O-g@c3#Zo1gwK|BYbEI^j<1+CW^vtqL7F_dUEIatR3LCFQdW=hcO;ItZ*SRsrP)VTJ#aiyv#z;MMQ?73C zhH^8X(EFyggg-<&kbW7fIW$_2?&R8Iv`GF85`Y@5p6DBDBy8p{@`gOc#?%}PjnOd` zL)tUh2d9X&weGQJX&|%H|LG9FS?x zy(OI#vY=pN+49)+Zuw_&&5w`*<>c-vvBSm(ZA)_jW^+q>TRoy;VNdb}dYSWISxAm~}bDag*&JhHd zPeGs&d%Eo(Gjg#MSP!v&PvOB;C8V146bQWIgs9IO50i1XObi_}jF(YjSmL_DUf8PI z+yx8t%Bi^vZt}=^c*awnv6C?yuhy$J-hK*J@+{{FcS*6Q>Z08FQ$$d~49=-u=D4{s z#aJ4nYxK%VxeNXlIYl#eI12__)hlar=aV2KUOih?_fmbcUU>o4i7m<|>x2x~B`Z%C zU7(9(80~1#>8e>PQ3;xxGh0lDm8zLD6eX_0x{>lhc6kS%T)RV#R>1_Qvz8lnv&lp5 z+il+MI8AosF+3*MfOx(`un44=$ID3s{o8I$;_4^W1 zzSNJ7@eGPD^Y;8S%BO-Tidc)7?1mKru|sePn6J$T<+hnuVULlhG58>K{}63C8b*fM z%0qw}bG-DXy{}vC4U_iT-%S2~hp$|j{1xZ1F7~p#jp;JhUs0y<(jsF)-lWqf${S#Y zi=O{vT6@p!ZVyRr5V-X9AGjP2%~YUePD$B^gRtFqg5P8g5B0$DbU2B$$$5!Z7JtDF zas!RdP&9^Xtj+DulG-ZirY*rGVf|p3bzUK)ha*AJ3SdL;`n>W1xVT#nJi|%l8|ufi zdyPYHFU&L_MGLmh!SP{Z8^q3a%=8=0zt523HQM^~b8!R@;sgw6&o8b+QYAAZPUo!k z6NEh|7mP48R=i6F*t;CR)|jM&P(mN%AkUmk+X5wZ1bs53thHi`fJ}R>b*9IYV*Zh& zk)w8J75E_VdE{53E&4wl66A743)@D^(zrzIubioKT{d^%NwFlBbdp=d?*J%%$CDYZ z?_{n-hvBI>XOPsvEMH043b8uLI<1h`TqM=bjusv!tqA!PdZJ>HdQVSeX)#5Zd<1(X zjZS%sjp-nAv~Xh%mV{KL!=vCYN@52=nT#(8E%G&cs*^=N zL8-raq31PRyh1`iho97jdaf37{U`D?_nCeN)HkwPH*N$y=j8?#=8%R(HmTv*!}fXa zJ!)j$phsM}jO;1@`wbOr`D`(6E%4paP(d(Wi|@vU3WWL=-&GA2)Nk?CG*sLxzvnho zd_#Ue-%#;Q`7Lg!cr=UO5e*fO@oT)~cdeA|qmeULN>E?q^DCR=r*vhr{ES}NC_hK8 z6s;uM%TuP9kqJ{r^Y;H#I)`G~9GE^$e zd#ToQN9%f$@2ki6@mLSum>bSQ^6x8AN#Q*?yI8PE9Vui!PaqX=_l*Ft^8)AmddXmt z(dUe7iDW$jiHVbGyM5MS!`rpcacoh4`)b@44?kXj ziH1DjU~V(v4UHwIQ+X+8wZh7``Gz@{WwVVVtB%j_6e9`lr^b?Us&Fa=YlvVP)}ONM zkR?m9)T_p#g|Bg3yjU32r?D{HA%w1Bt@JHf9NaHtY&j&3@AfGKP=g&7cpeo2v5g(d zdzsDh-Sjd)a846eIEvn+NLzJSHqZ#2vWPPB=%c=lKO4S^butG6CHob2QjM^>yQxqY zJma3gU@>EA%X6R~vO!`L1JOc@{z2264dOVLwfwzEiWkMh?!8K(;mbZE{1}$)Y)GxMjgl)#B{c7?z2w5Q+Cp8*9c{R0J3?J z)4w?B^-zqD`vv>~JS4GF<{CNWhgrhBSz|owhHcNN5fjMEid@%-7DING&8G3y&iybP z>le#W-NF1->K9ZVIa`qFS!9)R^5~zZKfh6NR*BPae0-xkYvmw>6)t8X@Wy##pQ3_C z)QtE)Di~5KMe=}oAuI951q5>0x#i_tpTghK7WK*tm*2thsPZ8>qcq0Uc~=kSf1gLH zW$HIjA3v6Qr77_hb*M3<1<7NvBlq|CR;dS@OE9DOlX#|7}+?A$CocKZPRd?K4Vr2Z2&#M`C;bO zbSHG{uwX^x^b0~cZIXsZnq(t?tVQ!Jh=>;0m+2p6)VQKx_9z$K21H&N`U#-JMB5GtL)93-W8uyrX@b7Hz)(OJ*UCxJ1_;;V$GM#MtwU>woaKoQ7TI}l^Wde~dUTC*)mao1)N>(hg~f76hvz(W zHSYEuO)LIKT=n~keS`R$=l_{BlDB?hG$TSY&$!0zZXPVVtX}{j#uxi?#^=eVq7BW1 zBkxMF>}05cXbkoQkCD!KqB$i>TxYkDgL=`HW@r80t9&2S?>)|6*0|bVBwrm;aUtR- zk0W{I&r!f2)<0`T3Zfh3>x0&3U&RRMFjVAi`MmFZD*1Ey{yF3Ge3by>6g5^g(&oX= zRU6G&7qt&Fx*-t~GVthzaGe-?t=2QF*2Bk9B%Npf)aNp!=RyKp!gL{0L@|lxG#!dy zSz)e9U_w1D?le8eKgkAi#Pd05CJQN;|W`v&nh&;Pho9zxAI`y>aZ9znN`sMzdipp|MHd`w zcTkUJYYIn<^`x?-YP5y)>Unk5RaU3IWbM!=xJm$$4w`94ow|1j055*dW=7&&gOzExksr7)OrMZQKPNJ;@!YHch2)#0k^1 zufwOnr2zSAj#CdWr*B+`e~HBL72tfbD(KYRPTMp{VzhiOXAR5m*2Z;?`-?L|z zm%GpFt*>X-IDfm5k?VW5d8%6HAMMHBq*kPPEG{KPCA_6S*F=)D!b&>Yd=jy_dpXA0 zcyYTBbGUgS0ScjO4@WeuaKoEF3ZKDKGa#16(5RDcO%_e>q#uYe7o#>H#tf66-ixO9 zx2c>au4K{l2jGM)niiR>FGQjm24O1SM2A+m*oO3FAl99jI*}HYNOQPR?Se}MM}21z zB8}s2{+4fwd?`^r)d8H6WkxFb^lI9U37S*6Hugo%+pn}*rP{P5n{nKjMU0j&G*z z*c^X_>mKL$GS#L%$JcOUo|(|ZN$UDjndAH)vk)zvIGF$Q_%*ue{pZ+vs@V1o$K^Z| zEw7U6G4}Q6^h(EQuKlvte55&!d51ygnc5(^@Uw5i@gYc{2OUSr8=XvEak3(Gj>>y@6}rQRXd>1=a7ML-m_&9*zk- zQW17tHfZ;EOhQ{DthQFg+L~tdPukjd^M2bBecy@_AdAO2o2abz?q6t5pGr92V&vSI zf{ij2t-@%A8TT~NjK3rc4R|^5Bt(V-=0|y%pC*2&`#g1}+Gc(w!bKbeQ1%{#7`5)( z`=iDBGua%&LQm+5FR?4*Sd~d#8EJJT%j$}5cg2-bSGJTt7dcL=Z###`+)Ul+#&*3; z7#osA{rF7rnxOJ$Z*(_jR+Bdq&wS!OAVDr{XPWVBJb zStmzwZtL8V$Pt}&Imus)sq9^j_A}NuA08P~{~>+Fg6MSP_}XaqRjVJLk>TI%iMDvN zTeRka#^?Mm(essJ#WsI1BM#J|%-OML!;f1cbG^p<&4W;cuGLAmuSeI_k3Ut7cis4N zd}mnx5#wp|3+m-I0Ph>40#exzywQB@eBtSgW0EI$t|)2drb<4N{qM*_f({X|hA%xv zStP{8L-NoHE9ycQD#ME;$xMnRbWYhI&3iHP#Fy>?T_{|Wb81m{BvvM7BbI#7?-)xAgvdQnp`evHv!&?4r#{J+>LXANEbp!>cd`@oVEo zk{=cPJm(P~Vuj2aIbu~NR?RZ|0N8}Q{4N`9E66ar)k?~jD^lsy6 zYxsae`4gs&kHKJL9P9HCcWfA(%aD0T#w^vXagUOB3>o)m#$CZ0VQkl*kvMMuz2ODc zn7x#Tzm)QrCEg(~{Q7i32J3noGqYt&jo94Ov!@ZfEzq@>y)`LTCaPzQS7bpuV_Ii> zd0k-q1n9E;z$HAdOqX3qxMPU#7Sj;J)~)a{wH37L8Q-zE23~*d$oJ08{RI%vjrGyO zQ^gA%Sc6yMFaFnU$nQVAC53Mt|9tJG-}N>K1C|-UCbuuEOJ`lPU}4v23mQotlRHERJ*ZJh^^t@UyI4uA;-H3*RLjA??||Q zC*k_p_UjIQua17OZsFY?zY=y>%R}rWNj9GcPwRR<#a1H!E&2Qu`XXFHWbzZawq^3O zNht~`$TK}8u;#JI{aI3Vf3kB}T-(uC0pp6&uRGi<;(8 zGUKx`A^%RfIY!+W`QMeBchUHCBY%osc$jPZ8<)nu z@lN|UzGZ#mhw{_?H^RpIRt(yqG{IL1^hlNuK2-8SHXZOu%!U5)rQbUD-KJ>aq*5~(ZcsX9xR$7x$;%JksYzj% zhiakx-%~p>EU-7zkL@>qEqCVknFl5&J3zeKp~OKf+vAX$b3Slnn8%^&QnYrjDtfq$ zBBvA?6LY2d@b!*&zf53=L>RB<2XW@gHRe^P^mS(oaCj3Awnc?aveHSWtRO6NP~Ot8 zS7ObqOc%-d8f^I9{%6M66?|p=MhmauFy-8eg_Rbaos>k|rPlM5Eh5ba)Iz`7sdXustG+ofF;D zNcoO=-{-CHt)p(xjbUSENDuG*BY#`p%H6#>)8AbyYP{`oB>TEk7Wo1*T_ttNcroOM+?W=13QG3b?X(^eDBW8p9omC;7(SR1px;~3;(lYaE6d0 zRzU}7CEv0twNPzVxE?MjPl$o}@fU6Ssf7LVO%nGNo?$;137>+@@P$@E?0uL0+;Ci@ zUKjWf`*Myh-Fntr>6k*XZ0p^)+y#W74`W-KHxh#5Dc?p2#wk2i&^CW{VoW?w>Zqa~ z;g>-@vDrwUGs9cdT`a!emO&s%N0__OB{yV9*o*nv*nQFEaupe3IO-q~!Av+vr-_yR zh8i+jqS0SP&x=O=hcxWXXkoDoxikMXUc%r~X#S|Z)upjkJGT_G17Wb3!`fO{EFqS0 zmp&1`Gxs)pnBk)BGJfm%E#;R@c|=6=%a-0E`OV7k6_}^SzZkxQAq1lP{Q2fcRVX>L zA~!c}T6ja%IX5CR%)6TGDqdrcr}dwMyrD67eFvUraYKe`a;Whll^(0cAh?~22PCv+P2^DXr|~MLagwqy%Hl`$=^wAS zt;60{QXm^r|E% zIlBJ!#j0N9koKp;t-@Houft{fnOo7?wuKviO??+uK%5Ioml7L zg!07tKaZEw4@eDbt@-r$TAN!MTWbW?JHA9+p@c6v|qm)yY5C7%sg3%9Bj{Fe)7zfSf52A%*3^^ABoVmJtfMPWIf%E zZ23C~10u{sS}V{E800r3Xj+o_+*e$ zaW6A*0#phmZ`4IlLOpcGZ-f(p1jVd|Nm5j`-8WLNESIf2YRBFu|5%e7d691K z!_F=!;1Uvt(%#`j@q;Dm)^TJElB1{n53yZLS$E~*)cv$dMpXg9clC2zj7^psNc6H!h?M@i66o|g#XWVW~8`kRw&JTejctq)O6sr^56 zZlBl$$s0qwdXenEE(-6VO&bH+=UM4;R@${4I_9?HncS`CGocA{StrIPYc9p)_BU%O zGmjMlwC>znUFlAVWr^2no0}e#^plvHxG0v`iQtH2ZOrO?;(LkLv3Q)svhJ>9byN9n z{GASQK$iT;_6O;&@ti1+41f%H4b#yY(D~MDMMSGVrLCBzXwf$FwPRGwI<86#Jt9+D zX1SQZ2h;8kU0sT83IIuVq#4IDHJvr1q&nk!QKzWuI;@zA`kRZOw5@)o#8a?R#!v&H zf*{K9pu48i8jgdpRCFH73+Ht+lw=!ayUi@I9KCTJbd$A$DjHj-p@MGMyJen2cO_2oB4~(g#+ao{?4m9(!b!QZVCG0s zsjQkA6fvEGl*T0FPq%FMnp7+ouH`wvf{R)FpJR&cNfyRJz);)Wny{B&{3kX~FQbr5 zpD3&DP*DRnoA09wsU??8lo;z{5LS!VhYH82R|;3b)_rLB`Hyj7E?2KQe#JFiiA68j zYbP&!jj(VFp0Jhh5y%ShXO~Oc6rL@0`1Q#BYShqJeMN3<_{aK=mDI9@CREmh=$g&og#A zzDxU=eq#MCVIq{j2v%=4sMj2G72A*T=c}kHtq1dO0n~~=e~Am=3a_v~Ql~zmzV~IZ ze0Ag_@yYJPMKYZR2gT+l>#zoAx1`EhZLdSMF3qMR6=69^H!jZQ%n&+=liK{6Rmy?j zaNhM3i&#p+hZPI%M0v*GY1)5B)x2|vIvv;{9Wbm6nR(V%hNus8P1QCbx^!+^aH|_z zequS`&b0pb!tNf!O|j9LTBuL>-u78yJdHYZxM^4Ph8 zg}d10G;LlPu@BYI%?xu+k(4U8=TUm-QjR%A-+W43#82`B+Y~aO6&%<>YU(s)bIge39EmhsZRzzlrrZe zRb=CPJU)SsA%AYy4UF3Fnv2i|%HIJrH|U{2JwU9hEcG45`7WN^K}e$zaCfLWOSX*> zmVd2ySV93Aom3k|wa>+>S^J>vif2ki3&yi!8n{{;Y9m-INC2ih1SeJ}sCHk_aV)V| z3wCyC%b%iK_{EK|nTh>@JgJ1nRH^+&AIrD`Rj2w-^M)p7)m5_>^@NoL6zZXn48|Rr z95o*}Tu{W>6qd^F;1kF2AhKFBqT!!X;ticXk${UcaZMu+x4E2wpG&E+F?5+r9kKAV zd8OTeWJRnC>^qfLCF(nJK_HsxFOrw$`6$2E_fah=S7YSL{V^fSTOIhIwA=P zUf*}J-)nbFbyAKAG1i#>DO4z2BNd#DpTn3>eP`n+E+K~KH@r`-60J-kLf51;H8iF15Is^u{Q7@~9U1#-gWbJdxEd+*d|S!}YauJIwJ0FvTtl=;Pji%27(sq7b%3;5LwoCOn# zxo{Ob3nr87aD-0MvTpOtb*m6_@Pe<`%68xv|t z$5<=ryUn#M(=OJ3r@?hm0LKys4a)lmJ2Ka>%+yD{_D;HDTEV0;( z5holbSgUJGu_)3tX}&!<$(2{HsS8w2^q*{P*BFBt!<{YbXPe3^{5hc^P)29dkHOOF z;Hkt(M1EsFcoa=JzAZo^=1aFV5I)cPdP#sby}Egid+BW@GjO^g)OyJs7phlkOGqz~ zd-f*&NRFnE6on@oViBDxJ|SUTWN;~udZHWZCRC2Um2kU;s7%K^uiA>cwr1>F=Q7So zTBgoP!ot#GSy;f~tqO9m3u<~fPN|z}zoeQupCL51;3=tRccYLf^JVBYJmBUg5|C9> zsxs2a+>!W!_Me z6l<#(s*JTJH0(_CtPydj&Y&xv(BjPSYcfgdlOWdfWp)MMmDQmd7Wiyw30+}jPC-Vo z(6&cGGy0J$S}lEcEDuB8oy%GncyO@QF$H^9_{|?fLKw^*MHR*3_GC zkFXAl{XSi^hha{o2V&(4Qs!LNRL@VH+{>vYUZZI#KX?yY6yu!=lYKVuq2Eu~<^4-| z5}KgOCsR&lP@n%~${RbC*ZB{t3p^qA@(TYDiPm&B)^lT*o#G!Mv7YkCUHP!&7VzCr zWBgsx_LPbPWx5i9yj<1VlB%4^rkk%gt+Bqx8y;hA_&?Y$v=u;^D3D|*S`%h|nN`ti zNZxL@{wvzkt*Mpyc2}M}$InSK0F~nVf5eYBo8)IWh0F!K;%;UmIJL(5N@B=-luDzb zPV`%&=F1$d+V)Q+{+E%s;J&4iY!;u~alX%5d100y)f@xoh};lRKBLO`)Zp>N8z2Tfh!;KsZK@#7w>z{=!%9DI0}vo({{ z2mZrVVaVY<1)@!+k3r_K!>MY$btP0(4^(B~2o}xWJl$$#sM&~)EXp1teNo_M&f7c$ ztLLwTJ*g&q$c6V*9BF8R z)fGrezC~sU)>u;vp}J8G$>#h(<8HA}L+@}pPs4(iD^DmD5}@NV!xhcuYdVI)1@ zitSVFyPSn_#q#U5JN4L{>o)en?VWdiMDJNzA_48<(jB@XQ!}=NrWKekjgubi0v!GV za~e!yLx$`&3X8*78GnT0|6WxR9g9k3?Ul%=lCiQ>XgZZbs#2R&$~T9`D@9N;3fG>- zBr~7B-E3qfI9gPT&1N&`A@fjXOc@5-G50b%ygeF-xPvF?!9lw5svOQ>e5?o0XCiP| z{aZK82!@Ky=2_}UXPYsNZ$5tjw-YcEco-jp-ly7hOH=Oj(Eco|Fk*gXa$22(KS`12fFPIu)l&m{$1EM z*B~D54?|R*AikVC%~}mJ^uP@*2pl(T%m63mA7*|LJ=_+vFJztJO#Y&|>JUH(+M1tZ zE=-4rP)0S`jA}TosG2~FX~lxcfu$nE7uaDL+xXqcOFUL#8aw%I;ojsIv{d06nEa~S z%qRXK3xJ1#wKGz}_D(wBCEB!hJ#dFg<-Ot;gCI6v$Q4-v)4D?GQKAIRka>rd$kA^o zq;X+zjW;wWCs@I@+|PMKw~`fNu=d1M#^p8g|4fJv33EYjk?u-WQeMYkf_&^Vl#5Lr zRz!-I|D_@_q)Ffp$JEM6Vb?3E+1VtjWQ}oIG0l2NnMmpy=Q3oAVFm87t>P#{jN9ao zfFxeTS-!B=`kvFhfrcRW#7cy74inBWw~Ur=JN`%Fkg81QUALm} zp`%_5QLd2OT+r7;jSWJpvp4v$j!&sD>j4YatTGY%4>g|Q*^umK)Uz`4dY*ZMGcgdX z=ZEjitMCTrm4;hHK4(O3^=`LKkFg%pbjQz@nR)8j#97k3w9S9oo>>~cUNLYO_4V!C z`@PcrBlP}|Jq^zU$BGj(FE+eg0BO?=$MDZVy(|ri00@+lca$w@L$w17j@H(4rur3#7O>{P0ZeQnI>ujpw z8iINEZsrzJHv0%kaVog%Y&=ySk@szaQkJwLa~+4M^pP~bm~#pDXwEJB|Pif+ktH4gcjvq?^=)I&K(>E{gM${9GEzar3! zls7xar5P^>xt3Kc~f_;HmsHTiZ5>xQ9{z5RXVP=JRmK|TK0zSDp4w;B%o3;xRyIQKL|{E;4acJ2HNE3(s$ivt$BOmFSQjqm*Bp0z7b2@^hYh3wtNXW!PHQIg zP{}r8u2AbG?G9__x#R4$(^Smlux`9Fu|e)Nry==pBmtadjskGP42ivA2FM?u9J7_v z)T=S`$tuuPGk>w1O09pDrB+oc=CZMyoXbX>&kW^hW4Fl+wc0a;&@)`{g;|0JTHB`F zm4~6iU_|!AG&0PwS<;)G>H|9kEe$V?su$p(y4aN`8+S!Z+l8s;1Av2V0!izj%ODwlj|xDNs!I&OO*axCcRI}*cM ztfD8_BrnG*qg^_jO-tlclZI7?^jom|lrbJ*UuW!chy$)v3r$_3hnk8hF1L5gJcJBo zY^CY5?FTEPJSFYeXxP6iE3kL*TvWEg<3}^ip^&_(E#D^~y@O#kwHRB;<)H;bTj&Yj z)vP{gMw1i-CmkI*8W3dq^JMtJNrw@j6o@+fgRR@5DWROj5ToWUz)%C%uzqq zjU0ykOtkQ8+az3-orcub6|iG-WZs)8bb&(v5KLpRHgBVlGB+?*h9W^oAtKkJBnS~% zDj3_aRuDIlh~N)gQOf8lK?F`S0NpCslmQ3Ll_+5>MBb_jvsiu5TUBNr&Q-i0c~Tto zRh3Q-K59+)hMW=sx`nmD>#Hilb0GuDM4pftxlI|4Xs^BK3~{@>u<0>bdWHc^<*EZ1r@qs^u$-)jC|Y>L)zL>h+6OD|p?l z`_=S-J<-`(^S@oq>mv{utDP+Bso-a$<_KA|zXsT{Xm?7F8`jEXCNA23#o(SB7ey~{ zOF@=zunO0%SmQOwRNc@jb4c!bWs)$D{m;iDn@K!2>L7wJlBKm%8Oy-mM|DL3lpds9 zqqGk8z6>k%V}vG2O=!YCJW81hCSYMPueavnOfR;Zl`df8l@P6G%!fWwpByXYdgyK; z*E|W;PBXt@JsDw#m@7XX%F?x+15u`Q*|W|tQGJy?(nXRJ5Qvn;`y6&Q{en(e+cqmN z&h^9ehMK>%P~l9Sb7QidO=3dz8s+6t*39XP%x8htiYR4uRqrmi5jH<3urtSZ9T~G& zlG$@P=SYSWs#kAit3jJje5i(dQE1^b<0YIsnee*m2$HqMsmyU$ewcxA_PaJXutbcs z9*k^<20)%I;sg34Irln45@;#mM`NIT)hBPPC!scX6QXKkr6&ZFypC?Sagz zwl3(oEo_*u`L5$bCkc~E9=g~(#g4Y$eQ#It-aWjSyd_uQq#Z7^(?woao{j158GAr~JK|auVQf^_0I% zVp;w9&EBfbmia&*``U7)!nb~uO~kWqe55-kwaI3$Y_8mGdeujBk0AyHn=gjqt>yxZ zZIY^Fm%04kA4?`goMNF{bF}5TLL99+7su<|XVq~wKBag;;f3@LN91c58TNUM-N;3r zv71m22kWijZ2H8vpBCd)fk$!#?|onYjn^nVl9#mQE?V$#mNFZJG-EaUI>v7FNNl4~ zpb@7k+k~F;NEmBjtO=e!qnD!y1LRw1uJAXp zr|z*WVu+MYNSpO?_-*m8a$Q68P-WjM z8=MhdCi5i!tg=;7_S0CII*SHb3L5L#FmV?aIAV<^a!Tk#Q>kbe3TpX3ow&6k;?_)J z){2Q&D=_~-7wWG1}U5KS6=Dcv( zz63ECvG%LQpRfy;gw-XKgq`A-2#Pmur+J8k5C_(}x^^+ZH_w1S>Osd=*r)77vi=DZ z0zkj}JVC7QN^El|f1O0j5*L#*!8C zwW`g&Vdh=(9r9FD-c7Ss{Iiiirjl`9t-6(eBG-Cg%m{umOpjGI?Nn8kugcD_%BEUn zmHe-6tC~U|k|0uW_jupe>v5=03x$co?#^pQ}8(N&O*W&Z+wOFm1$PPRu zFewOpnCS=4$|VSVs2TW|0HQpW0|0(wiU&C5(uGpIoB-}4*!4G6K1d30 zzA(fbt-erYHQY^`df=RgK)CkvS~}*z2o;{QQ-t~aGymeq2)AO|R)7<{G^b{RJJ=XI z?9Eoso&kRnfG%Z?n|z1!z47urpTqpZVQ~z_Uhxvm^ObF{@q=g;e(GIIKunk>)$TR$ z(WG|Sz`){Jz6WS>Mo?_OpsIU^$P%Ia2jp2`A@!WqdJ$79ABZh5+K=Jy4s)8kK-5*p zF-yI3i+X1Q>-vf!nU&;dGWCt))GIFdhh&LPNbpeiN49!pn8(sk!da}?Hw$1HVp%N+ z*S`}VWBA;+)wSIh7=ONKDsuja|7iEpO!GoC%~*2!GeKqn3^|pM#ag zKE491+Rw-T*8cGwy!mZ;)B1RaueIMAjyr}9<}~ru+MaF4Kjl8Y#XYpu9dz78VSJVp ztdA1f1e}MgP}`M{AF?mH+u@;FmhYq$M=-)@;UnKu=GVb1z_E;{Pqe~;R0W+}@AaRd_o7W^QVX5j93GJE+BITjoW&ll19!PO{dVy>3w>zVTM%YM4DipH#n7ME-!Ki8)i`$ zA8V{1iN7_*$fUj$q^&PdkYK~kd<@?Wf8%egYnRitsj;px!Z~W7-&xpGN9|4@T(CRf zd1U%3WG>H6$6N}C(lDR<=~MsAsnzd;5tawsr-5~PP|&yop2z*Hi5Ow)J5GW$&OLw0UGlw@=vlCN?q`TT^nLwsVs3m3)6>eFq z2d8ZlQwSCibSV{Q+`@gEd6ET|IbGX8gx+@icYu9gM(kIb`hJ|1gyECx`$uRfY3ln{ zQb~dspIqP1OJCpDTXwTguI~Y?8fk+29iKGZHxM$GroO)^={-}znXcmg?VRqn$?=Ep z%1)sf9x-3PS0mdUC9p&MCL@FtjSyqQg7TKI?D&wQEN;}B-tpCmTslWLu05GpD#=ib zL)TOF&-o|RgwD@2C4w%{w$FEJQ_IcQuOB4W{>#@-D$Cq3>11Ve7^m{HuXmpsRnNA2 z0{f!=7wZ?7W%y1DEI#=-|5!bE?a7fb_B%rI)JeG#`eX+`Sb3elO3W01?Px#8AuJ9L zN$cK`a;1K6+Y&qaD9Xg`ywC>U95x>&Ku|pI$q>8^2tHs#5EB0mU^E&_>ZPO;5K9#h z|84`3J#07MfFg8mCn%Pit<>SsZC~9d4_{PZe8F9@xXf3kz<81ZV@VfaRJ?^rQ`xag zGvZLJ6_3$$@j_Vf3u*Eg#rAWGYcTXsNtqDshPSsVn~UR>Ha1mCR8><8o?zW*Dx;jZ ze3f>Ad<%QQO8?30UBVGnq#*|xGyNM}iWkZbuIo#R&6&89L4~lKi%NoUA4e_k_B~Z& z>~Zth1C*{Wsc|p8zT`sjQkDri5nXET`py7rnY zuU;cf-5dYXsy~SHhS8iGjXa+EA~}FJ_KO=&?oJ18O#0ZujUk^VZh#U?1wWd5#*gi< z#qq=21%6b-XYEAr<0Qe4F&2K*$fS-0KL+uo&qZ)UT8QM+xi2|Ch9N(Au>*!IeXBbR zxjWW`{|SX5v~&HUeUZlwV8Z+GY79rFS@h$P_Z0o8B_Ew`IKKBm3`bnbQrh$gKWgIz zIxFfX_{g^HEV|FtAm@V|V1OEihLoSIBqPL9)->tC=jM}ZpJa)GHZN2UVW za<#TU+A{kSr!6s5+b{lH`CdBk=dbu&1%Kph;)4W#KpUYrUxDJJhC{ct^C##}CmiaI z{zQFA^ykzL^ylO_{W<2j4p@|n{RR%z1r~Kde`bI3^rs^pbt%Ujx+{i92O`IO56|U) ziyU)_xbpi=j%jOICr-?&i2ol z@3W=fXSDa5u&-U7;H{>4qB^+a=Ipv)xhSUR_OjPXy-V2HbPvHM@lKqOO^n}}vwvVJSo!8x%W~edU&+v$P>Tz7JZ0tO)k7cY~jO*`|r)^x;-k23WKt^2V z4ic3Fv?Ag%Jw;yUDy@x!y~A5&2s2d#Mxbrxd~jXMEteg5$^wzN;N*d2oKVIv^M!wY z939sZmaG?n6?4=lLOCw~O@@cKtMKuYUGp(lYtqknEbVE|hOd>I8YS+iAyCx)5Ot*j=ql`M&O41%hM| zq@{vQQ&~v~2+`rPot_2y366IWjFo0MZhkd2IOfrXg9MJ-`izfmY(T*A-VXRUF99E& z%cih#*G9<0ErdjU*bhclLS|CI$S3h?_A?}*`$C6%v9|jT%QmbfX@{lpm(*Z6k52SI zEG>#ij&SEHy$#wC9MaAg`{UXE=g#eX+@i}*_jw(R539NRdWUt85?#I|nJ%x}oZ8H- zz+}=sbI!-pPnLUH18IQc2meSr9Lup=r$S9`q6-HJ9G~ekK0bts1T7JPAW=?8kuG<@ z$RDpw4U#9&iGGG;k90YXlYNKf3?gLG4$Jp~~1^NQdKVyYH~vjwqXUSl)=|DHW`|m`?OFR*H>D zSqwxzelm#=qbK*vv##iJVcc%vZr0k|OS8h8`z(%(!t>13-PJ)HNl84uC|NxIMN4WE z_g&QU_K9oGT>44aEYbIYaJwIwxJX48rOhh>be zI+rDh6LGqFpygfB;db8Voq3>S_|-q9oqW_SPi>;EpbPC2rO)gKGTb#CPA44iN7_v@ z8Ga!}qtGFA;UIxy-$_T!^Zh_NCj2fnjNFJq-M^6R($3HsANvkR2SZ3ZJNtHu2Ag^u zp#2QT82!~}c1?c|w0!^c*KJtzcT1o3x2w0Qc?unf{&sP){`ThYQ^WR`3EOI)B@P-) zx6@g4>;8sgA%g(l(+S5*QZxpAW9vZ!$G(R_JdNTC9PjRck14u0I$-4L-=v0-I-TfW zjO-;o_8pE*NULdwV^M2raLk|+{S3z#{WX%vZ@Vq+K+E?}H@r6e?Yn#VRdikEDFyYJ znEei6KejVZ9!To1x`$Jnr7P${`z-1GLV$a~_XCIH{RDcY8ICWkNDYpM(1n8pj(wNg zY6z|aj;WX-1n)Y8{dB;{3BO1Uk{dVlHza$Bk9~)ugCV3Hj^F-6YH+MaUhZFvjN2LX zWJ25T<^4^UtJkHSo^1VPYO}W*{kwl>FVW|8fb-Yi^YPf4w9m%}|C`!;jH3&mvH9pb zeH*j7AL!eWKT2&zeuO;QzcZ3HI@Y`O(f9edAE#;B`Az9#sm(_LojAzmqjzxcyZk;1 zB|Xh@=P!Po8q~kLs=uM$qy6N-<@Z0~J54hj5Bq$$ZZ_A}gJ{rn;dU>4W2C zxJ=Uw$8SBD8XR9(cF@4F@6v#iK>){ZfJ?m%&KJDvU_I%8kvaFL2FYfEKKdIYyQIGz z@v-l4+<@Sjb~s+~>(t;lfll;09Aoqs!r>w^PAErg!&F@NNawSz=y8JI_kiu$`H!lZ zOTnH^O0o_V*|r|a1EI*@`c`W5){I`?K5ze}_Uv^yQCR`$gk#Q6Q-k9Kx^R%dvG4Nm z?Sx)*!P)lbPZYfCK#@CO2c?E-FG;i!4T38$BjQr4UUf>Kld+2 z#%b;+DGzs^r@nK}5K3>F>BiyrrZ!7M=tBR_QaAE&I^kH26E)3nZ2W#|a9sV+K?BFW z(~XY_y+}LVcrTb5Bp1?&{>8|Cr@xOOyrvzF`VUisV;P<3XE?^>;ZKtO9uc=ksMvFO ze^$8f6nN;bQl%W76S>&(hCC1n_&y`Gd0L9@-9Arjh^R|H|#jxM@zkifC;6!=zxFH)o&0?4i<;21{EX-o~0yMNx_knBb#=n5zM4$IFojI_gY z^>q_qC}tq)J!-TD{jeRAw);`Q>sa7uVx zAUv_IX`}U&K6FtQ(jFXNyr4i|nOU$z68w@4>!+*d=GN~$$(KE@WsMv&8UL4J-MT6KlaFYzC zb4%8UIj>p{yOtb;a#{-qNm-!iww$wWg40QmHmg7n&f(;hg~i%5`@mt25j2 zGhZO~LFa&L8AM|vD95qG9AF#1nM36?>og=-R2v_ z#aMry)?DU^(rlKtqJT-~>v>vL*x4i*yh7)18=toz&*faTKG3o)a!ly_AC4axyZ=>W zcam)APz0u4b%v{&rpHFcRriZF7F3wY;Ue z>Rq?-p7VcNhHh+qJu9#&cj#UPlkCX1J<*K}z}2|hSEyB#`3lT+OXK~1_%^Zx?%t3~ zMn6*Jd4pAwGcns6tl$uaJL$5voImx|Azf1_P>ARG_S-!#5RlDX-jX3!7{2F6} zw!XS7lLX(|hH74#OBQ^MDaODXZZ1yX;`Qm0mM=z`Y!vv?BM|EF~=@*^us&S1XuGVKz3T{XNd zai=UT4s-AZ|5&n=yJ};XI%h%@nfP{4KL0&9tl9VAO^kSwucE;Z+}V?Ch@vt*5F#@n366&%7E!vQP&;v-pTp^1O0 zYg+9e;#@XT4{4kMI%q><$#%Lp2ee*Z#~)6GEqjyS6=jribNViBRu<3%Hx+e51(Rm* zG496C;m#e>>$!H-k=avQNj7MC;+`XSf2hk-clw*$QR>}g{npmytNTmlSijRH1vbyG zy2ARMvCaCu{$=ZTR(Fb`+bt#W!u)eh&9R%jAHIeQ+kSTnXY{E*yNz3dF!Cl^}PcIT2GaJAygjEEQJ z4W*hkwk0fNjmIxLmn@dYA0|Cs9lpVO{EBnQ40${U2(-VwCVam2nD1-ycvsTn*6<1P zSU$}mZ(KZ}reZ-nnG7Rqj&d zA~H&Sw{uCJRj#Y@Wp=sOx#V5W!=Rm7RsKV}{1WGq9ai~tRW8&-+PMlKTIDk+pF2;= zu6HhZ*eaVPW!FmCZ0C~iSY>mhY>JfmoJ*RlvV~H1mXzJ*Tym3?-BnW07Z`Kh*j5CG zyagk}ms2j_kmOao8Y;#C^GSD_Mr2TMy9>2~zX0Dc7NV(mvxG_A(dJIzDD32|qj6HrT zJk@#(QhMdFg_NiXWf%&uV9?|5%?c)#Pl9xJfl|LokeV=hz+#TlU+vD4ps zImQGS_9FMZaj%tE{yBfH9%{%y8jI(jf7aBqS0`xp%08>3VxqeGN{Uo=V^Ws8n%^RS zb6~H-d3P(M!&fTG=1`at8n$(gpQzebsJjoS5ZIgPY!VsAm{R&=F28!_twly_tC{m4 zX~8EJ>BgKk`_?y{(~NG;)Azg<*yIXMDGl6Omf;M&%sU$5L)@%JJ5oV?Rs&DBV9`iVtSZxuC~osaXkF%TZ)Y@7k>Q9Zs)U1T{M zFW@447Jo#C>LK&FIv&ux6dxysJxM_?-Fi^~G9 z@A2{#My!XX)S83QD&<(GoWRV|zpS6=C2Knbd$S&h=K6=|#*1b_1B%OFE>6INYD_F` zH3vVKiDBecJ%cY8Q(X0xWxz5z#U(fEGs~hA^;iye67%bln7=lqa}D}~;0b;j^F-_suJ5+m85Gq#DH^kKMpwb_u`bbDz`1c*F3u0N-K`QDu zhNyLy)W2W}S4+53cy$vqtU5SLU4U2DauL?~(`&ri_jQF=BFrU@Od(jj%Y)7LP;4W^ z%)9R5$6+=v6oasDL*NhU8~}fQ;1BA|0cX>F($17pqg6Nj#k>#Zbg}Gi&$E|YSoytgJ`g`$b{UiubO)nX4Z4-587Cd{4aI^j5*&VZOJZphL z#AUtSlQ>M#2aViFnq@|GNPKtL!fSPE4;+Y|-z138cXP`&EAM|6b7@ z4^E5!7q@N_hIZh=T1+Xql#4ha>%mO?;nam4tB}dGC+s+BETy zR6`C9CaybxU#a2O8_<`u;MX@1-S&%Lr^WQ&n-c9Ty&-7_8-9HXHs~v7_JZgBT$E$W z|BGL#XP*1YRBBoNU*W!K)q9&^rr=diJa>s@gTC%U#dBMx_b1PN_u38^+L7m8V-vtX zUNyjT8}GpCFX4gz2jft;5}=Y6nz)z+xnG*Nb%Kp@Pq7qJ67vo=nmC~6_Fm8ZDhv?( zN`wCwB`XoXI{ANpe~yh`r$CP5_%&d2b~dIE?|d?_>rvnRqA+O7|BG#*XWsjRNz_uj z_pfl9^zz=}h+^PZkN)2(kOTiOimv#7yXC#3AVDPH`7Xv96*o?o9xEzAFVCRb_IgO|Wvd%=q*2>-+X z%kaeii`drn-lKHzVi$UD5=HF5i;ua~M%0@o_X$x4c=2b=|9e@QXykfC<0Q=M$cy*! zB}F4Y^7aY!4koR5K;}zT=DQRk2(3(m{}=2@#IsKR->Y>S&zdhzz_S5cbnpDXOjD0M zSciAm{$J5_d*s25aa;5S=ck(o@4HChRZq6)_ojdp__RD_+`+_k z2k~6#FG^M-es%KyJ{*(jvdR+h zYry}Tn*SG8)}y}rMPbmE{}6kYNE zcFTLyVRPPs5g-XuJMiA0!kZQEy&emEoDlXNQ4ewsJYWk<)fPAzgh&gGyoiOFgn1qH z-j|QDQSYB6eL}s1i4zatS*m#U2Gln#c=i^deEY?-iO1V`_KNE>f@hzC9$YjUX4zBj z$ulsX+WueBhzdnXqmjAbitF-dsC2-eX@Zt$)fgJdM8J_rmkL^wmP6sb`fqzMu z+JP76o?#>ES(SZ4)B#@nS@Zvb2Wg>^>k*BUFs~yozU2fP_3r*m&`6_UdX5~W(y9kq zYu(0EZqE%+f=ys3&xoOAk(!<>)n@a~qeJRU56< zO|Mw1a;z4b7?o8R)XM6#z|O(Cp}DwdDdWUOl9p?dN=x{xIERG9q8)-TnBKVe{dkq|2X)swYIu>yW4oK6Kl4p!Lz0pV&KhgtzqGMj26xC z*sS?E-vz>&AppytX2oiI-e`R*yLolX&aBX|f~-yMlb+S;S93t#YOVPx+8tA zx&GbEme(Eit%I}R{+dgexQBK%SLEl_V>Myo)jYv12fi9p%bK1ON#{A=WuXZjiJWuU>bh1%=IXLH)w#z$tA!?) zLE<>7wsO8xYhH7DX3I`T&fu(8=PE_zoU1m~1#>+j6$z>1^N|O?e)Zt2ZK6IdEzpq;I(e!2As0TWpnd z|NB{6KXIK)`Lnz!`?G4g^JjU|>CYPIS8D#h0eJnl!b|)E%w8Y;Sv9slOID@wXUQtG zB#eIYXAShVfBb|4aQ(jx*EnB}`Lpm?r|8eB!PI++?a$JcLrcUO&z?8*?!8)krAM#U z5BqMF@507AFs_*YabUjMy{iLw*e9>?|H<{0lK)E<+10lHs}oV|(&`Q>rs4(r)`5D# z_B)3IV~uw0*BqEvo3Rhz@W6WQ&O@ID+LUbn>L9%J>@SmL+U_s&eA521f&TWdKXL%R z1Mp4sPq*VkYW^i56UqJ;S$UZ1`5))Z+ZQoTH)}YxUrC z(sIvY%j}#YJ-Dz~yHpRnUFk>ePBtSwCxpq;!S#@`N7!P!RLO@{t z-&fT=)00e+nUFwm$>)>l>gww1s#mYR_1>#jRn2~RkkZ#9n%%Lk{fFhg{>JP>Wp%z- zS6}2Y(UL|-1!qW#Y=QSsnMIOZ>r%v9I-2HS6Pc{cv=;UV%X~U7vrxkdy?4(+|4P5# zWGcz73sdqpyQ1WqHlghI-K}i^S7u4dR|ZMft^y}MV3r~Gz3y4EKzh1 zgu7az!)*_#lcdB*M3y>KwDa$EHjmDh)A+r%!rhs-@taY6hc`iCWvv`*cY_Iu==jr` zrd51{7>91k6B)zlwQwr}+L+O_030zHEnFp95K5)_J-3(vFTyI(A-TD~qMI#K)pKH> zWIyfaQzd2~tE|Yf;=GfezTH7}EKb6Ivcvrdxl7_gt7K8SM4P)f#a2~p!P8WPX)#@K z2L2^PIv6J|o=izKwgvyf#nRl8WrGzU+7YiGFW*HqGpNp4M^RZFW4-EQ)@1qV2e-YmgZt<9GK!Pn1pR%pqRYY zb;W^xy-X%2;^X7@#v@&-nI5om7={oQ43xuv%7yp!GP$9@gnT_ve%I3`j7>ClNv@}9 z9ZPT!WoaO~icoFpP%5)la!G+Si30YL6o`~DEH+$RpbV1YCXr74>fM8W$@MISu_;0b zDO#nijUw%1QKX$7McSMw(k4Zb_RCF?(_uvvX&;Ot?c^xZj*22}ViajVekXD|EQ=y- zMHFc#M3HuQ6lqOSr2WUn$my^&inL`>q%DdfttE=I%}tTlZBrC!pNb-_97S3winM1$ zk#^69HtFC{2w?|S+mpPHZa(M_fpY738c)jSr^ZOiekW{zX4g|oV@;+*<@3{^Bg3{Q z_f>8fu3r1eLBD%KO8KG;lRQ9~G)hvosM##e!YzP++eslKPw+EJZ^?gN-+8@Eh%(|Z zjRtB4FE<+*T3~kh{3H{ZB{34B0@^@;JeYZll^bQ2ln*7PxB6WpRsRBvGqI8z?wO5} zYbb8WHW{{LuFn@qp15LdY%#B;JYl<#Ey?4?i`R+Qi{mBF%a+Lp{eEfjS5Kj!k`h1R z-|;3X9j4XFhe074oRkk7$~}n=CBqJKT>CMKpcEwMr+?{C`U>M~C1q@iwR(?38Bz!m zC|P)zgBnP3msw!7_;VFv)$v3J#WN3KWvBX4!$E(c(%^9anIi1U`_}5s>O(+K z4AzQ=)gpb9y6nS)@LYM)Le;b@H=#16SVsDVI7z%koH*&`Hd-~18E}Y9|gPgHVNB5a#6W1>mL{j&_TMcYs{tw z3Jem%s~+@puDGQ_7F!ZY%vfH(u0^N%5+l;l7|Z$A5uUh#aS2R5INt94i^*~>Dcckl za5cxunXcv-XK&X^84t|zu>ADeWoDauG2ObF{O)RIh_B{`_-Zn^OYW;Nv6MS}?a11& zGSZ1}Fv%f8TG9N9YbE{02#*H{>R;S7@gr+9#5lQE=0Io6GTqKZctSdcQ;-_PMA(c> z>9x!ZMf!%;qFg_cT$$jN{Z2cn2^s!VE}PNIRK6(5Ub!;v{8! zBFXh>sssI1K|oS=LL>2?(g*KImGBHe4l>k%1g@BKvD%CSoCj5J#r}U;+vL8IzpmO`y|tp&`3-`2l;P_=Jb&qD_%J;| z{CBiXu)nF=oRcQ+6SL|hPqAMT^0zsLVF$rD>;zL^6@z5|4a?cQtYk=}$GYjxle^2| z>3`!Zai*Lb=bj`9tLr6~n&R5ENUU~>d z3{x_!uEf=R)&hPUVIxb(Nb$t)?>dLy_-^KauUD|Q^Iu0kvt4;435I>KJSSO%C~$7W zJ2bmMz!~0{qkjuFE~*OV6)xVjuVw;aoMc=>TP1y2BG30 znk%0Idl3*{`^+Q0B39JFsqPiwv9$!ls;*xqUFa*4l+bTF6s7!{M@U)kJW z7RtR-_SStXJYMfhc-`!a6|1+|$bU;zHn_Yo@;NTASsvor-&-EUk`ENicTW-b)_*Gs zkHh&@1i`bmIpda@eJ72q^$p0++6vYqR(Py#WF5g3#I^`rHjUlqsDw}O@ChFNiSV#& zNn*l+1rE)f{T*u{X)en2)y|je8K_9C6#MEV_pFS z*HegtF^hW}eHQ^j<%;b>B-g@CRsImtGr0 z!1H6)9}wgZx10?2bn_K5&T=S5i? zoaa-WBxQg)XxTwOfo+jc^FHpYcd9Xn$=VsjQ)<4)YN_oW*YFg&wA_IVcvJvX`-q04 zCwP!a2FD=}KKx2c9=s1R#}^MWy`@g=XW>?@6@I^e5$Pg8hjLscPyE0?#F5s)!tsXi z{wIU+UmL>zG=z5;!cB(o+lKIKhVY*a;olj;9zE<4x90Son;@*NbE#=-J>s8ohG=)= zaknOLcllaOCbCiod-SR_RH`I; zPtj<4UaZ|;waS{r-?&PP8L?{DsXS(c7IV6%=zO83u4Gs}hOgdp2mAW0IE@i{Luntx z539$rFy~OAW}7E>jpyn=xtfQ}>FwG-WKJBl90D+*31jMA>g6q(G1#Ep6mlpZ+ub)M z+1)de?e5YP5)d$Q+yQC)J6Lux`W&!(FeUBZV0Rbnv3tgnTBHxDPd zU!wJJMKBqpwdE2MQuD4W?=<)t98cx_8)jUOr}D-hXXPCS2Z!T{zJJCHZjULitM+h* z0P%C!D!aeHK#K@5B9b!yapmz>=G`z39&dEM>^Lm*lA7a>&YPDXr82X*49Pvyl6?Jm zww@kR1$oxOFU~!gX0JE<)4!G~o1B>q)--dYb@*V26B6c#u^_Yw+A_VGlD<8?N&OgJ zD@p^23KK|Fm`tLAc*~?))~fk09Q0$l_H!w7Mw0VVNy$s(@6v0=T=9VA%<@zpM1GLE ze6RRjY`XkSK8;@SFifTn&(9ivNeg%LlH4;SYt;-(HD-5Fn7pK_v6--PRE$R|TXlWr zj1=KPE5Z=mT2J7PhJDmp{VrxbB~L$0p5|Gk*bT0KF2eLu+%;8smYhVvH4ZN;8(__- z=nHWf)>EOv2NJNrZ+SqznT)DM^m8u#ob1|f7Ap4~hU=m7j#>oUzHcgpB#gAa8)3SZ z2S}c=AoM%x@8DkP8zZ^$l0oylWJPMOY!al+?t(PmCGHt%-aGM4dZ8Cy818%5n9yA? zys~M2Z&yKT+`bQR18X=6c`v@|9mU>Ck#ouq43#e~KQK&ADL*hmKB@dbnovm^0A5P; z4&Z?}Z#)l}y$7j21*s|C|MEbLcQ*o(dqyfqoZ&7_bI%xskb@c8C1n9t_s?)xGwx1x z;vA(d>Vt0_^jD9~1lb+J>W#MS&1EwsWenEZB<2b=arW~}fCpWPtG`}0zKu@HQz$!*mpt+8!Yd6{I( zsvyNd&q5iS7~BCOB;!*>oTlY~+X2sC{ou*gnFkmN)!@8TS#!wmug@9= z+^d8N8)CqP4!{VYN?rXjRZ^(<0RT|Gzyjp@BXSd#7g&HO6*MEpAdBYOSb!9G z0;_xJ=NI&oNt)cuODIQJ^>g@CdKKK1FUY(I5po~9@}Bz2Uw~lq)GMCg zpPz#_U2hVl%t69buEJNv%!?OZBf2m1*+CHRQpD)_#KWuHw_F|g8=gga*evE!7D_^8 ztp<5JMRx*+yjZ07PQc^pyv&>wIU{GNJS=CJd{)i~d0-9zkER?M;1Mh$5a%7n17`2J zJdolY!UHj0=5^q{gyG$cR1{Z-ynU#+-uPzc0N&;?&cWVKiI8A}ewnO+g$go*%HF~vzM)~gOVX+a?6T z3aV0gIqeUBqPC1yPWuunK{z?B8t?--?X!vyIjt3g3KiENVSe=nhJd*UiykY3Ks&qv zf)E&x)$%Oxa+5SSHwbFiYl0eO!v(dIs56tG_C0k?3OvCB@+|~$#q?tk)V|fg&iV|H ztb~y6Gzc=jiDG%PK~mfE65_B6R2WGOViA|r*c)6_+hj}`UR0Y)xRs8w;B?_M5A@qWz%G2Sl`2qUkxf+T?;>EjnM zRRGWg@e763TW#6zg`iS#Cs1jlTKTKi-~nIGfWTG&fvriNXN0=Ic3mOD+8|vD#L=hf zC1G>b#XwX*mjo;S24HF-p)J%Tw8SVRv;k1S!od?%ng0n1Ej-?EZ4k;~<_jdCJCh88 znKy@|pUgXwoM{vb6;IO^NlS!InZBJVcQ8DY%Ba4AJ_gwEzJYEV>JVK)f(wx2UyD0J zj@yt>M~(u7J3x+hw7g&7?M{KmWV}d_@z^hQ@F;||*%CZ%A!um_JZ5ne(Dl3sz(d6w z-c0^lJK)hR${qucKRq7+4+3gPG>|m5YC;XvJqloW+ng;^Cc#Uy8vHRFzCuFnmH zKIc0Nnw{jQ84RufDv7o#%sucMKi(sKuLXPv6^{_kbs}f@sE6hp4nkfAP6YM6aV^l~ z4vr>a3>}0Qkytife=RJwgte;NkF-jI?~#avgyTF>2R_m_s3{bU#Kpm(wK}UxEc*MXOz||_Q)D<%U=^gcafDROao4ub$ zq0oH{J_#c+g+;YxNDEYpg`!6|in_Ek+8pOl)+NOc!NY*g*De-b92FK`2%UzokkF}x z45nGx&zaki40avf)nzaV;SOZ5wzM}A?~NuHSO&f2w?YjrvUaUaHxgUrCHgJKwkG3kT(bFF8~{|3Tmx=tFlp0EGoCZo;mPVc>n ztT^tN5n{$7vZ1iRlRN;IVi=5m-ok4143ZP>%z$OWhXL#z)r{F2-z_*aVZXs_WLttr zyU`d#6MS1}g6~pHsCoZ^Z}3;R-RK=-((rbpRD9V>Wh=2|zbmKH+e76G=rT+`jV>eP z{&Y!m-b=!fPbQnU?=G?!`KI@tk?Na*V2tl($z6(hz0wT#f;4w2=JiS)K0D3IHRL&T z=_A|(-K<3Uw18=*rb)f!F~h#(+C1F?4C~O_!nR&zF6>@G_3F|V9sO`ny|R*6Adw$h z5iL5Iz-N@PXs*@7S%{DUc4HIL1yID5M&IAMWGp@wnS|?`p=uHO=hv)%hB3$d$oglb z=9sg-RNQjs1J+78d)dC8s0klutwg8BbfOb@+jAjh9V!XAAOA;qU%SJ-mNdv1GE}} zI`cgGnMpr}nXgZgiaK)zR2J`Vkdkh4s&P||n-bT8EI#!mVd`rJMhV{>HMNp|pA?_g z3KC5^K|d;VU+J@B-s?Qv26Dl~*L%Jd>eHCWAqDTYuo=)?yr}dtPJH#^6JH~do&ktZ zlb2N@W;e=K5D-RW{KANgUl@_`3nTJhsLnL$|7RYEV*o;s;QbY1Y`qtxvI-J1@U>>{ zi#1KjeWf-9=9?MRlKSfNUxM#?VunOM`6V*|5o!vuIsg&O@(@yEdVj%2Z2AJ zv$9FkQ5?TxI?AQqn^;8qkf8ghWI*c$B_uiupFX6By zsA9A??lX&L#N&R$A33hjLeduF{=X5WkNYd{j5E3UnD2cO@oaQ|9RV89ONO;Oy0@iL zJcrjiHMIW*FH*NpN5AAldzlhuXn!99coz@tWVPr)L%Zw2wt8k8Lwi1k_7>y$`H0fg zeCv^o=L_Jib6k$+o$qVqG_pqA*KYhh?`vn^trmT)7ozmO=7A#}iDz1W6KawIBDQ-h zKo;I}>%fOLv>KgcQ}r@#=#)#X7xFDOq7bo{;(gu^Y5gC@TcP3;J<#sN?CJ@3Lj$RA2FcbXG=lmjhmoxvd`Jv6+6}U1+>orIbDqFuoUy53`J_~O#*?I&5MX9n03Q5SWo{{TvU(d1-kYL4x;D1ek2?<}oqeas=T2 z)=IXX5mvSyXOyiap=PWmSBHX#VM^6P0CIM#Db;Y`5j3pmqV+~iw7zM+CR$I7LbUz_ zW`Gl-HG`LM*bI& z;k~fk;T@+8VtBuhdZ$ICGY4BbJ;1uD8{H&re20vU6CVP`PpJ4Lj#XaKTE;%B%f|In zF%x`Tj_cU#3j3W8Wcwfnt`vuVoa<&*>iKqAy^B-VM)S`$@X2KRX*&C4vW+w47{lI} z-Tj;@Wc=5+_B89eddB$r(IC-}@9}AJ#v-+$d;~~6`5h{%@t;=%PW1-D8VTOr&y8iF zutf#_f{Ve#b4}#BnpPV%387@1}XE1)_d`b8<`}*KF#TSR)(7isX zeNW^;R0#fc1wDisF>6%{jTG7Sqyu7{fDVXZ0y-c@3Fv?rBu+GOlZ=6rSui4id z*wRKT@$#L>_xPj(`C=q$yDrR6#GFfm=rENpN;NrgvqgPmVQ_T^zoalrW*OW@K=Am-t;Vm7xH=PF1cH=EXr;G8$n#Ml~IpBd_e z=$?lS9Q37?I2kqlZi<8 zkO=nZ$V1F$hP4wP_0UqZd*1+k+&I;1hYZMdY_==5NvOCSF_JPrF|~wXL zPM+G5Hb>l~H^WFq&D>#=jzYptHt7pfS{9o(DI9Ae+!iGAh76OkgFe_FCWG#3uvc$u zS@R=qu$M7y7*T_{kg$^t)_iNrVjrzO*bY`so2Rvth%M;zvAyMkP2sWfbrv0J>lj!* zpAH_U<-is=ghc2+-okk@8mNqi1uCLu`WQMankl!XUuHWc)~Ys;wkX!TIsNADZ=sGc zGOrazl0B?7Mm{m;cxuWl_~Jy=lmn5l>zeYYpkoKv_?>(_HPj>J5jNCxB<#9|>Q2do zpApATts~jdEY#R>cp4M=f?igk5>>!M;>WvM&ciY>5J-V@;6l$vH4dBnn;~*gUtJDL z^4&l}kajePNya9cA_+jc5sHe}VY#Msu3UNag&g-?_}KwQ;?6y4{6#CxrxRp!~!T z%3s5ZbTrDNm+WZLAUM|0=+R1Vx?xsJneD0YvH(q>M5#CZIH9HR6JBPEWJemVHtmN> z&`C+`u2zNV9?`i2dVA4hLuKTyqqj1?tLg2AMBhnzAHKe2VU7vC=L4m>i{7WVs^XFI z_Yh3{b&}o>jq4Hg?me@mob#vfcv8ipyF<5#98O-G+m+Hw*Nd4QV96iuJdS96B{Y?; zlN66StuMXfIHL7-C>uSQ)<-0F-VGbrNLwi*G?_l5D``SDDDriQ^y;#w`Dq7WF||s}aEqg=L~#KEb7FT#jXLDId_D!o_LKAnYA-(?P%b z(rD(zdzS9?+*{kG)Y-?iAkDN87UVR4+fr+=Ec+%#QkG!)*)RhgLD?U$qwJ@^BHi#BFTsp&RhE$Vt zjZ4fkCbqH&VH|d2@~-Fc2^3z5 zAACBgJYyy{#-?pk#iSLOJTUp{TVI-hw|gTAgM^GA$S^eTo}YHx`BJo0=iB*O=mRI(`FLpOjZm;U z-_ExK4NkQ4@zBntIY-jYi=d;NXy@ahowr_lB<=j0TTZm|@i9LC4HMd($L&|4RGjF~ zJ*Yp^x&*9g&_(VCjUsoIbkL7yy3kFV6+;}4T4gxC^!*}s86T@jcEyOc1obT2t zCY87#hYNfqU28%78U6+n#D9%23GR4fy5S8bivOL9;+v2=6UBdl029S=v`;bC;>Vz1 z=}xQ;xi@B{vj{SG91;Y?@vHFkGX8XwbENh(Ad#O_;!-CdMURlmxvWpJd3!uDwfM+* z;xB*?0Kf^JU>x();EC8H>W;F^Gs}ab_lSky(gooaw z@EGBt7wI}yzDdk#kT1x&Q9dK*R-uBd?>SS1N)q_fx2qpsg*}MKVMcx6V(dAxNUYwW zK4V45nREMnGjr~cZ_2q#F3P!E9-cExPR=Qn`{y|20&7;Ib3*!d-#^qHm(orpjba+k zpC|Q$1bg2q#h$9v)v57f#d-?5vpttGOhV-c2q}2Ew#1#kD}8TO{^yi&9A!L=LcJ)|t08~a2w$>T z@h%Gv^YvHiwyEsnc#>jQe!$tB)%D^<4NE_B3W1Wv=U1=y#paK!rALiRKNB9S#fh5E zILuz1-eCLLt~4?0Jvm;?dfyolKVPKibL5VdB*LsDGhdIv-&lr z^*}(XbSzQihB|KyO6DwfC{q&C_foM(Ba>j3SmD95luxlMgA0{)E7Pc`OH+AK2P*=V zG=U1*UyS`h%-&bF#uw`naP*=BD~joqMArhzBs{bjA$-J2`)FegwrAXz`9e)Ui{vTX z<(jt3ROp#%i4j+j9!t|yDe8}x9rRb$IwhNuzYE*F$X8K80;{fxnu1<5XS~gv;2UJ9 z?w3?oGwO;WWtU3M2Yn)na>BLm6ugRv3 z1;y6O#S%62M;%ejp*QZF3&K+D6EXWUjbdW;dPynVBc*Rrf6Rc_g=eCr$gbR!VOL76 zc4dKNSH2MGD9@Y4i8mjWX{qj+?COSGnO{%4_<3*cQNhnwFVXSy6Nvj9KSx}NP=xq- zCA}2|ehwXq^h4C=&%;H>&s@Umc=crfxQ3qxftva@#rBSh7dbE81jKc}BS)u_?8V{AR^ilc(9)+=;u zeV(L7CY$z;0$Y2Dcq@D9U+Q-ct#W`IthZs3E4Da9PJoCKfSyy{Io*1Uml{{H?*(Y zTiem?*Pp55=O^eO96$d-`g(-2seBsJMuDGqp_2eVmz<7^j-Q_n#!bBXF~npIKNkh0 z(AfwDb^Gm|)a`fBNnm1it+lmw|1N3wO?bv+RHoiH>FWI{yV7i+U3`94gEQ93)caGQ z-q*({rNf7PKde+D-F_0bl&ai&-vp@V4!&W9U9l$GGp$KZ98o!AEL`Ds5M z3s>O_&C`SgM~|SVt(wqw(QMiFLA|qL5fYOXF9OM^CqeJ(BSP{ ziC4depl=j3uh-P~YjCtMN;XD;9($^!pfqU+ zI8YKnE692}y75iY-Eklc^!EEoNN3NFRB0a#B^To5a9wF1s_Xh>g&?&a6;Vf^68W(| z*hn#7>N|%N^D`(N(vV_Kb%k!utpH}KFwQ!eH$JF&J9uUDqpT{v9j2-VrTc!EUrqp9 zOJM65zs^cOD)_Y%vKO~aPCN%F!sNf(2wWn>uk|D~MuA^_0aC!P87JeS<5w=l#jBSE z@rzENZLM3Eoj|oHQ0)w~XHQ18Sx_=NM78lLk)zr$q&-@ww#;$@)mmbje%~>+cQc7Zb}R*$vK{FtNN=y&yRZz`YQhSYFp+V)-sUF*1;5 zv2}oZfM%KF)$Kn6i>H6BVcbNlL$hVf$Pg;8MTqI2&{Ia)l|v=CW{7O-b8V7&ot&;s zGOv^Sik{s5lw_3ebg^QSoUmdTs^nNXtbXbkJ@-u9dqMaQkR@ON& zC7oZrj?Iy*bH-xk*^|4b1P??uy=s_xJ`?#k%0|%vT)lAImgtNXYJMnj%Vn2Iu0}Tb zEUub(7^p#63IGZRNoo~55(t88>A>(wU# z5jZ}xK|V{XcZ+%G|D);MSHjOjmj>pc@eRzgI*>o6p|A9TH`z4wX2}DB*px<^P<;;b z$3d`MC*Q&p*-g&tdD#z9*{?<}`V8$Rxwn?5d>ZDV8I`ESy8*g^4Pgc=14zN`rA;;mu5-e)VyjXZ}1s>?S?>eF41>8!?0<`ZZppo#< z@A${tqEiYUJCsJX9#|cq(=-E}CW^5i(-icZzMqqK0WXMe3F+Zd9|tXjpw7A=hEqi1N>t3I!SS0qjOAYr^0+>(5`1-O1soJr9J7yly(r< zqX=~{1}q+WOvZpu`s!mq`2fQhu$cyg&W-_Nz{9PC+;+x*+Xf>25cLpA)cP3U@59D` zvq@PCi~+NO{01HVSw260!-l z5C>WD#7GboyhoI{gE8RdQ$xpqHM*T>F6>0NM_?!V2wEmAHZAN#4Q<(pUPf}*iOxIp zqc#S-3z;u428@A-9`zW|=)95HiKP9}jRE7xAz_H>hF%gF19sCm60iQI_d$O^Met!l z&&te1pXzQ3Wcz__fSZZf5wqdVMEM<=iDr_S=pWd_H7`qCMRp>76m0|SLG|2Fv`IG< z*{a{gndoc8HROa(&kbG-XTwrdcHJl(=-MDB(AllbR&=-ok+2nodNNG5DeuBx;D#`s z3@3>h)00CS8P3-o873PX8St?Sb+-l_(;9ST*hH=jFSd4NU@I1wD+4zKsb{14je`CJ z%>-0rQ`VzwcJgJw!5_LWgEiw$L$L(k8JaJ{ZSZA)ts)Tx%A^n#M)zh|N8Su8(QYvQ z>;%O$R3?O-2+dXkl!# z82eTB49WR$`qv`oA#!$D7%=$AvpF?p7-{h{MvGMVnq0v0$Jwq1?}^Pp?}@j51Sh{j z{wQJTbzxX~J#Mtx%uYOk$Pqzot3(}Ou6N)u!Q3)vQ+tv4Ak*BsU?qn<$GLUY$5@#Fh?4iXn*)QuR4b0Cc$A4oiM z?~x+08gl}PTY+p85gp+14gHP@9$)a4E(6~~7IPhspX+x7cwBfAfVHKgTRV307ZVsB zfBQXHRLA30N-C3U9@Fn`)LOoa=sd624VKr)*A9sj8*E35N(dUlHi&a<-7_*YE+HU z;{83)MxuJZ?RsAFEgI8vpeq`)bv>)0)J0X!6|}!K{4LtN(tdvQyp5~mi7$RXmQrAk za!-7|A)ILlk1&M)xg(faw+kSklUNNeG;qP^`_YHL5O}Ng51&s0(d3%LB~&S$U_ahRD*c&y;##qz6(g674ar_0cz0x@xHC<)9rNrJvg-!bnff$BG~&sQ0G9_!bfjyg#m?=R#`iLFg9%)E?Pd@yYuu~*RK7p z+Wu}a&3A_LG-waE%Zcf=xQ=o5!^UYOz%VI>osj97Ule~cq9m+|ow8LeL-U9$Ot65% zd)*?r-kbox43jfnRBC;FFdJ8dTWOo>se1OXA8U})e6dOaVBmp7im$Ad1Y4uz&O`Ug zqXU)lk{!ygCPL7m}>a!s;2B-wOk6mdS;c+nxO!o?p`EpuYJm4&|37q_!&u z;5AO4!Xjw8*tdBLV>e3McH6h94sgBHi1h|k4??;O-EDd@$dk%^g(c;E^-BycY?3Q} zsaY@K#TdJ?xS0yzDUOkZ{B4*XtTtE0NdEfj7_oYTjRkGhwG~ay zZy>P@AA^nHF4T+TJUg@?Yha_Hf=Hh6$?9yvG~861b4ED(L&3D77=*vo=Hd37^X4W? ztIolP>7N}Yljxd~y00NGvs7|z^yB;GIRj13eUdWMG7C}-0D7K#tVE|mP6y@{bqLh0 zB%SV$XlXY!@U~j=B^ME|0E_6uLy~s7mYlH6>^&b3lsw)8Kj02n{D4iKj_82LY*v438G^C8hrCiYj}VLbq1?qu+0o>g5G zPl~5du@H=fV-9&=psCc8ZOTn))D@)4ra&iOQD3|Kv)BP@pw8|Vmk5TbUjBWyrN zKwmYZBe?Sm}^o=gX{R&uYej2#{6@;$#*}Vv6uO7kf zjhLDVu=~9qcbeUQdbr=EyuI|Bp9*g$0TSEiZ5bw&9>Lo_uYtG!_`wO@4#?~30cNBX zDvq8^^SrMsWtxXzz&yq>O#;BO{f;mL;(w3m2%rDk&=DSguhSjjgiI5yF1rkqNIwmk zCK>qIKD(De$nO#C{@*VQ?Ed`UJI(ILy-agG_DV2lvXE%Rx5)Jxwwg2eX-}$HA`V?w zvMP@On!|d>0=;)E zV7;RQd(Mlnr*+1jGb_}dGmG1E?*5e5=7F~CIax<$&zaS+J*O`~wf#;)h3q+<%{@P~0>BjNmx6mTHUoJWt1O!(;`+C>{Q3mglJ3X9#joc=sHFRg zw(#p(E&W@o`TZUYzVtjfsJP1#l*W9}n*-l4op@uTQ{j2i`gkON!(vkg)lH)T~xv?1xkG#SM8GW?!o0 z$t!Xw<>WgAS7nD_tJQKZNUkn!7ORpP^CalmaIz^VB43tAxR=p(_*iU{+}Ob1wJzurApH83o0$OiZ z_nDFChaL5q>tFw0?K6YwdkX)s^D~+IH!Uc^h!a??VDLm2YGyU7m%YJStH4?%lb3mE zVwKHuX~yVOa@^dk{t}YCq>N4`*F8!3C4)Esa~e#q4rMd#paQttqLxFT#%#;!3`$Qi zCaxqr+*0DcRC}8{N?P&04xV^Sa7kbpnS*<%S&!XupLclePR9ntvr<^a)4yg__Y`5b z-|48#2kJ0%Z<f8fGG6L${hCu|>NnzAEO{hUe;YfsL(w%#Qv|&EJd?>*}o|!Zn%4|@H z*rz@Wxj4<>zR1t1j)+eN@Lt^ppWMzY4IT2y1jxR}lux3o^J%ZO*EdQbKSa>_Qz2m= z(>k*?0v+{@2VRM$ZL*f+*Oeu#iNqhVJ*?)%2~e`$|T3YdYR!@iLNrQ%rf2|uyj z`xe-h;e&Qxi=J(~UrV|X{b|p4E)Bi^3hi!u{#%SM#{12r6Vadceir(e@&1E1L+>wa z@jM-@XH5Tzo*(HNiA>jMxfDx{0dwQD42(f}iP-1>M~*_g9VDRC$GE~w5+sY>vr&?41A z^jILZt`CLI#3EJaL(-JI6v>@H$j?EXX;PEcDtRe*U1b%C;)lz_R7eS`+I1KRFswZf z?NU1cfsSuzJ+l1@vFhQM7!59om*W7o=1r`p#>M7WcD6(v$)aBvB&>bfcTF;Tc}Wo^!}3YJwPO*IxVcx<}Fen|fyZ zw^PTnUW}5*V|r*E!}9o|zeU31r@as*j~|AL^b_Invw*`z|9Vj#*GcdSV^J z@_2e}Bs~7}XQSlt%OG_AM0ouAXQFL?s24r4{gvWWr5<}7V@+^^uxfXLyEqk7Bj@Pi z{HE~F&-$Y#-na3*c18Qo*LRSA%*yuP|JSPapMOqMIqWZd`By;VwZH5)diVk(xm-=uAu#YPNV&QPGOtpj1bGc*gU6> zHqU`^{w(rg?JIfu_xdH@y1+hVD{Y{ou3G~{OV*z@KNNVXjztf_Qd_8#*jOXNIk~`i zg9*YLU_!)t=fA5Ty-ipwR8*7FxQ3fUd%M;!bEtEUGCqyh>Dp1Q1Abfem`uU8m9*Qd zNC`a6h3$Y&aV^4jK$nQ+f$e}$qZCQ$OU3SkN?po|-B+5jyD_u0<1gBe#V}bR zdF}y<0fgUEC-M>oJOcu=^HZ^wgCQ7A>bMU1wVjLvn<^<+s#pDvRV;atyAZ}>%`2AR>yFANp;*t@^3@i z=*=psN=O^c!LS)@qZe6%0-TPZwNW|j*L+AhvNq~m`QP|WX!(D9pjG*oL+T5be>Y2D zDE~8P%&sVZTRavE`=N0rJwhJ)=+~h5Oli2ehk1d42W~|mRiQmzrR%*okVpB;J|2>z|cn9V7E6`CerQ9f;gbq0Xy5hV*w}>DQWk4E$-7>+z)MW ze{zfaSpA;n4-7b|+>oez4^gRn0pG>w9d!w0d+cC@ezP5Cnp`TDXPV?;*sEwDd1ql; zA~+bu727>_v$%MdsT_ML3AQHDU++MSE&IK)Elji#m3jh-$fmkm;zH{(eFKwcPb<@n zJ+Mp-Fpu^$I*sgsW%?sbtVfqlFbYV2Lzl+&I^Zl_C!r8@Eqjn(e+!19dk023x>iHv zpzGns`1Q|!;@3mky`Wv|v~(}SZb<3x2Epn2ENO$dJ_B1ST~#gp|7p*^h7E?|zanKG z*Ckr|`Pz5hgD(WdZ+sb7csHg>w1XME{><3Ibx=lRssy&RCO0e_lDJ7Zo+Lqr3UaM*S+9t)kmi_PBeoisv*Iie_9k#8d)wPo8gAlfy zgEif^IN7G;Hrw3daPQC9+DtKt<|5g7+C?;rnkK;&HA8$2x?Dk`xS|h;K+#3&EYMAx zo}{Csi#$bs>W|-g(yp_& z3D?wNYSQhZIB80~&8!)GZjpd~ZaW`e~$wVQw%L&(ja`YQ;NMa5YjA`6lKNwI+Zq ztX<+98W<&82fC>(pF{0>Qd_P^-;Aa$V_%J?Eq6ddK91TlBf5Th+0)_LGKTj{I%|#h z%ReGi;-ZfE7(%RLDhLERCfotCI_jB2c+bQ^Z0&c=zbMf)=O{pQq z-K_rl5iDZ5e<_Y^TN(oo*$pvncGEB>HHMpKBUNA`8++2Cl_OFim$l~aV<$)aDoU_= z0CHyJ%zXn=x53?k$2BCFbN%bdwv7O zzeluZ3ppaK4LPE-@zrA7TKbn9n{GCmFu2`= zrymkbZ*DI=rbv3z-0+38b$lv3v88jMk7F95As4RLxy%(CXNgaTI)Y84UF$MXz;zkk zj~;-TrPUwG3nMDZ8_bP4Z)@45Hw801m1XGTmB`R&sb?5PK3gEff<2Bnp9k8@hx<*r zvP`hKz%zQX^CX))hFLOlajF^!0+(r6Q&QA3IkfpAut#vO_9XtLBs^`rBqcwoJj3D~p`o}Fr!pz!$SQrixMDI64pSQd@pwC_ z(M4at{%|JW89Yn|G%j9FCNtH|Yh4FooZo0)#xlD?ED9WlNn)7zUNh@fK73n2g#&{| zVKQud?q7XLRyxhn=X|kp`@Az@-*e(vtf>o6=H>&k8*Fp`ip+UFcf=fhCA6QBwchb? zzG=L`EJlRh zZG_5l++mZ+G(77)cTz{)=lq9QGhI&Ir^MB6|G6Ji2VL7vFL>H)Cnia={&N=D;o9s# zRS|cfL$DB_p|0hLV4q257rPaZM(YERq-DSLyQCn?3rc6U)? zp|Vv}lE^>xWcnFEKfPTCuoQkC;DDPfc^32ry>55aCOfjXI_sDm+ES2?V7%>Yn_mwf z4YbYwL|yO1i1NQu*ZUw%A8&OvVk3oVeB(_D9WA z=A=b{qHMeM(~tI(X?#M@O42(0aR>Hg6mGW?85C<~)=Xw2^hbp{ZGe zf5c$UIH9w!Ejee{UC~kJH8`wv8Fe5ZgzZ;dM4xz+^+@US0=K_J+_N5mR?&s@X@x`Z zLsG;+b!xw*7{W>YQGWw?bxhgd@SO6QCk}$ZnTapPnF^IU5yxx0n$2@gw<~paWt&uY zpqFdcRd71UP4XXu==&Dl5n5{J#m%b z$*RdXRhp%vI~YJpvNz0rZ`B?>wkQ}|yQ&0s4wg1682h59Xby`zKN$CGJ?^An+!8(R zFbc-MBP_WS;*lQzZ$tdg5x=UWpZ2v)h9?<@H{LMBrx@a&G{h%TPDKN>oX8fWfBPF8 z2FkxZ`z}51Ll!q0^_hL69@l`lRaPwjqF6E!fkMKPWfZ&XR33Y=9{U7)|9lX-WLQ1Z zkWcpBkGK`5F`DDOdAM_J&?cJOX~V91gtNncxFLAPyw?!^#1P(Q2(LGUR~o{v7{X5* z!jBumZbNvXA$*S>X7<4pc=_3toi<@LJb1U+l%hdm-R^!k%iS!)00+zLyhM|HvZS0O zDjU$r)Z*Kr7&iOmIDf1!*43AM0NYxx6`Fs|hizm&L{bJ)_Z4d1QQw~bqkpBJHBen7 zpV;J3nrzkE$pQ}zPRbOMoP*2fC!6GW(Qop_iLOLH&S9;#Ca=XkorKX_@{37yQ3l$o zPGa}yp{@TYU!kUR8DjuqIlIg;;j-3!D;*%Wuo_g6Kyq)tWoBE&2BP^u$#pMijss*t z^LNx;(-^@qp#f5d%vDgSp?i>@CY80Vj7~+CAnrzW^1L8%+sKa3xdrxF!!}{@pD&Ix zN$EI!8%O4r&v!ul`ar1oH9D_rzGM;}dJrK=xyPCggApBudYuKU1#1S-*`jGM(5Jyd zIwwZdPNF9R|N2rgYdDK-mlEULBW>5Y!Y$=(i?~*pbK>oky`inC1qVhk6%Esp{;Tvp-17&=;(1K(i`aE z2a9(bJ!UWH8hTKhM@o+?W<*Di{zz}2$G2d`uB8Xgcc4KbWxRO3$aa6rr}6azTgH3` zH@sj>tE?3sdX|m8^Al|ui&C+a6^GLQ6#z;st<12B%08s2sAp-$U}6)C6C5 zQidDsbgDi9Om|G#gPDf0lH#I%;6Oj3U8Rd43_=zpQLw-MD05z-JQzDuQ#w@u9|WYe zcz<4sFOE8wJ@y-aLw2d;bo=bAvypMO!$Elfjs3`;5A-2p@{k3bz7vS%GjUQn#$q~+ zK24k?-qQ6e4YWSm`8K!&pc+*h48|bX$u>~X?TH*2gO~1!vJDvS6= z0BVj#8w`X1e@xl{XU$v>O(QKoeJ?|ydw@c;->`;4&jnCuu7*M*fDC~iu$NHi>F_8d zYbZ2`y7-i>K%wg-g$>`(BCxtDpwAsOk7G^zNwWxQV*yF{R_~n|dG}|9~DE z6&)+6s~uB1K67KY(Gm6nqn&4fZs&2vLC0R}odM`HT13dc&|dm`G29u`L#Y=ke#iPd z%mx#%{Cqlw^I4E+=A|$k!TOBv>{FUywXxH77nNX&i3__viHgHFiZJj%;^M`X(TYf zLz6bKP|Elo<6;!Ypt8Eq(oO2bs7YWm1x+wRRrcGb>|s^G{zEORa;fiXRuvmn#i0N_ zQI!S6g&-geTo|t~VRm5dAPFM)lsXKh zx!CkUJkL~aGObPLj?@|nU0005q)WiP8t<-gH4mB7*CYOkuCYkH0$G`K!zYjTh`Z** zD0Nz-r}$5<149rejA2pMabw3zo|%?9Y4KNVa?mwxjj17j3;zFu|8McX4+s1-$-P7& z$?QvVU9s&!l);%KB*lO1jH6`c{|bxp--l=0BFUXU*Wu2;TXK&hkGR|EY@v(cRk{Wl z!HpEVVUvfp?o*w)F$r)JDLVYm49Kz*$1_yLbifkMkox!Qm;yinIJRxKF_S zsSZ!Rfcx7KJ{#_$2?*nR`4>o@!bJ$rMfei6;m$*TrMZ0Je_}{6D_rAxnwFj&Dqr}m zNfwlweMr1Uop&4d51EiszHlFl{4a}~!Xhn7qqKM((PPq0H|yjKGV&3GqNn$*icasD zaH#DfdXI-yr3>kO{`3gwop@^)djEGaMfN0mf9KZeeQy?;9? z482_}vM14dF>PVM@Z`aJx{Tg)VHN5^dOtcX0(z(35{BLX1EX*k();jj5zt$La@lIUOlOhZ zM{j-(6NLX+P-EsLJKU2~#xe1qt!|kGsYA+7|I*=}R$HiiXRDgF)voNpMU|8faiL%{ zjJ0ySkYw^D*)q=?R1wF)=ImckW2j7c+38RUtq^jAicc`)7gp}Y&NP)DIZu-+_X?F8 z5hW@Iz2D%9SfOGi3+xptn7pLqLmAkD#qJBgViFEykXkm8Vb9(>XLzA!v{_A=aR}4) zhn;p?#DmnBWcAnwL-se1>-jL^_md4b+ z5}fKX(pEK;(%ncOY{=gekgu>>&EcMENg?s-t8w1dGPpmYMpT2^qRI6s(!1w`?%_LO)AB!ByA}w^N`7EW;uH1yV-O^OM zvLLNcnUY~wz96lsYelMvrLnH&r45*!X9L&Y?+nLFpMmx*c!@lCh?n-@%6N&KI*H3F zUZ+3=ytD^ALd||P=OsP|5yBnbUm`1Y1Jc1JH?{O|3ucSG$u0z)ica55rA6SY*%SrcIk5%hN&N430c6TlQcc3tCiCJhf!}1(>B_t^}1P;J>6) zk}Exfs;QPDa{8&7N|Pzy({&znULaLD{;NXJss!`n&Xb^O-7_5=X0yyAxUyNM1FM`P zB@b-04f*BadcMt4rgi3Dz+{8I?7ae-Ay`h12fNAZ3YC3e4vU>w#8OCQxR&O;(nv+m zAo#F~u7Afk`_K~!Z#d)eb;-;=X>(6o2GIH~`uoEak%nTwA-OB}K*bWq*P^QPsK)O6 zrGVuXNL`DsOxu8eRC?OSCBmZ0T}bM1FMQbHE_}-7{&O>K)eE5sNH9!MZ>RtZi+dZ* z@+E}BrvSjQBcey8WO3FX{oY~F$mx(DtCYRgd3~jS-t|)Uk8_HBAELj>XHzv{JDMMF zt2*D86G(S4DwFQ_4Wq}e1!9x6jM+o=`Kx~PuYqftAA>~|8L;?Ae~IYwGRwReXFqze zD2RvU@<3RI%Gms#dj54f4_C=a%FPu#Hi^a35UF?=FTk}W69yY-n8Ygth~mUaw{)?h z88Iq$oKUmdlv$FrMWyh?nN|y)&QEK|-%6t>{`cU&862jMwXQ3cVsf41<6oy4@DZHW(9>*kIFl(%}DxIKuls0Pn5)hz19A?C3)6;a|nEFeYE5eP`)(qz!8k9Nd9x7&} zL!@D(p3fpfNmmNeEx?E!HTl|PqINMd_NFet$lQB1j4YheS&X#9GC>%be+)4a(71tc za$`q0nNQH6;Uw+3)CNv|oCTb`z=)GK04HxGoE*n-5?k+nB-_Dyz3|=hVe!`iHH}7v zTMqk1P=Z$j(eM>zXvm+c3-AFBl>-rD8LeaG6vRh>l?Sc~hm~Kl*ifwOkGP*YR+i1x zvGM`P4FSC*3}B3fDWXHH{6k?FtgK>@p&kC1VCBPeG_3snBtu<0#>)SjL|Q6gWr@2J zSUClg%pGIpZH_QlS;!(oN!RsQX;(}(VR@4_1z;~3TF*_-m>EEPU}~VmwJR=Qlg2al zN_i5nt2!>=PrbJ;&N+mfc!%z-i;+)~RsbpJuUyLBI!D0D2#I#Gr@uwMuSSMUGr$jd zpu;UD(vTHvcPB~u8vOm0vnfQnT^{D?853 zgfcO*@@sjt=&?dsId{$#4Pu%Z69tVT+rEYAvt^c4edYk$x%`ezbHka6RQA6TXe+Uj z+w5J6Aa>6lWwApnMHU#iW8k`w>O5IZz80T>@D?j9Pm}!6&|?cdW0F@Tf+X0U?kNnT z@K@USFD;Jd<5lxu;Yk~O4`yNFEW@=)s6?^4VtQl$8bNHsb zK)Lf!ZtLF0L|9bd+2(K$B?&Rs;Z8}f^*(?qh{TxX`5uW<#W|DlYnHFaZ;YIfpS=e% zeLTKBr%-7W8^)xWUH^#@8^;VMv&K@h6Dx-{`{}IEv5A#_ISJEEaxXdz#@$C$YDv&H z+}HU|XSv3T`#zA9_{3-a&IH zPnyc(9ko{Ls3ed&FiD@H?jMg4Te+6^&+%A7C1J`M{nLRURzsY@`X{zBh!K^qZ5el@ zVuPr81^5g+9TS9_WUNcY!vxkjX<xnOrb ztB<++IlVEfFFZgSA|o(2)>XI5BhnC3CMklr@-vW2sG*T0#^FxDNKztJ*2xljs^k{f zV1fax!KUn?&EPLA$s8zK)cPv|{rbgAfAn+4=S`nha#8j>w~oBMv^I zWzGg2ao=9?E$Uw48d_9|5eWSDv9RP-YII^r@Y*}#uub0IQG}TNncyN`<4jqN&0!^q4cH{`ej5NQ(S7V@0sug}C!bSg!a1QTm-> z8@#j}lVJm6&EB}9wjk7){VA=CV$t8@mRfPt?2U*6CnBp)wYZ$w%Sl;caT~Qb+w5l$ z2M$EKd0rw%kT8jtw-NNI+eLH7kF)8D|t9cx_Z|CgW zC=T3r8IJ?^?VNoL#ew_I<#FJ?owKtj4%|0@;vTb<;|q-Y_)^R>hzJ{fNdf-jt+U0o z-|rk6!hrF_cl~wd3(5%zV)o|J9O4jVy(qle07*eq-p$75AL}74h}m9cw=OEgKvdxT z!vuzezTbIw9r8ogc+0XC#R7*Nb|~8D<4!1n!ijSWk|9H!njK(O|HULjG%y)r3}lE4 z3^D|DAfpV?z+{L9vpf!OK!y;r)j37Jc$8^QfzrTbh<_VphQ9k@rfAXbP+<( zM2HJD5rW^>`G&AeWA=SQ=?%}6^^)?WWf#fZ&ce(;Rh0ihcDkAFnIkpDwK|Iywe{YMi#nEo?H*MAzh z{xc?^{~&_&pD_Xb2N7-RKNzxf{ii|M6V!j8JZQUy{&*280R1O})DLJI#?c5f2Kji+ zF=cc5b_qI=ecyKuWvl1ffD*KYD?!1+A%c`3UN};M5D`>@HkV#TA5!WhXhF(0D4wxf zp*Ax`$ez7h3Zh$35wi9D&gTheLVnVOGJs;mmj!B&i5iH6Vp!1KLKE^Wz_K6_dgw(M zpRp}gF~ccc(ZNelbtJ+mky;)1G4iQsd(vM>?+q&VzL6o(fPea1>|b)PqB^9$T@-DhP_(tR4a?&Itt-3M}H7~N;BuKPf_ z38VYe>ADYu)G)eF{R!RY$aNp`{no`#uKUbsNB7A^Pc`U1jW(s3bf2N5`<$gVqy_r* zUn~LLhcS7?T8|%E4`o|8WeXo_xY~mOM_f&s4~8AC`H&?tMDux+BE;-Z1=lW) zsFmh(2Y(EfoJx;FHJ^99S5qW)MacP_??P3Zi|Bbk^*IN3{P}F?j!-G^PJhG&)E!c7 zxVp0!q$agt6jN=uy7Rdfm%~&WD|>yj7H4Cs4Oe$oX>m}vHPxn-%A=_^tyG@T7@tsv z$)vXED$htB7ozf<#p6O$o<2M-MCI8_Oc$xjvpFi2XG^Kblww^jfXc%K1FrUjN(N!{ zp3j-y^F{}H&)HCRG?^#i|Ficl@KIG)+ju6)KnMvFkU$WSQ36JS8VzV-KxQC;Gctjo za?z^LVpFPC5oQDnYSKwG!|_;KwbfRwt+m>luUan&cu9y50s;Y4q9~$x+2e>tR0vR+ z|MTo~&RmiSgiF8o{oeoQPcrB1voC9{z4qE`uf6u#XBg`qXbc_JJ;9$tV}QbN0F#xj zFig&~IGZL*%P1BpQ3}KK6uD?I6$TpO;wTJyG6>55pfJcXy222%(vb?o|6A&Gy%_jk z{G|&&kd8he+{g=`7J2+ib7S-ANl}}9I2{5XqM5Z^Lqmm4Wteeo<}(WY3P+uf4dkPF zgRFuy@8k{g7nvBlO?O;7oJOoTx`M>|yc`kNm##2zT|KdzxSo4vH*np2ZX8@!%EbRR zTsO=yaedp_Oc}e6t@L>Pd^kLhhmUv6Hu3$`(M^2o zhIa?wy=TY4_kEdo((px`Dz~~C`^0itA)dqTD~^eF3Tnl8R(g(pSa^5N5!o^}_NBRZ z$NwtKeQIng>qj*^jvL?j-^~I6I}RV|G4;TNXoC8FTnm>chyq9mDHTfV^{W6xUVeAz z`6t*@I`NMt6Hf*`yTGp_Vw7v}IZxz)xyNRjtn>GayNBsyLjoRoq}1ld!Sr#Ncrq~U z_Be^g_4&(9TwfdCJzU43YmO@IH^O$(sZ(oZqK@hb$%NzR(>E?N@!USHdw5=sjyWox zpPUs3&lZ{Z--GAJmzsEfRn$E^S72T`x|IJnEGwNl^fQ@wQh7IQlZ9-vEAtQJ?@&M2 zmRR800;A{~{SSpI56jcHr(#!nX|SL1mIhB8c;O)J*5R<2;SjspNHZC>33!$rXTOi= z6kzaEoVNFBH_5gKiZZtSy=)utNQW#PzEf=so{4siL>ybio=x)7;cJ6^aoF2(doRQn z`f4N$MTzp9OiK5+(mxTE-za{2qh?)CWfr*(s~dqdIb)ZzPp4-S7u z4vQS$tlq`=^^G4{))j82cN4eo26u;>&yjfGByqHB@}MZ>PE2R%0>6%(7A=QIPdCTy zg$3Q~#opb*w0K0EZah~ep44&MQGYlRu8wIYu2V1U9EM6Hge+BlO|ZQ@iTJzmDl1cDD`ej@)_i^f>7KQ6`>@(RdvF`1~biKfadVJxuQ# z&>c+Qu*bplC7F0KFg-$Fe&p(^FW*1Edl+7c4mqmk7aSG`!MA1N33F-}{pcItqf6W@ z-Nfy7biq+^v&F;hAhd@6>8jsGoY%d6tB0&Vx+Z(R#G}L9KQs!t6Px=xn-j~+ zZNsYMvRldBLLcqx_BZszyJx8FMaxCWsotxVP=hP9&T}aY!_yS~qj$G!RfX}NYh~!L z{-2hdIwAxY#PRL;vjl3TMJYlBFDbr;6qiq=++r)$(h`;ZEw14WuIfh5W<;1#1|t^s zy0D*lXZRv1)UvZsgg2-G&Qr>Z61{y;H-bv9PDK3{?W7oH&~Fj!SJIyZ!sDSsjJ8FmEx}Id%usY z&xUOswU>ArzKQpuww>VIu50V6u3zbO;r4SC&hs|JZ)crX8g;HXVx6QwSM?U^_3AkL zrNb^vt*61`q0QD{!SxH?eh72lVcQ zXESf?FONXzcCD_;b(L<`W5(b|n6+NQZ3Qd&h9_|K_=AW`dGvj`YOlboG_XC1%CSh+ z4tMj=sBZ3yZXTAcce7ROO=it8J)`$0>g&P!@S8bQ|4rwwS+_ZCOlSb6WdFc_L7tEg z8B&em`oYEc+b{52J)O0q&W0g+oqy`B|2}KH|C;X%>yD$8^gTB&B3+4nN8A`vn&Y35 zgCI@yZW-*Ct!Sy0@Ss(@fj*kVncoC|30pJ1^WxQA$k#5R@t3stOWs5e z--g*4sk=ZgP-oa4&`D)|q}AzXNLsaqX@&GCTA}5cIT3ob;?bZNjyt0cgI?m%gK)*v zN?Sk*05KD-mSzd8=EzTF$Av!!9et2ay^P`-0ZRpUta)wJ)I`aqQOqCB9x$z72Pm`f z3t(Ba+5=a$bz%@psHNaO*FupNd6^?ZmhhK(VsGSSf%qiyqKMYWOPSaZd08r64Zrv+ z&>iCG$a_6FNj%DTooB!&rFPkA299*n#!5NhN_ z5w}NP%EZl)m!;y`@QY5_%OmfSvc-5OMNJ|}mP-YBkhlwp?cl?YW#WwX6BvilG$ZD| z)Ag`;cy83?vYP(JX~_xj0Ptjqd8dOOP*GA8UayjgTdvao3m+BV`jF^@@c>08Iln%5 z^~!Z%jyei5@dc9AbU$;cttjiwz`?YSpfciA_Po%+P;j$?8!fgV0pI$m>2r}2IjB@( zGz52WNNmPPL-zBKU4ex$c4mmip!2iT5u{3_rYB1v4ic4-;sHAwAVj!1hGzUkB;j?WLGzYGKT{`!#0ax4<5umjjx0r8EyGBS}%yvBa+cpJUxQ@ zZjww2<7d7L&4GUC6vd;(6|#SRDHDp)M_?l!{-c_8IVTZlioJceW+Zs6!U_Ak;{StQ zZU+VfSX4WO=+g9kWK^iLsOdi+tdFQv(FZFa5|!5KXx+pddu2w>QQ~8$BnHC{RnrTQ z4k|yy0g2|*ITzu#&%cRvjOG*}VkbVi@9*T3J*P(V$!)Tk&V15@TymU`M3Vrx6Q3lZ z!`1Z1m@UF52QbROCrb{Qd?JvbkBM8@>{hW|jzfb_KHV?Jgo5nklS8;PO@UV_{Cec3 zLNv38za&F_ICZ7o zL<02IvGrqU2QQ!mIEX=~V_Soqz&0R9p&{1V_epH8ME0;)6PuHc39U|j`r2RFr-RsB zcTq`I({q6k#3=(sai%?#sWBZLbv`5F7T}vZdyb+agBu`V<%F~IO-!68kK5uD0;>&WUL&jH ztysR-9Y@@U)a5}1ggfBy4i055V^QDylmvC%+DRFfQ05{eK(9%bE4{elRqFHMxrI!4 zpx}xOZ&oPt9F!%Xb5qt%VO=Bf&YG^kykYE?cEJxs1nV^8-YvVLo+mF@VVJ3+Q0CiD zBq#XcmFg&1mf=lR{L4}ZD{Eecnzxf8c_PSBhX+M%!(ot6=3h~Wqpv_wahAIqo3s)J zIbTYgl)^#Y38Bm@jkXKs%BFSH*z{a9jcY8~^uln{SabCR9c0su!6d4g5`-?$4l@ed zPKoF>1mK{eeqC^-r0d&%j-~4+yc2{gvF=O8(RE`R`Utv(*=IV9XY&3CgeS}3R9g8( z8NOL2#}321)=^N;90bEyylD zqE>(y3kw;@N#O^55rngjq0E0ij+;T%7gFQ`{qk&wOWh>-{Sl;--!JIE?+%mSOVM{> zewUTf?w8*j%Dj$6)#?<&?yuHs*57>fDPSbPQT-Ihmzk%e0hN=C@H{sW280*P`?Xn>H^gf+0DmP&R+zDfRy3DxBr zKNxky-{v0xePyi~2ov2{uLtKs;441Z#po>E49?J8;Yg4bw?&8MItQ?H+GZOh6SH|R zvVvXXdwt;Wh5EO2KpfDstep*R&xO(IM&iGb%K*UE*XW{**Zz5F(_ z&QsL4DL`S&gqpRnm~*wSp6t{ypg-=Vruba|^U6he$qC|4XlrhD=rtM4j03KX?)-Of zQ|*d%u5BAiaZuG3X~+fVjbAfR(md49hDbR!tZo!P?RQLyPZU?6pE1g>&9)rnW8%!pA9;E}vkhbRLHq0F-%;W67_? zOkD5O6pJ_yd=ScPMJCv0WHMO}^XFSgimeoHm@`M%CiW|Bb(lrn{`6*~MPZ~@7hd-WFO?3p#q4GO?+lKQGA0?gR5vfR`wk@Dp6)x48jO(Uw`_Id^<&~!rIjEv44E;LEb|fHF_eb=g`cp;_n-5cIWcC)#Q|N7^^i` zB6mgxE56Sy-T;$~JX0ezxN(83?W^o&Q$GowK469pm= z0w9wl#hiXiX$;APPBM1JXILTXkh}_#b>gKk5O^?YMKC%L>W{3&=+c_D2%)-wVwa?c zgyJpI`A1^e_yGJ2*g_%)Dt1sOOwK~WDy zeft-`;f$#-Xz}g>D=FF(T34FLB8b3sKDq0cvRYgDM89XoVZ?_i3(SF`2aSu_ke;$X z0^^Uv^bUDE9HU_R4vMNSmS?lnpFmBss^B-vz= zY%NKajF$Q#%~s8=G=pxF{g+>HxI`-}3-GFMDOFA*793K6u_sD6P%+LtYKOLmGt6>r zGU#`d`3~CyYaxbCW4u3U^_h;vx)^{_h)qRL&swMs3BgI?ORlHd6TRn)nfQd=<+H>x zWUQ+94zR8KDibRdb(>pVQw+mc8Zrd?ia&FHR@VhTb=Y1+ge<7YQhPlX$Hgd4I0`PM z4@KcJjJROa3bXyyz)`p`m}8JRJ&X*;xkTn^Y%#<`=4@mIGTX7`eDaV1UL|U;QaYM) zdpPheM!11%O!_k*VZ8Leb&2H~dBTZLl8iq=#&~3G$B+aW@5L_m$s^-Yc%tyPQMg3$gbO%|u>dFrne;F+9( z{4OCrGJ}v6$TY%0dGe4!KP#GZ3@5L(&SZd6h& zyOLUb?Po9At2y`h+WRi)QJaoY+F03845?AeDa?1EkJC1}zR{@`H$(yk8ob0GeICRX zofEQ}BB~dR!mnB7a?@9zt!{u`)5g_qs~E-{TKc2-h>RX=uPS!`AZSgo8kkk@*Fy&ntf;8la(zE>m$LsG zS5f_1P|GHk@li3T9QnbT*N@ty?nam{kbB5(wE?iH={Mq2DDyEi0O}10Wj=i$m&aoI ze#xK$`nMlCcPw}5bt^^d7bio>$8}nGL}VgEJM1zYel78?&f^uFPBkERR}PTBvWp8A z8@W(GCc}`CK{<%Cj@Upz{D)2Xzwk~;)2Bz{;3(_ zA0O%PD_YtG;-~T80Ux{_3y?RTzz__0dk_koh~~;yLJ`7nQ62=V+p2gdTnWKeI0<1N zJ1)F&GvFNb8}9owx+TI8C;2IS|3il>5gkYB*ZV<=PW@^}zhaelp7-)j9eb^jU*9FR z@9JL1ZZSHxxCZ^ozAPYB`9LeM?Bx8d>PFei;=eE_>HRw>l=zw3iIfW_(IBD04jPzIyrsTq`*J$*yRo`$vi z2AZ{T!y)g0lt%0Sd{66)Q=+bO!$@fl%z(;)r11L(x>6){hv?9l@=lpDT=(sk>M<9W z1I0ZUIZo~B0hkPL!5C2+1KZL2xah#`zX&E@UVgU=cNw%vPJe`?*Jdi^O(n{x3D69R zYi_$lT#U|PTvCk4addN#wj5CiZz>g|)Prhn+oh-0ZzBd4lSGd&eycW|x zv&@~lpKhuRhm&vtq*8R)bB0@mwt?M|hLVDDDc=1`Xf>j8rYK2UaD}G#BbIT>`2ogV zQM8ZfVGUL9Js(>%KVqxI<}hz<=q)Y{L$TBQl~ete8|N1zOyAU?!Loeb^RnusS~S?Je?KI)7n3>9dwnf{GuLH4W`(84ka0ue|8{lB%!Mw_M9-I zZS`h}KLp9{S7npm?*t2i-{-)*EcyKmo!_xJW9<7ahj`*;A(Hodv3~7=XHaWXHUExE zn1BWu)&7a+@v5w{q<{nMnD2IDK$NQ3bX-TK$#rvMMGgwGQ!g1b300HDZPh#6#K-vh^2YJ{7Ljf*fA0*S7oP2LX?6|>xT@FH(7mo_;O4i4Vw z<-X66`{3D25bAI>b3bEQl;m9Tx+`}RFF?srwj7|OmwxP8@$9!`ek_HrLt*r|%h!~GTTufgWDJhf<=F+cs@Em( zy~Us2HHQZF)4Y2E|B&e@JsPDc#L@d^897!k#&3)*6I=$t0_sq%fV&h*777?$xQuYa zvlY`Ds9j!CnC-&Aju9`rWEp2IRU^`O2h^4*`I5-CqU6iocT9LOlo1e`qj@LNAYUFu z4Pp7BktYoiGs~?8-ML>G5+=VMVx@diVe(SS7{Ut;Fc(hrP0E&b%9`93ikg>OAtD&V z&V!vIRyN(AeGUc9bS-;1h0Qbaav0b_Fm|pYR8dg6qoE{-MM$8)(Krmb=QLsuOFW#N z!QGt7*Ew9HMG)9g?qlea$0=BXoS3Bezq@qDbw93Q3dfvhs5}_&@?lrS%!1pLKU6|% z90g;}^6r;jxGr@qE?LI01_i-E?b<|aY#kv4Ua7X!;!gVBg)VD{jT(%|ONIuOs+&qx zjMnWCVq*5^oP=!E3?W;Zdl)R2FDKWH5E9}d)U+LoM#yi>K& z7a%SWf~AXJV}(Z9dIl!sEpM}?4Wb#pugdjUvv>v17$Awz*Em4XpsZg@6Zp+Qp@(H5 zHaW;`xg#aGLGm9K8RkaRudwj?&-2hR_j7sSn4fz0vx`G(j4nPyF13%^$tx*ujGmVM zX7PHu_RWqxy*Sd-zc)U1tEc}ClZxKc=e>0zJ^d7vS+l1<0|4yl5AbXD^fo-Br@x1+ zkKfbJ$wEiy=_kMYKhe{X`_wRy>9A0bcv(Um&((@xb|EXOCYzcK@x#oA%i!=^i+@-cd9kPKZ7Htt zwu&7zC8#A2hOr(1*q`#ync&_iq%RPkK%)lIgF1aSaPHsfLl|W}a#Wh=`7L+sz1S$P zu7~2F*hx~w0fW(6_bozhpU2-QfV>m9;7dEq;vmqDmCHkuMwJ#01P?cRF z1w)&w)?8=6sfvOD>jm5x5w%`$*&eUwdf{`d4<^A+_9hKuQI!7o=36%M#6wo5at- z6Y}!ca$f*a;bUZ#>xc%{Vyq+3+r~QLpgssG9Inl_?`uU3rGrCqDRGb^t_?Rj8tVwp zLoW4p45N#chEP(uZ+Z4r=WwsFIQtqd4$hQ|gA`bquFak&)eVZ6t1!1i-xr_YY=q>~ zQVwN^}T$G7>ASJO4 z%6uirM+UoF5|kXKQgk7(IYpy!TjAAFXV^}pPmfksQTsBaGh$X(j7v=L?l*0Ok@Rxk zxQVb07#~Wb_tffP@G=^RN&n`J`04j{k$-6y>3{E{p8F!{+=H8d1q;F8a{y)r`D~m| z#0mg@AUJA>e;N3fg@5)MCv0?)GqJ~>CsH`JY$V;#tIV?%Yn@qO%L9sba|-v;&Cpe! zq+;vWn~n=e+rCLkfT^oTaGDU*7oaa<*{RmZ1)#qVo_JD^x+C>rt5hCsiZ(k#Tm)i3 zH&rWns_&^pZ@OSI4HVeHTN3Q_+%G{g4_W!5am`119pLr=^; zlb*NY)*PTI^SUxb-G+mqwUdz2jl5bHc_kfb@0W@? z41-JG|3-6j1LN@7;7#+V>$+@5uB&Z*r@AU`&5~1w#h7Em<3_XY`7{)guh?)p5PpUa z8U5GP^)TsT69W!&v_MNs{#Z^%u`XwCxQbfLJrz7g_Efq`4_jbPQR>3t+4lIB#Ywn} zEb9KTiqFrjfSu+jxiFS|UnsgCsk)xOdGJ@K9u)(XJlV@SAmbrc z?P82vt^@UzQadY4L-6*?_DPMzs+Cy~b!jW6;erIJYshchP>SudPPOZ8#N#(tbNBge zXcu`SJfib59EVMI{(PNLJyqEzj?qcD&!Qej?oXeTRWm6^-*8L?$6F{BmSsh_F_u1^ z`LR=5x0`KgX%j@z$!H9X8snKRp6kV@Yl#6O(3;y}9Y<+=KL&1Rs(W#+5oYma8A{P+ zTlJF^Otii?dvmoJDcU9f7U#mI&$U;Qc!99XkLD_SDn#+5jG#x!JrG%CbBb1q+Of*k zMo-YEOf0m;XegW{@mW|fUoUIgB`>@(9U)+;r)WtzVNam&uwoiK+NKR=Nz7WltJi zaQ0J?|D0Lmc$|8Wzwzb~$1U;a5&9v7GS9$QsQ(=zXrjIhqh9$Nn6pO8W$BO4bI~|Y zZ+zE(^>Y9n`srrOpzkP!H>Y@d;*LDt4usPYg@xeV*(uueWU)AC_R)dY*+)qrG}fVh z-0R@0hm{Dt+oa^47tOmczTzr9!{Y!udT=$6h9X1vEB{*WEvvRPEqDr-EuA@3LtC7s zPsD%A%jh&OqUeNKJBArF1LW6nR%V|7hK zK#o%`l#6K}$kbU1Uj}1686Xkip&l)e&N}SL(A~1kYfqYUEtO#7qi{MZ5IUdiQ+b2 z?g*YBZh_BWlp|i+#KXid-h6&*gE^ni#}O;ve5laA`Swogq@-57@`cAxUh&VcOFEms zjLng2Q5xElm`qs~^B!2gQNkZs3gY8?!1kd$fF0PeTmHrwgAUvWi3Kyy4omNr!H$CK zay-e7n(J~D|8-cLT!+QUb@o6bL{fR-S>7>9;dNQw5s_SC{^o$3t6$oY3-hNC7Y_^Lu%7&S{i(6<3Ua3p}S1`l@eCO5t3w}1uUy7Ir}FE0owAR*X>~ma$^`D0rTX@kA+$ z@=rKM_Lu$I)t|7h!6AL^sQ7*e&cM|H`rW$dPIw79v(`FuBIh2cWqFb#N!`x$(+*@$=^EE4W6$-nVdL*Ol*H@Yh}vl(v2oI}mIZ#5#vaK6j0FL35~lDLwM zTG&cfg-^1<%c|4hX?Y%SIX13o_noJ2S3d@81ME8=yl2{d?}g=2x-P%#thI8_Oq*GO zb6qz|t4Dv>KYk|J<#}k%m^lATuEWA$0rG(lxWt5bqP`D)DC3`bOqjD4iw3xY0y~P? zybj{mk-)P>5M2@RJ6>+*Nb&2?#jp7>O8lZ+T68%>{Mu=);d!|Vv6~(c#c+sGH6lhc zOE!io51kQn96HN#smts*bao7~>p5f~~K`mZ4!;ipX0x&IS_hGifEb;fe(ymY;yglp4Iy@)93T<3?8V?v0?6RKq7}9s zaXr@G27s3VK!_s{5&!qa$UF!wn7VC?R$wat5^VZ#~f@F`-N^w zfo&wJI~d-~CQ7$4_i@bC5e_)etEU#f?Kqz2|m;Pish^S_0H-QUuf{|a*+1IkOFIBf6Z+CAbPbx`kBwO-a zmd=y1%Oy{K0yhA$6boRZ%jdmp^dS0EA317zUqYudF}63u^e2uu*mM+2B` zlARp5*ya9vsgOMyHCAmz3(3<$8VAk0e4Aj@@9{Qz*MC_u zoU#@FeRhl(?UEkl-~1icz9f8754v;fu@P)jLQN~2SHBp+btP9GpdrpyH3cnl*2KZ`_sZp}yJ`%QV8Oz)zHk)*s9gK|Y8wgul)rzCS}v`|_R zaekLGi1ZUtwCaUGn~P4WkY7QxBaZ`am}nWLiW%qNx1?}>Gjd>quw)_7%#(8v9_+$} z&Ci%3m^Dbq*izLCfkbS<3>3t^?Lv2MlUvjH-JOel-3JH{_O1u*OSE`WD^fC?E8Gd6 z1^ezxOysK_ua?h(iRU-N8jmu>k+*&F1mDKs1aisrL6T&}+QdKLxSpMttEE)*%Frg- zgHWOMH@L*?LM8Pzm8=A=S)lEXkUj=K4D9Cq9$y#wKttG27-U`xRq3$z5sfZ z_i~IyMJdVt4B=Gt@j=}=D8!O}DQ7Ys}TR+mX@h?ZTeT$v>s(tiQ)=NNV^QZTD zCkf+OJp3$hSxY7-=YYxWhyjuFACCcXG(PXncSF`j;;Xm|7k_=B#3QkWH;=DC=MDbLWA*(55n129oMx*6Sty%6MJpWW~b zIiZK*ze_KQ-hj#~X9~UMUqfcF9&i!FrVP~*j?*HZtwXcj!7VzEIgfLFS~31bI07Vi z-8iN8@m4_QPuJ)fpjr2A;!pZ7$z6VH1rz=0KgExD0Cq%7m_Ng_TdjZ2QU}#FB%Xsr zSZiH?L`$crLD8+h@rJ&oS#8|~ead!!y>5r$T6ryqh?tE1*%n-!p$!KXKnj_qG2?x` zCrQ^z@ce%GIch)Z&vG3BBI5Fo1dmm9B=h2rIQj%?@36fUIoEeF-~fVmqX8fYE6WDt zw*MdiTS^!h07ZVmQV;f*S+n6sN%snApR~^32n0AUb8=JniVX~TwL@*M#+jbWF)G~J zh+5FPSp5bLv)c8RLU<8R!_X^E`VOndJg4ulby2V~B;-VXHa^&1+8oOK{u+H6AA*Eh zPVz!1-NP0@F1y^N{^o%aJ!s0p8_M#ICLf@j6CH-?( zYd^PW{c|eZ7iJ|VeXr!c<^7gX90~?`5gB#zsda||N<|7zL99`7H+sKQrzIOI={ZzM z?Nmwo6>an&+*o4}zVg=ja3%|4SJ-+fAF#l)I{DBO4|#Y{{C5)HV4@oI-@6PXT+y>QX^k_b`24Kmq_>Pbx9p+yyZctg5#zw7MkW@4dit=(0cQcn-ae55RNi6?_1m zLlr!@b9WkDt7x;*WQR`G#tnz7%fNQy@I2}HRUnH~HTv1cP-FEJE(NrUq}7v+5v~PN z82_$^d-iVA52b@@Zw|5lvA6~I^ow8qckHf5$5v@#OPAmM4uM2*35 zh>zvzrxYDplup$iPCy4BBZ3S!gHUZ{FhMZG8e~|UCf*#t+tgw9`G{TJPwGtz%JSP-Sa!ES| z{62X6?`RtjXj-~H<~KWQdxCufKfq`)dKvo=`bT7vA0c!DMUn5(WvNvJhDE-`l;ua3 zrB|O(x9>nNZ?fjRu+b?`YVtPt63uyW;Jru|#JbtqDVs}OFY`Sgm5*>>j)HdKtQ|-= zejE8H;owK&z>kDuN#uJ32RNn$t_gpLf*&7PXkz$V{?>qRlW9khGM#<+uHJ!@%B9I1+ungXgs6&+?Ffs7DG~7-67!qG9f+lnVGJcxmBFNawBC#0P1yg0Ds|#U z;cUQuXZRb-KsJI_EOTQxU6$bob&FBv((pHyp(xbLTog{1W%wan=Cts)2yD*U+3b^~ z@Fy&Iz*lCU@FU5)8_~fH-iTp|K7nTQOB9SK0XFCp_^0`e?WKfa{EeBcx5W=(7=IrA zR(W77=C>uow8}TZ)xP##OVXURPl5iH zz`ywWN#y}fz@GQ@6}30X_fZNq?hG6{{upi9quW|(w6$7q>)iaU!Q3ty``Bpgy{N_z zcVg7+I3c2B)6wlja2f@iJR^)YhH90wPM3J!(od_*!jT22pttn2t=!uac*I0tj9??> z*K9p|2_oCITVUsQ+J3V-KV+adB!1KRXgWC3Xd1tgmRSZZ2N>w}(b4ntAP|_pF;O7s`Fp+hN<+cdp9N}z~g>}1RZX$H>fiZl^qqMmfS zX=AjnOfOnJQ$v~W1=;2LK9Dq_n&qD8x*UBS?!@O@KvOc{w+JvB8ifq(| z{BV)qEUsgLR5bBJJRmNRtX@I&GA1Q$_V5M5Zpwe;D6}zO$M}+jGFM*)a_-T|>6x#n z-;@{Tcuoz|ar9*N-I&RWZ!M^J4*D+l8$K&r4l7CMg-v4KA5EHg`nqwZhTa3~M8%6t z{R*hwB54LP&O=KIy@pS~L4-JD;kaN%^!Zia7kLQy`>s5n+U(5`A*?fXb3@=8h`^QO z!5}U*B;ErgZWW=pur_JJ2Uk&(t?E@gxYe=CKEMK~XzauIajaNian#(9z0li_ef}K` zSZ>A;wa&&z=gScC2{_(mt6q->ELLYKg=0(b#p4z#y-v{Ar-|iZ5cHE~o5f8ale#8Q zt~ZyaH+MFEyvy0jFT<^Ty)!8xxWG}h$5xevwq(={9xZ$nrf2e$wFMc39n}Hs*YV7= zW)A^~dOUm24d=hn%>NYgw><{X3dcT-XIs?*C^sm4mtNRb#eiIJ2`^PYDb4-NrS7Ca z8dHh`jw%i{0(6+NfE6^iBxl9A;lHg@)j4g_l84B!Bpcx*}ntJ_@%R5 zg%@}(b*X7P#m#6QDB&=Tf85T%?`4M+?@V#|5w0}U=qenu)BC0AGq+7r9g7%Xi?}iu z5OUD@2E{-0t@lBj`KZX-Q~fgV1k@NdrCkP>{B5>h{EF|jz=i(}gO|R|cRP~wdRggX zvQl)W`0x)nU5rkwx*8b>lgsbfnd0`3U5pkG2ENdfz0_9q8^Fo_bF1IsTWcWJW{sTj@v2gzouR#}VM=+a6puG}UiY2Ci75RG*3 zR%Q4WN6pO`B^$(bFnoZ*r;B1J@g zloI2%a63&%3oa-xss7kjHHiA=lp4Q7Ch_^hXs&SVJ$Uv!2nnF! z0mHyMMoJClFEH~jV*ZuLk8I_7He1yXF|g#YF(pRsSFSBM_bMgEMe>A{lo(HfY5-yY zBt{*jZ~4T+v<03F{ES%;ksIr~kQ;L-H!hQMqYwZPF+*@XjJjOv5e3J~7)rX}`2P2# z?GDe+AUOUE!)EYW)+8mzBON4%zq91HB}Q_T%UUTpo(F9Y>C#6^&8m7_>q!Q1-Mul=xpfZzI=fV%lpjBZG%&8`+{weL-93&ou zql!bS^1{&zK`O{cSbIULR0`hbu)my*SNi_qck{k{zHw*_d zl=5bnK;94+K-oGGN^yPlMGibtGT(xXC`!KoKi)JU{b2mo1SVnwAhIF~=ikF!@1pd5 z_(6V^Qp#^_Wn#zt(2KD%6{FiL>i8#^m1i9Sj5DFrFkdR^Eug;m4MYG4VuP5j7}o=O z9sY8^$I$DxD7hc#dY$n=WlKM-Ah%~Q7{c2#-5^g_{9*^7$V43KiR|kO6%|)^jjYLXEydeHLwd z#uB8`?Z?NY zccpt#OqorNEb%Pf=x{(%|8H^(i5+`BySMza9W%gEyp`&=8L`-n(vKBYs2p zr!SH0AwwrON*o&{ij5M($ZTNp=%2wLV8X)FVLy?}iWr0>IWx%%dBO=`3z5rfUB$^! z-Edd>Pf)lkf8?Q@?bk2Fm;D^lDgYY{*F#nlbdmGDQi9ti+1j*z;Pll3xvR_D!B~kZzUjCpPn+JS;wS0tFzWd) zY?^|tht$-yQ_@l$HRnlhI$yhW5sZON@K&FK;3;dowJ;w-C|BJ>g$j%lzG+7)4H#I* zP^_~|JGG|uKfKQAI&w$it;Jz^j z+G7V>yIq+NDj&pk8P^vLwE?chFb_AnwXqkXYTR;y&Q=<}MAf6~QT0B>w_N0eyc0x! z*tY2bl!LYRfZSG3@1j=kkUBV0g@S2y*tQP^t#z3B!6Ms3nLj|!$M%vT1SBeo-=`8A)i}&RpGU_So8=#%s?O|g6qfw@D=ak)el7oV2Y#jO0X-a4D!RYmFz7@5$#>u|Ts`{e^@@?< zrh?Oe?fFINOCeYmk5cC2Kk%QBo zAa+1;HlS`K({YS-SX0L9rZDZZq@+ajoE59HQ|fmm!iT7(SY7X2u{x~+&-KpA4-*{l z@w64McEY)OMMGMK?ZwuLk1A}%5Gsh4d0nA2UfDyLDFyOS)-VW9W28&@DlIB=8+mhp zwPJ%KnBr?s@+MVmND&u-9LoH5Ft*|gg-9QXOcq9o*bROJe!&;u-E9Xs-iFERS6H`I zY`|HWCSDHLaIgo6wYXVl4X`<=)KYWRx&r=!-3!^lEfv?U8-JK}SWv;Ef2R}<(E1sV zD94yabVPm zd-a_MLq+2=AlGcu$M?byE+w7kRKHYwkU$tj2*&H&*Tdo&x35PEqX_j5W&ZL)cCBZW zqOJj@djSucdKwN;uE2h^4y;*^WjuTax8$toQB%C7fPwfB_>*=AA5O14PM=zW4sWgu zcyr;H+hRM8y6L{P5v-4q@W>vYPLLn@`)GBTze&-?&uNN`BhH*dVA2~0)+zoV2QG_= zi0^8-CAGr+K|w`;TRUruKPaeFH(?WQ0DCDFN_`yR5z4fTfk4LYBQDBPkmr`Ou}vDv zoR4k+t?U>wFyDNTLw4`U${oS;$nc~2oDv)%lawaF03#5lL+e(~Untod+}fkbLBBXS zr83m0?{Jc>`aGFS>R>le2+>e;B9mquQtLXYJ`FTLhUD*n?l-GSnrYI+b#Rgq8ld`@ zMbGjARH+qREU$E1D@BT(c7XA3tzj3W6-l=R;gkX@y9o0c7^L!00(A97kRrfNUyyfJ zE2)ov?=$pqJb!II8@hR19sLbtild{)=-yAo&jTNZXx%;h98>m&_+?}ADDm@fE)c&a z9pKgqz1j$>gryQU+w1Pe2e_BysgAVHQe2ju)m7QsB4zt`QTEiX$~w)miZzG(PMs$Z z+4j3Dx`5kamRD&fkF|hetX4PMsy1^sQ?($29QJPYJ(nLc0f)w2xIKZs$a+lI$}b+n zSmd~P46H+k4iE|W;8z2SqimVckK zi^J%gV3C64JCRWEu>A3iqSN#UI84)T8cx&wpjaloJ#lTa9a4@dw`1~e2b`92!#}4Pk9GvBwusDs$eyVBBUbCELeaE%RpchqLC<3MAA#!oTE+1(0iO0+$pX$*3HZ@| zaWO=-(o0V2)M zY))HWxKgRkg?K2%`6TCK`1lM{?M%T5C1*WSTA1Qs3eG4wcOj*XDf3*uJr$^sAKF+e z6BCd_7DjchJf_%@A`7EBR~b_rNSVh{@@<~WU$RhjE_M1#mfBu&E(dK&mOIrumjW%P zE#pq2hu?cL}U(!jW0Cl>vetrZSYZ^Yr z(chwVvlw0Ly<6kwr`|zklXpu=`>hKBWzrX5y1^;7zp#`#)sB>F^pyMclpLg7uBZG$ zPrQXG29HF}BzDHrG|ZaoE7%=FQE%0+t00;F7|r{w4<3z3qirwq_j zmLg@Oo{}t6R5=)n(g*2@Uo9orY7GZZQF@x5_^zHPSBXXGA*fD3a19fEUG1nHTZe}2 z1-cK#%&@*D@6mDK9v#JB+U7p}wsx2j+=X=xklmYw2Zawd#L|Vmar+;V5&{dMnK)lT zYQjqDbxz2VyP=R#y=oKv05biUa0T<4z{AKX&H0cwIE`9vb@B@2YS=`8RxULdD}YZO(M!ObCAGLR6o5@%f|>8h2s zIT7;jB3Lq9+BBs0XDT%ZX4JpJqw!SzJK}ip4!#cGd$)>%_Z{z~@M3_HNZFhxtyY+#Yd_ z%pm(UinI&O3}1@zGK1{cs0>TZ3}1*LG6VZGs&kBaRBt6H+OezXtn1K$cgnGAK=Pb; z6M1^KVhZNyb=Jwwo(;iOJRa=}qhwjvar`)MSK?!m|1?xK*3ZDY?tM4=@Kn|#0eJ4ZxQOcN7#v4s|W?;qy}<2Hc|b*GWQBt zeYXT{1|O%@$bcmb>9MB~+`G3k_Xa{o*$~>g}P*0i76yMQi+YWZih}{FHuwgOtE9>av<)71{6h0)U z&MZ90$<$V?9#XWi_dSR?^mHuioKk-_=Fm+-`7P1l&2*eR*9K-I3t}CRPvxQ%BUk%* zmAcs&z2@LG$F4ba&5>&kTyxxphi!P&LJ$tf5V<$$Q+K-G8HAW|tT)%Y3Yt8Nf1c0A8nm2m(7ulh`XP>8$I+(FSoycXuaF z!~T)>CT&`ZvkrbmQ4=r9;4^0C3S@9=H)c5NGW4QyX2myIFQ(?X$e`D2q)2Hyd5$UG zzZK(U4p~28kyD7GO`d1w_(lvy4hUr|j5dkU5X$_W0eWx|mPmtQ<%R8o*t1;lOYMMztbNf z1+CllM@T^HoBAW9--T{0HakSj~zj@(x!ZHTyni)US*EP~|82AOK_r@D5=>ZV9MSo7?^L6?&hG;_I z8vR-3p^k(6GS6iB9M``6#SQ2u-*DP#qkY(-{Y;|QN>X>1HhD!Gw}tDVqRsksjgQNU zV2dyMfHxy@mjP9F>_gOr@KQ!BTRXyulwnX}Bp>kd9^=(N!twu0SMn%@Jhd%el|w=L z#P^1wZ35cB{wnO-@|5v(6ouG^l-MA?lrn2W5c>^HzN=6v>lJ+nl+Jm>stqOT z=G@h#>e?+LX|?p@ZV-vr*Z0g_=hDW((XX^kKNr})24bMCM4OH)6{Zv*zwYx*6^@z2 zw|DWo%&*-w50Ic<QW}8i?DVj77tzx?- zcsK$`49=IC;$wh?*(v&GUsFmLzJ-9#rB%TfPgbTa8!165RyS*xL2{$co!E}--KNd8 zFk1n#AsSb)cGEjDp8+J-U@sycim?o`FMEgC?*)wNb`wZ(pR9^G`0+t@r@F!Xikp5G z%kRb7vVHu{$uz15(1wI(nhwvh{mjEz2aTF_n0ZFUG(@Iam4x{Pt(j00;$)+_sXbWL z9OObhh{qLXh~3qCcSw}bi;@J70c_k0XErHbMW)^op{FE5=sol)Kcg5jibrGy6YFPU zv1W$l$RJhJ-fLkclS(Qa8~=Zxr$)=c7(3DPKZ!3lX(ys()et0bzL%~juTUmKT%u3w z5JgAPrWWAwX*_CPD^-c93k6(G@ImGHgI)s3$2W4lHuI3c79b>BmK5HuF0xF-OS3ntnw@F6je0y7rH7Z9>f0fVSZDmOPlXE3^L>B9tzyRuNrBKcooGpgle-&nn8Bw#vy>}B>c{t=$ zY^-q?bTn|m6oJj_5bo zX)@t_!adqAF_FjJqs@e7C--RKL(qA%Qm7$qpS;?`iM_&v;I(CJ2yLOtY0y=M?krCj(=94%BE>ECo!CY%(I<;`Ha zsKpYtDS=7_NQ0h^?_sY~A~MhOW^5eA-oj`#eb7GtZ1oPtR6eQ{*9P?~g_l)2K6*xC z@6~&HxxY|MM?ozLNgUyC$_ooUS==&Y@HsfG!Nn6rdtmeBq99@r9SC`c zxN{q@CzG5~j+>G+S0Zo6(qyQ*K=3>^mW{8lmN^ocfnf-^^~qz<%;f1K!ymqf!-C!< z00e+-)l)eYvF<+Qll;rCJgiMD3;Y;qY*jq6$cUX2a3LukGaN%&gmxtm_axpsB;IHe z4}Z3L`iryKo|V31hh%F9S|_&O=h!_f>)Xpv|;b@@*f;7)-Ejzl#qmI zS6qp8@2WG<>4BURC!wS^sE36Rk%fnq=d4m(D_v5U;TeFg&nU;kK!mGG#7p0DFeJ91 z>l2YTBls4s@x>j!op*jz>opY|80+0|s%y8}?*1i55~8#0tG9Synr=q%RL^2=n+Cu2 zeK@Sv&hMyf|2w6Fx4MV7xVC&=TC~2@HW6`Xnx|^XW$vPSk4=`s87suyENbz7?aFOY zwj6X7ZS|h(()yRJ34FD6%^q*+n(wzauoIEb9{h4m`x04{#>y?B}m!wmOf1Fm(r@>(fcPq@+)+wA6V zY&TiTZQh1*+xB`Lw1$k}=YXr12XL`HqYV7pTxz{epcHs-0bE}%UH%!IenT!@%myWC0jF7)1zHD7<#yyiPkFTH=zFPNTu4R#ku_AyA=H<(gU zD64BA6~94UboZ0pbT^=i?U9ZUO+`fABZ2gM7$kHDplUOq8l-oP$Ltz{gu8>+c|VgN zr2!;c)y*8NIA@9EuL9TdC274&ZRp&dD>rhl+!08A%%4T&3+d(1>W!Jvm;PpoLEkuSLAHBOde1oaw zPF71f;szPNcB#z~mY028YoaumC=rsK5*^QW6P3NeH)5IK`0&txgG42_5xf9Y5FcNn z63qO@89Pu3Zw8V0R3g!bNZ6_z-~bbmJ%RJd4_ev`j9Yh6gC~PPXOMvKcf_y&0soVu zw`*3y;3>xeYEy{Bh-x>68@_|jBV!n26k|BTz{oSh$YYZgNtBrD>zKL-0oZb1g9Z1p zstr2&y5#!Kz&)1xN(VQ)hpz*&bm-3dslV>r6Zs=y)EPO&1|v3q*)1 zM-34V=F%l8+LY24qN8itM1MId?9mg!3BV3sE4SSQIpf7t5C)&qzzM+~mekN4L2k(L zh`ct0wU(UPLAJ7AbJ6{)y~VCvgggHTqj?J^EC}fXU)8Vq-eXWWETlP^eT*?Ms6$1D zkdCHjSI@fiBAbke8ZQ0Jxh_0lFn!7a6U8(xwMA+Mu_8;?45ZBJN;BBzN#;}!)+vh? zT&tljzFew8Fm;<(YP8$ z;x&hF!l>}b=xh43S3VmGMAWmMuIJfa&+_B~J>PbD%9W#xiMHAGIL~mtH==*thgpzZ zV&`mlocfoo`deAc@#tW>!t*T3hZP>~X3H76nh!C0@v&-QbB|98lZv6;0O*?_;$tWG zg%*LiD~`e#JK|2xn`*shG5e?iYZ$2}{{p0t`d449WeQVmRR>5ht}woil3P+}HN(#a z)7_Q;MkJ;!2Ej`3NUHDpDAgBJ zh^a9`_1zK(0v9=^*2W+OAi*KFDxzv2)quwcQvYJP$PheUq`V$o2aY3VyV8NzN9n-5 zY*iP==)h-59XJ^}FyV&|%t6tK$2k?BLC#Sc=0S$_v&yL2B*`hJRtR zGPqtDZqk8;d%)(yN!wH@91%}H-xu=`hm%hHSI@%+8hoj4TZkR!Q8)3N#u~+6VlP%d zFJai>Ev4!%Y)mAG^>bkae1+~#Feu^ZVo8d+G;RMQ_aZ@V!Mv_+9=sKortn_wYqRYM zzK>EutHrakuyG;7cJ|B<1>Qwwm%5KZDz(XgxlI||tPICkdlDZM9Poyh;F9wYiPVM# z&XQE6whi5n|6t16)h4b(T}m#Xp{W~YwP8(3Z-AeJr-+-U(T*z(rbq!vyk0r5s= zD?_{*+VD1r-7wh#Rv8Oao+7}ZV7Yk)i*yPqFIMYOrUZ7%A#PQxAWZ5uI5mbcuK;8S zF$!1cUI;?O=y2#7O=$~v&4}qZ&Ujl^f(Ow_OA?Gg%kXkgOYKVjMq!yx06}XNv{pfD z?Z@HxfB(nai)hd8%v9Htb}>xV7Q&VGYUM8C4@BW*1v*r=#lA-QBJgVhC8U{Ia~3#j zdoaJ2>4OTQ6qdD-Fc~zQqB_`&mkN2)URir2sow75eJL9h)lZ9m;Ca|oyEPIcTRn6t zk%wUI0EzAm+#m;3w<46wNCJX&;LjA*x68oghl~Su74}+murR^fSIjPDcd62O z!g;-X*6|JJ7#o%2-*Oj0Wu;@!I-g^f)_wJD^P>HqJRwPzsdwF*L&yIH)W zr)4o4Uf1idtVX=5Ka)OU4}5GC?O!=~enlttGF)Y3?dKuEr?eqnERGgI4D=&T>B1+A z_7ThY>$?N=$BiD-L4O1xW)7?Pq5QHI8zD`01zXeJXEA7ujhFCwMeI4u4P1zv-Rhd- z&P1?qm4r2KBF+v#A0&CJg((JZok|LH-aBC(r=rc5SsZ2i=>CLyi|abJsP8SIj2@Dd_n5X7TW~ffGIElU z0Qa8o&@tc5v17iQ9HPHRkDd}JDsuFs8KZ|;QuW~jw+nsv7-`1%fo)TcA7Q;#q8Ssy z?5O<_+4m5&m!iB@O98Ln+@o5b1~}F0cmd)t?#qmpVcW$O*y+4iQ8TOV1+WmMRacSD zt@_8yeuNiDVfcR<@yW30`&2fr%AD*y3 zJSPz=F@DmE3{|)R=sjIg@6KkuJQlM>lJMbdT~xeI0OsmJVsZS@jDy$o(_n2&<92_N+5Op;X1_azv_F6eECc7oA-02fP#2;KzW_5-df;*imE(d7#Pwg+G zilzS;M1*5>l6VR;kvcVFUqesZ1FLN-KkQ}ub^RGFcu2uRRf{*tzYL?R3&*CIp6mLh z6Adt#<8Cn>&xziBaLNa!#M7B|5^)>>#YW=zI_89ZlQNQz7a1rr*n#BTiJ-IGHH}N? zip4?c)zb?T7) z@L}9Ecx&ZHR;Xr`s}nQ8^Fyx2M*SX&SpW69oDN(J7FX1%I4Fjb(PB3zNL)S!pP*Sh ztov8iH7ToDo9^7-syColnkXx^u+k=s0LK%WQbec?4O#U z53bSEy!(O$`x+9xWrf%Gw^g+e^7)hc8@v9!#f?xV*z`;I;G3F}h{BPQ#+Y=eZ$VW= zvRF~9=l%m&6L(bCC7`+C4Mh#Msw-tmmIQi#t4<<=B2mDnO5kl(U%*>5jKKTQJ_!PE z2|=Z{m7_-5(%6U>kUg{S5OSom0O7 zNZc>K8t*{J5`$1+6jDJ5&mD@2S$?w|;G;3Xi>CJXUeDss%i`WiZnbx@x(0hD+)p0P zjaV*Kw2AuIO)d9*{=;(LL0mS7FV0YX@Iy#lY|CN0Vzkq{50?{prrK6spJ77J`^7H` zgB={w2{G@G@K?7s9ZZW_Y19=eH8qnnHXA-j!peLefB%_2-J)oiw zRqRnvq`dGvTh#-2!1BWZA0_d^OgZwZD)qD>NTW93hGq{DGacE^GLj1Qq;W_ZX(TO` zg}oQA?46K+(_;{9Cdq%viCmmEN7iz#iU}Q4$8A=5HyY=uf~ZieY;Ujw+Q+9W5xc-1 zd=b7kJC1_}(wE2qp15PK!4o)>@2u-(KxGFVFwc~U8VniWcAB%6pQxbV(>AdSdJ_1c zr_`o-GhO(yuDO>}Mj!Ep+sNGMQrp#c1sy}--+}tvQ1Ea|ime1D_G1twR6!t1N_ZIw zWl7Y%Q{A2Cl{j(I%vfLuTT%)@55ikm;;VjBy>+P*RGHvXZCdih59O}j(yq+MajEZI z4WA}YRr`+=1<o9{T+w~jHA}f<4ck+?ohl~SkdpX=kPl4qk|6_`BeJX~BZv{HG*gqfF$*m$IDt-ig zSeybso-=X20Gms8&p?P*CuU%nwbOqx6$4?DJ|E#Dw9O5kQe6BfGxij_5WpyC74IX0 zQE}n?46hTuXDH>IoS3lEfri9=C<@XI<6V*J2BXy9SSn3CiBc&120|gRu&wGcN-0gA ze@D(U;jV=iy(yv023)Ne#PVUAxDeMQsjZyBMk4cg{jR~mc(lEQYe{~EeEgP*1e_uD zBsu-3$tW6o0gIx&K#@a{1;3_|6kAgYvvskBc)`X9HA46z!D?{22NUDxg-wOp}aERrtDcE^}h3@i@IL!6FC_a1P(^)89RV!sSsE zW3Wji%i9w;#qgb25Aan%R;0@4xeFL?4xhfwl1Seg8Z9q^Pb_+hVoUQ060F7$JLm`iCI~ zZ*YR5YLAiByp&Q*fafWC)s7|OxLJt_uVRgYFh=w zEeVhXWLE)E0hfBmals7|Q0Di2&b>34Y>3O--~0dl`7oI~_nv!}=RD^*&vu?C@7mpA zEh{oNH!?TN=#$Q&sNS*l9gF%;wmyZIYU{hYh|@H1Dr|pW2gV&VSAcLle3BksjW?$# zA&qL){X`?eTO}ER!uy;o**~yQ!C}BA$xS_xY5`87a4GpI_c*gcnUD$grY|~;Vfm~s z>T655iNc@qeq>T^WKvc))k)_*E}Fa??_|MvIz-Euh?eb2v_#}#1M)^D!uID2 z2~t2v6h8e9@nZY+DpnpMM0%gaF5`z$lJN(O4Khb+{9WZs#YL#uxlwrBATb=*AClbc zi7fsrFQ|br$g^1j`hJ!`8M!PgewE0OR~Zf7adQR* zU4g2zln7a*8w1P|7(G?|xNvJ`*axz?lzQ{-nNEv3s0qW1&>7* zUpLkuy&hs^AG$vzm@Cp(q))t34F*1fuC9`y4bQxGWLel4LRO>`r7cCAeLR;MNHZ z|5yC5aod)??5$|<`P~rvf$@UOyUn}RcM7Tdf}zH(vYvay>kfG=QFz$DWe!7qkF^=` zD>?I^=%kv=$1erZR7Fw-beJ zpWE}E^<(soo%bw>=lC`EtK>vNR01RvL_F{rtK+9fCq95OFneyFW!s376(3+J7_#T) zE^FuaOy>qq!>%k(xM72~bhWsKd!4OfKNY9&m7b*iGFf->JAJ-7%YnhE$bi9fME*NR zB+UHal+Gx;C2~8j}N)8$sg%MHj8av*jM+osj1}aR`?ub z^Eb}5X@+k%l5#*K&=1Y4#wn@+JR-iG5ua&JmmATFog&vo?|%?z>5)2NYV8PKM5a(Q zA>tGh<}e615}i?a>6u_~H2?1LnHdRAL98&h!SHz_SL`G(hAL0t`Ks`2iRa3%f$A4( z)QX*ErHE=A-r~|nR(9{WD|TwN&(O9}IF=d%QB_A`H7)qcSvm`-Tmp~WF5T;1okOad ztE$^0m)F>3&QncJF@xnY=nV=zlI&^&&x+v##f;!Ve2?aT{4pke_`Ms2RkfM6KD%IQ zd^@v3LuG97!<)GVqY{Px-U%b>Gb6q?Rp)EA^9~Tp;Guu-YkG9rPRpsle06_P!dylX zC02ficZCfQcLSs1O}nXE?7P3ZqCcDFHJZ$8IJU=en&9Q? z>D{tJ@Km0BmnYnO)=d>&VhIWZju4qB9I5IKjx#FEfGx5c>y&_*DC}=NBg4tv(tCq5 zv*)b#M$g({?nHl_wthIBjEwONjJ0TJk}1?L{*O5heBmnSy#TA>#ei}`#LQHdecl`* zJQE9hbBllZtl1Zh?)QKxiK5GhgWpOB{Qv&U$(i}|f4qMu?<;OW(E>@tTcpk-svPWX zMxMECjIuxW2^gSg;Y^AXLVo9&%6!2A@69cNvc^Cp`$Zf8)Qp31a%e13_%M8^cy;8D z<{dqf|1U}y{mch_OeU@yUo0hAJrx}et`!j-vw%J%q8EuTVzd%bQqMIf(-5CAr%sRUrouybtW`xlg6sQC7LP zta7hQxgU2a_ct_q=zXHu4{|}H_wg0e(+bhIKXFe*bfDOsRZu%k=~`}4mvaA*afq`E{gZJr+&{=TF6ybA9Qp22 zj`+Hr#-ZxV?Ov{LPvtBnd-g+Cy9$16Ql091Qu-(QJKFudRqpT7zbAVthe4rhxnFcC z*C6%vx5~*pGu|aq-&I}8wMw~stK1V-xo4%Er%SnwQcgwSiDo}zm77pNxuIRksc}fW zoG#<|5Zp+|gKbjZK&#v;tG;!7#Uv|hdbwXnIW|P8Z=qH0CMow&mvU-84ztRo&+q)6 z${pUl9HMroc2#|Yx|chtOF4!25-yPbrLPZ1mvYi46(EpuQEMEx$~d;Mf2WUEo>?IR zQ{%l}%Kf8Dxp4u?9c{IHJlD+cxA}@ix|H)sxnWkhQC7Lrq}&hE%k{=9>&83S5aiTB z%|BHYUB+@H{Dn|L0p=1+z3_}*D3=W_0k5Gw?2W{o5Y zr@kcQQ`{`I+AxI@g}YvaZns?+@_M6_`baRAXyIA;u#NN1Qf&9Aj@ut#Nict4-9EzJ z^2s=nk*YE@Mrf}8<{GO{;pQye^|@9%js4S-A>2K(>&6=Y&9~UYXvHyDa>M_YUWu<} zYidfq)%v!2M&_2N)n zwh^{uaf@uBt}R;4JAhE!ny`m7#&+<-?|RqDKVyV2px(PDIXMG#*AA_AA0=Wp^M|?F z(`{~+zR)o@qJu~j`nV%=>HXiv}bN^Ld?#ZU7f{-X&xpg2QG-?jW?g~{D3vVVoI_X-%Fd46CA2c6kf?MncONSmqOM|uIbCDVX9rDD^u=YgW4V}9eWpCm!KHVI0DZR@O=!*D_C9jV3OFsmgGr(6>uw2*vfT$`By>8Uf!|nJY}0K&|qUq6#ketK+Dj1 ziNZ`SZLqjOGg5FC{#PFvKk9q|i)WeeSlk_`JZ{&R)z$;?>{BlHGPa8m?1oYis3X5@ zL8q7g=*{&+jIm^sRNNF8)9GF|z#%lo#;bEpn?AlwwA5ma4Hh9!)^8m1^5FVsurBM( z4N^<8^(k1BmmQy(@dX`7Z%^7tGV|qDdt;@&-R&LiJ$Av6i~n#X{x)6P+y35{ZtoG+ zX;LV-N7ih#@J_zW>a_OSUYIlai0QX?Z|~|a-=4IQ6fWwl_G+cQg0%LwzfgMM#D6UA z-roLq4{3Z#mW<}-qp(u)Nruu~6@HF$p!rCf1;;|>t@OK>PChYvGqWWrSnrq0VQbhp zJ4wwQ2-9^xrkzR;PMjzNKLS;rp?>s&Aj)6lDq8qBUsgD~(X<+{&WT(`!@1Lb{>k9F zzv#vt#ShY;#Qwr~AxbofAZgSTS97UH&M$To%m}>$6z>+50!e<9a$U!BE=LM!kdR(} zV@0Cy)i`T(w4nc5bLuDvR0|bTnG~j8%8jJDRPDT$DEx4ZkdLle-YdVp?buSAN`G@j zX;Nt`O%$AzzAyXld?|Y*koqUrWWG`ia#`#Y<>L09`VspqCPb``=-N zU|lJEBC)4#juh#99lZJft5C<`ABm#b*u(K2ELybSX=be1yIGZ^YS7ksbn#LuA~ zcNABvnOei3=LsT!0HwxD);tI3Jy%7F=zomiHGZ-+(^r+qOamjV0PqLT`ZY3R4u2)?s>$A87%} z`z?Dp*oc&8qrJNmYhQYZAW5g!1=1f|K+mwc__+&Uxb5BzrFRcqcK*84hJeg#fQQSlrs2UGJ zFbfCEKx|FL{_g;9MzC6}Ibv<0O& zmrj{^$M%HtoyIQaB@TNa(s_*CH2g=JkRD{;mFmHugu_yvnD2aO!Qe=metFaA$_WqN zh!wyF!>exrhJN-Bv&mZYr9$}11@8_%G3huxMn-HaVTz;|_^I+`USqc|INfsb_u7uR zg!A|*oW7Li74K!fbb{cHrSi5B{vnVhIqYuVJ>WPrAm(Aig!7K(zdH_)d&u)yE>~qbQ!t)97Q`-v9cAl|LN*&>P?I-oFcLYI5(t@OYcpeZk)U-irUByWzc9 z=O($1{03(`^83(+bRm1s>C%M{>B47RJt@jN^S^~HfR>B|lYjgD1=kG@{0obwG{4Sj zF12V_$+fSulHJ1&wvtovgH!fm7PP&O>54ggQ1wDKvRmaUT6ni~Ml^(Gq1~BN>CC?K zW<7aV&EwvtSw^QGWQ++$k>f2G$H_=L(^WU=o zC4C#Y?TF%=Yo6}hw=2;^_uRJuhtxNV?ikycu_sTXRf%f|kp9FqK>9OZ=BMvkeHbEr zxZt$akDl?j4yt2f%T&8+56EHjEAypZl{O`seU(-3kEGuF?0O5RSAY3}yC!^Cn<%`; zsxRGarhuqm*s)KYq(COy!-)bbTSMB9Yx69-T9FK&Jb%K5n`^dp-yKe+8S~vEd!M~@ zdVGrvz*g4Ivj(t82JlMU0*ugO{{=(B&raK$MvvF+=p8aPzN+z*Z8yIUU5sAma5aZ? z=Hb&ZVvo=MH(!kJ1HPhD2AMy#8#{p#A6q5fv`W0EN)(zERtas%cFnhgVE|1T$9-k;95@w&rhg%~$T1IrD z^|($R+lHc`^?0E?&b1!LW&6Ov! z3ZvtHaXty2kD=Ee>(t7l#~d95D@9w7(6Wci3v$?3$+!7+(q-FF7__>)P`bSHZH8-^ zL~5!PH1hKWA#IyoyHzw(5b_CClmqwm!HXDM+tkw2AANNXLroO^c{`19e|#BPOGRcz z*Fcet=b!)6K989Cu?U>rsJ}mMfSealns{8z5{0vQjko&jLBw{1vPRd(Gs(S+RN)qX zk!X>%Y0m&9zKpot4Nt5&Cymf41bu$=yL6Q^nW%};Tel~IxVx1+&AsplKBOOrW*1N8 zr)z6ytCa}2M~$D*4D*6P^blnM%yH-3xeKvRS#g<->NcR-o#@1_!n25;_OPd-g)tEx zgxA2hf&;4_ow!rq`!N9qXKUtMh<2kIp|h%Z+TheEckyAfq|qseAdQrhq@Wbo6V3znS+s1yPUJn$Q2MbVxf z$u8$XS8A(=k1yhOMiOUve_-l;O9ztVy=_Z;(o06C(GG2;h>sVN6WA5oPweE`4w27rs60uBDOQlQG)ybyGa`B1+es9^P z!3`t(qLE4X8rcODD527@9Jht z|DVpQ&?i5w^@anZ)Uz+ZfpmYW^lR#V?|22fvh2U&{+aI7g>Thq1E5xX`-bz~F&D-* zwS}64d3-xn{8?2|yPX{+RLG9{UFAqRYzkk`35ydyoSQ!D<^;JZ!hvdv4RU|xwP0eV zRpTq7b0I`We$rs42or@IN-sEjOQrv&h9=RKu>F)^FSk%|b5HBDr+eX8X7H47EGu|i zIMz2<7>?xxbHnX~y}}cXE#M(iH_G>)?C)RO-;3nCYkghUQMf%*Dk}_1m;==>>lKC) zJ^OPu9fx*Ty?1@&}ADucx*aH%g=bD3Y zHS7GU8m7>L3UDrxf2;L%oAq@&Ur9iyz3}XOCM;afo|@vX)&0@d{q*bvfzFj_ z6mlEed}Z%>kG-aNo@a@}TZe{SKzMApJu4Upx90>0hud?56T|KOg5$&OS}-^2i4&t_ z?m{L}t9evVD3+zw80vxuY z_FU=_JN~5roE4T|@PSOqE+(agNtvES_$L{hge_(odH*o;J#76J*v%JnaIpWo9-Wu# z8@)#jAbuR&T2%lA#8582D;I1x<1dm6a*K~I=RyzvuDF_RW%z3L1p8Tdzcx>;q|@cr zVIar!<781PQn_2-yiN}va99Im=htc^6ocpK0`$h={r%>S_h=8lG8?xTA0FpP;}49M zKYT?l1#&}E&ENGyr{gYQ*5~mlGVkDbv%BCHIw1u{)8c9GTj=O_`UDWCtDg!G!b^^n z5LCnT@Qhr#UtbW9^Ty-H3WD?@Yoh9kbUn`+%@M+w(B)8{vijJq_*_aOBg|uHm7Sz) zbLqLm?=_6d0{CO2iEZqMSfM?M4RI0ClS^D4;TAiYM~O``%*WL*|DLo!k-j@us=d!_ z26kfei0B3J+oTt{(Q};UFWK#^-puFf_O6Tff8lRMUlrpYkTU}w5wA-*NG)pQiO>(i z^WU_PnGd%gq22r>Q@6}pJws@L7XAyrMsFtrF3F>uW_2zD4kt2$*zYh?H8;&x41k*{;>Dpo@N^Ikru3F40fB zS$w*d2@Y!yw`t+u@yi^k_-Ey)RU>g<$-oIA3n2fz(7o3s%JUROD*R{dpQTO23F<@pk)vm~`H6TQCqiWWm~f(l2)99mcd!Mf5n)TswxC!Kz)w~} zU^wEOq?i9`lvDWBiGM-0$%$0+(LRdUOa-`30WmVs_YD6aqoKjfFLngaF&c`UXJm%5 z_cYXp@`z*9@7kH2SJ3Wj&H?MfZ3%G;o0OXna!0J3 za4wUfnQa*|DTiiCNr9=O|LV*pu^-7l;x~3Pg8Q@82!;)v3<;{r&f_Z(9iuYDmHS<< zX*FWBmTn5Q(~To^nAl?tJvGF_^dSyVL(G-%ek*e0PwB=51-c=bUUS4OToj-Vw^XEy zj9V#Y)#)PS6&eh~s|pL_qp=C;pXKp>kxvIwKH>cwpH51=fm7e@7;4q)u=wN>jFT zK{ck1wtB1|Cb;ZCyV6bp-qtgxtoh=y7M_hc^5lkp zPyo+jDbJF9mk2x|f)i42OlN_bN42-(CdMJlNrM{9e)Nf0RBOzB$}VPpkSRW7>g1%; zV!OLbzE)4_a9){aA%Hu41@UF0zLDW8il9^#J7toXJd=CYL`A1@aLWfx@wG9DLzaoo zj)~>CnE45NaP`8148vEX`FtbksJquG6IyiFs4+?6c#Swr;5 zydow47NJL-fO=~CbId&oal%_=pe>1KyPCB?vtHG*ToHlnlPP4r3r{Xu_Usen*H5IS zal?+}I&_LvYU^jTO}&DX#aY@k;R4+Xn`6@D!um1xjD@_ zunL@}UgZxrO;`Jj`u@NXy1)C9`R2T@J7$%gJ(}NqG(En$emWV9l2dQZkvSAG(3}ow zC&#&wzvB!US^s{fhdT^-z4hD4c(73HdYGrORfhKu38C}Me~iaw+s87$$3M)qaB;oS zeT7dbUIeWNo6kZ|Y<0mOz^7%RuR%+IiXVLdir7eI1&i0|kK{@yL%CPrk2ru>heD-e zh^(20QhW+drGM(K{rjZUZ$-cNHq>J}Oj1^hrq`}c|LtaH>s#DqA5`W@^9Y=dB=YPD zmhWjF>t{&qfqhWVK~LII2ZFCj%S|t!Q1ni*sE|1Gfqm@>Ig$MkvDRfBGTiifL;z@;ittBmLc zsq|>pM#1Iecar90uQ^?C_+@=uX7C7O(Ia4GZT5mV=uDc$>UruBa27r!6PzRY^RTOalhQR8^FfA4+Jje$=luz{m0 z)f>z)`UvvTH7Mn){v?!$f0}wWq9K%Hsbg7n^9yxRo$wEkqt?q&{=X~qhIh*LZVJEd z2(QlUtayRbEo3tAk7(34n}iL?oqOJFCk&EmTi?7> zPqg?)H27;9L*pc@aA|O;zaf^TOGI$~VUZrOIzV2O&9V4EeVNtA-8TekTRhsG4IVf! z4=h-Bj;%}oy7&}(I?jAm;?MO6)%wb|*VcRMj`SG&D~yerA0hE&0zE`0_X||DRFJ=* zOx(p=DCvn_e4K31Bk_u4g9wQJwro?Ar_>R-=w!H%MW|Yg6|rN492$L>TXWH1%|)Z` zYSe0Ls6`ZZQd@W0d?+$J|KEacI$QSw4<>-^k0 zr=B3AM*Z?wE}5sy_Y>)T(U> z4e{1F{YDPcs!LADH$98qJU~rxXOolkY#|3JC$c?@SBUQ9UIhei`NbncL#69`5YU;5 zj{1DjNu{DP!Kkck$A)8ZhNsR)XomsXO?OMLw51#T%emm6Mqr55u&^hq*1@?3!8wn! z9=sbj$2rrvsxBu%{M;sg!#i0s!;PQKUmrim%e>a}G9kMffW6t1JKcoJ5Aws=8c`}4>uKp8%J8emyjTh&Da{aP%PXy8Beuj;>G|q9 zza%>J1Usy0maU+y-d|<!9j?fpriM=+3VBjNwYS2|N4Cit49}tEq;e28-tfzg4y=JYke}N2BiC zLi^Vr=||FF0ZpvtNP~oBu1AUPFvkK}%IU_AP@kqgqx9%yj@tLGKXvgW;%Psw`lhI} zr~3Ml@Gx?=ccViNot~9W6LahOX-jTVts|g(GC*9%K6L2LS9Rw$y<|V6)gLCvM|9Ac zkee;$F~~o1?px&u<9NHT=Di@)*{2(4kLf6M8^2D+=UMKq!GK0K;Gxa9-WGhXUS=Nm*dwtjy4$ z>T#v$%W;76C^M`%8Vd(DvHO))_448(fNuqoVLN>k1$uIx|8IPE!7bt3)0SkLJw?KB z8hy#rC+iW^ktJ!oB#TlT$Qm&<93;HR=3YjYwiMMO5)bLWs=V=W?BVYP_F5qO>X zK7_By39s;4+^IXaLe6fzS%%;H8&4}z$qM#V-(W4R_2wM3*?wbkm!;)lHPqJ6|IXg6 zsz;$L*Q$k?Sk4p8)n`n|AXsbF+CX$N%MC~Om(0th-l|p0W!IOUeFvSb5DvEp{KT3T z>L5liJ4V_65K?!-+v|o@L}nK$dYFd1CMe5c5YEWe(bdk#+kv|0!?buIbf9j%jk+zV zU4$G9)?NeZ)|1~)?KOh8p2T`DOmdMP{v5J%G#i9s9`b87!6DS*k5*tdPiR^;up_w62!f znx`oA)T05S#n zpSGkzB-jxz`?TkF`$yn5*zPgbVdU30$BB(XyP^Iwae>f&RUdm8@R{%LQg(}L14bVT z(lvd=D*uR;wlq4YkFx*A&z+4(vL&voU$CzTrX>gv_5RwGp)ybSfRaniPIBq00FO7D zo#oPcpac3^LKmM!n5*yCCbvw5f8u9Ax;R{)8s0!_P z8sGnhIN{iIAkHM(G~D(rt*qc&kHP8YcI1kXl5s^Ej(+b5CF0urPdB8v4~rf$?oSzC z1G2Svi_Ug$ivf5j;|E`-Od2dt9dR;z0Eeq6>j$g^P`@p!flyzvfZQi z#GURX7|iZfJK>%cxmKum-56|ZGL$r=j~AIpt6f87o%9(VYptNw$SP}%k4jT#pxww5 zokq6bXo;hCY7~{o-mMZ>FudzCRE4>yIZ)qD%nG=+&d!mQ75^{6+%C(l0_`8mZH-%7 z@)8T|cUhSkEI8*TDsA6I4vB*02huOX+_Tv-@V!5 z+%-Nq6A(F}Z}L-^43rdZxO~K{O>SJut>-8jN`L(Lm(d-S2wtN(4~s^@2A z1f7Osg{^Q)@mxblkHCg%dwsZ3l1PA}k1WslP@ya>QZkY?r5J>Y42=yFypn7S;lAu@ zmSmzYVtY*7FemR>S*Wp-C{lje$j|_0!MqNc038S}W7x@u7<&Ij?JC8=STrmf#iVp4 zS&5`KSBeaBv#67)Ju{LMZp+ec701K!%S!3_WhZmq<8*!8J>}FMx_B8nyo{M%SIeB! zB=^H%Bz_3y2aHuJ7L|F-ew6>;5(J%ma?@n?WBX$c9x2;tyd*rn2CXuQGBK;( z=5VGxlaer95@5F8{JxlZ42-SOiXzYiN5n0GDmT6rzIp+Fk@@~Rc+@N`f=@xR^tFG1 zO||;{_U<;-tJTe7Q4C>IMKx65H?AY|&>LUbs%p(fFK`k+kgnEc^rpdVpcF3%kH2QH zz(vf>b2HM-&8Z>pkF_h?vC$^hyEUSaWV7Z@sA!s zSD5{-161SrV$wzB#IRcItgam)DZ8MbD25W_t5nf=4NJ&gAk>gLxSZ*pz* zGVbvB<%JBo#}PkqAZ^4QNIT9vgc*E+O}o4OU)}tABf=L8^?CztgA=u-S)L~|sv(sl zQYKpEQ`VIq79Vj8(|eSI8_SywKzKK;W&}i$MXuEx$%VIkbO=(*Zg4oi*f~y(N%kFI z`Oij%az*rt!td+G)FEEuyZt?j_9;q#BB%NCac33q;=D#W1R~q4Hytp0)~ePUViHp@ zFz%m~i1a9*xO zJ=wHef_n&~Y^;WMV9!_p0h#)WV$?CIqVBKK@yLo@t9i@kI3$GGq#=eoH$J6lQmF&h zta;MOvT4L!)M!zAt6u7(R;iLaJc=?FnV)S}w11USm&W@BB4ba&He(sz-Dv{3&2^W4 z1Nz7$p7!?L4S#1Sy4@9Vg>}w>WIKcy?Kmt+jNaLwhRV22)tg(}4gre?u!_53aXa`Q znf`UWSb7;tc>K4e!(E4@sLx5=1~B+g22i2;+Qkj0{Ob-t`~ciT@RhWE6AI1aUT;tO zCgi=;o)GsCr-6@TxRbPs`$Ox8oO7;6GI!|X^4~nlnSl-@C9UD5|0nzTYMvLaw4RgE zPqL(A^vnMzcT&YW*1Gt@RI1=57)IJqENV;T>|^M3kH}P>X7|a$y9FZd-TJYWrY)(r znt6Z_qp8q*71Y3Xw1z`wwQqj8J#jmVGvo|y={j@z+wBQ$DRr+ggD=Qs^A|_g3{NaL zFrUPct+A(f3hBt48R1uh9?r~64Wd_EIIf^KTo~5g37LKM=2QQ+keLo1WLI@lsv9GsKCycXcO(U>tK4Q79Q7lsN{w7Mf8tqLNg z0*;svU?H3zz;)tH^qoC&^nZL6>p@&M$I7D@coc3s5F9B#n)#tuZRJvL*q>uAlV>T1 zq8)m4P)i(p>Pw3!jyuqD2FD$K%lylGx2Z}JLB#g;=8blZC&-Ub=Ne~rt`Vp3ma^@h z@=MDXPGzHCC;DTKBu~l~pD`=Wmsww*rnZz5EcU79rEdr-rOq9p zWfPYFYjS(NQQgk>Eq@Pf={C#l=CseHCuA(K4yVV0Y(}XUVl_a6U%le@#Qfgydpwh$ za#X~(wcb1&!>cgI2gmOjK&BghPf<6&I)2CQ->$|H3n9J9c!+hc_=^sjgQMW(9FkIm zN1eG2jqOTzc0zZyrs&QukqaP^LUmX#RwP*BRS9jm1nPOaa=q+dOtRZ03T@Y@-3nII z6V*{bZU{sR{TeHy-7)7lQO-5AVdz$8yrTV4Rc18?qWxQNVf*AG^fGx|#JLCO=+-Jq}gbp zQn!MerDoBKbp3Y56&ry}7rwf{F@K;%Kf&nJUxgoT6P$Ls>+lG0q7phF13q!R94d(I z#*UT3op1W0R~&pcuQwcg^5Zld4F8C+LI1q7u#sxNTH_ReChRnFH!STjsR`6iN4QFNpi$L?b@O9OH&fIlI> zdxg_oeS3q`FTkwMYjwN5Ru3xRJ+Y$)pggEraxj_dl%W;TOUMzaITG5B>*`~eY`gSASRB^Ux15#;=Id~h5Om>uQx0+$~ z`8FUq(Zu}t4Z1OHgVEg3mg`Xpd~HdK?8oDd))yAkRn+^iv%BjSHq>3x7|-LPo-|f< zmozW}bfTr!p@aIF5udnwZ!jkI_ZXX$SRzLelx|}_`yEb|gUT=2$=O%K*JAsLqe41D zTk11MG}%uoT5KHv>HwAJZDS+62lzU~S{Tl9B2T$f}*Wq;XsPP7;c@P{*JYQt-INr3vA-}ofp zdVB84+Hfzwm(Pm4cIll`Ajugp6X* zEeXOc5b6ieyHP3Y4tYmSlRgCH)6_>aqsbvEO~y>Ves50i`uz`7)Bbu`)}z!t60` z*~_P#G{?_}Am5IU&@37}@ zhu=xb#GGvvl52j8U*^xx)OEB6`~ctKbyO082pM824+BzIJwWOi4OAz2rC6s_wM>O1g9XDHW0&swv=lKUka^ zFOvsOZqQ3MYfJL#GVyl9F65`h&|4jKN!RVV7FczaS_7(ZeGojp!dP2TvR)frE%@CV zK6I)KHv`qNQ>@C$lF->392qdyQCTPW^oU=~g5OBYyj^#FJg3C(e2w#Pvqy9^qI5xP zR3oc@sYbs&ev&raok3A%VXg#>O|3iBMpn@W?4r8yfxqN{?m951YdLFv=c;lyY$YITG(Uy+78(X{w#z z_W1D>^Sj>b)*Y*u`3o6g5DN<-HCE{*YrtPjhzfZYlmuMw%`OZ?KpGZ?LK^Jr3ZDRk z7QP=7OTdW7oP2X*b|It;{EArkl`KjnT6nf9`gv@t_+nzBkwvBBP@xtXK0#{HAs)#h z1VPne6Nfcf*b)?K9t^g=Xk{foEw{L*tEs5{^M_tiZVf zhbLlYg$g~3AvT%puQ)1gR{O(R;LW7&+oA(UAs zr(Ht#sM-dcRp%W@!~%C^?7u+jCXV(00HMJy zU$n9^b}9F0-@F=j#e&jA?tDckS+BuSO=l~Oy=rfzc<|vlW2`3HL{Y$Km_4`2n^lxS zs$jXXVE5w8_;78>2F&+PZApE2XCG}zU{I0vmj=>g*Ky@p?7)onYJ50^w?XlzT(pLF z^}#3Gx%u^)^RtRV!`UT#i*tPhX4@t_xUC?$3swuXoDL-G<1uqfx>n-QhL|?*;^+|_ zyZx{22~YTS&cpBXm*5Y}F^2~2!tMU(#KgziPvQRB2F#sp)ZBFR1vweIvnjE2rZ#(< zBR)gEGUFG?moxrd`O1njh`Z4ed8nLD=&VmeD#YTDPR5L zhs#%fyuW-6h-b@}hX0vI#aEoE1si5+Tk6G@QHE5bJ-vbD7|QWQFZw7>GK%d+qYAX> zFCp^|=SzOMf~2w~jUHEncJq1=*SO`T>8kJR61%9m-67RGVv>$herC$g%-HYkpHBJd zjNN7b%#xp3Dl?B1R$a@EUnkc&@+c?%Q@QRV*L~tua-A#Jx$z6-y02XKRd8v~lk2?r znR36MT=$EY$+a4F|M-b=oiF$E<44K$0J$Cz*W_CMY}4XS?ZQ@HEpb9#r+duKg#|OU zpEd%Z6&8R(C=)lME|C>lAj@;eWwA5aR0LidyyX`X9!K1A(jOP`SbMs~z|mAPSQjwg z1#_SDmb7B0(dN#dXxwt^J!#O}=ZIfHU-o6jFO@H+8s@&Nc%}Txj{D^+Cq7ZW`ovxG zl^Y);Uwz}FSg1uu~>cICoXB>6|} z+4`Bj^rJf^h7-?>;+4BwE>}MItFAGlfY#KyybVN=44#NX9l1D z;`0+eAwCQEg!wGy^9w%r@OgmGANc%@&*OXsoS&01jL*q@Tzt;va{-?p^7#p$pYyqi z&oBAh&*#s4mhfrhvyM+-T297PKHuZ>13p*s`6-_{d=~Pl;bZXmC7)mOd63T^`TU*F z6MPPBwg10W3LQgi+-9Zruyh8pr@NJ}H8#)I&>(Y8OG=cv^l6Sd*2iZ^0<^a!#N$Uw za{!xfzCtM>sVF|CCc^V`GmziNitE}pHxKr5k2iN{R_J|rRvn6BY!2^oa1Me3IQy1o z5P(c%hLl*(E-0E#yi*RYA4#7HJv=UT?$kXk?ey6Uk=rYg+ueF3r0bD|h`8C;Zb`}S zdR1r!5}Y2HM*3zG59``J*W<#5Aku0cg-+Vl6rJT*kZJ7p8lic<+C3po`Z&GDtp0oN zt7hGkytcw1<@UOxHia)QCe{Lfi!#Em=O!A>x1JS)f1425A0qc4r0Gt$5?#W2=||xt z*`U>o;(@+Ar56~V0i!vW6AG5fz{yeZq^{szYE!y`1q_Fzy2my5dH#6}w5VlU%mXk13o;lLDfT*Wn1)SB%+#4wmip5i7uWyN>omR#qBRRg4dev`2M-GYMQo)xSp*O3$fw+x4s_j;amG6L$=N|} zl(W{k@feuFuhNv$q|5~OAGGclnSUgR4bM0gw6B1d;`P%nr?vCF@xO>WHHDz{=y zh+g7GC)a;xarZcTHtbU8OlY%GnWS)biHWEr5%eTd8mc?m|5-=-7bV+|sYq!kwRSzF zy5rhE=P*<6C|F9t_$(aY1@@)pa-K-+3;{Qwi9s|jJ|Y<;mMXwFDG1*e=?dj!HE-VBdlwVS!n zYVNOBkd4(YOF=bd-?L(D$nHto0z@@%eJemUpQG0hVqm&GCI}_!&}>{JiPA76H6SyC zHLM^Rzab5vduh|wB<^?|fL5vaBf4?B1;b6D!D4jKI{>)=Aq_yf2zVoa7m`W{=Cxv! z;5=gitqTd`Cpc|sne)wGrW#3tb-E2!w+&Xo^BH8@Qx1byqhFt0q^6ZxFtF%o>8?yXyRCf{%K`GC(} zK5`$$!a~iQ$k^Ch);}c-mH7@NQuHK(WUy|*{$0~7?Mu&8(`ze-4 zMh|Uzj2(1WH5;Aww)hEOOtVn=y;MU?vWgSY>?I28XGlcFxKoOkFC>Pk_$)m3D9VQN zg=dPlSH+3uL;MuOi2zznEmJz1&F#8!rdIZg|KMKHiD#Q7JRAJlB{SgJUIkNzTb$N;JaP&I&R^a}f2t>^py zfw^{16~`azw9%q>H>kfqmP@Q)eN9c-53y^1V`Q?e(Y{B zv)#<{6h5<1TC9(~OQngz@!z-I)ull&N=T*E6nvjKRTRn=Q!gPAm{7$@n=3_)WFf%u z0a6%terp(S(LoHG$jm$FS=`BqOzG><^w4OI2cKex$#88BxhxzuUX-Q%5qqX;EO;Ib z(cw!wT6s>Wk5O+GY^7lQepC`CY0KXmCbS-ool(M!VkTH;{)y+({$g&`<-`iuu$4!N z6_-I2-M0y)TC`GTMX`#6Ccfn26~afzNR&H1M}=#iPwjlY)Aav|C#ikH+GjgrS>a_R zduhKVaB4+jgY@N1EU2+ezH|NI`b>et8x|Z`W!HRT$8isW1Dz2-OGf}*VF19g zkN~qgSfKCy6tTHCJP_4;5)m*RClTSAr5$jX`j`JOBCx0qf(xnfrx0PFAOd4gV#4>p z1SC=m3WN{o848{8fiTA%fM`l0#COapIQt|*oc-tjYY1VT>-8dFK=_85YlVNd%_@)o zNqWVq<6JM&Oz?H=1;sO1&8P|-0ayLp{^tEs{5YsUe7z^?IiN0GE9Ne%qaaT1>fKl^ zQeUs+%xWJOmt+s7r1fBQk3C>EI(l&Qq4Z$?!FpiFLB+Ig!=M!rAqj)W9{EBT{6>oR z0t3!d+AzR$`h_q^^$PcSX<{STl1G|>+wTqE2sOg z-a_#2aad_%vR_j}YL%{q(}vV_JUz5AU!B?SVK}|C@zz&pW7wA*hvO@>@sBUr#;~5- z0IO605J4-jz?|75cmy`8nEAa<)mZTES_jcmdzi+KI_^4zI$oCC%-t}&qmFgbMr!JN z?#Hc?%K9L6Z)d9c7viE6AGb>;;-~Es?m5x&pZKiQ1AZ$BGVrRawF* zhs@*cH>aiElmk-so4&p; zH(eXU9~nCqss&4|t}lVeb*;76y&8T9-4J$sY3S&VhO&|k#Wu1d$?4f$Dbva#is__4 z9;t_y%b~E05dNR&%+{E{`4<$vEf(RP=UMSigu<(Np<2s!Sr?#|a8*xa#jQ52Vw1P5HqOUKEmM^KWKaDtLvZE`EWz{(U#_LEo| zIm&BdWe1Taj9ArE8JtqmP|&rx15Kq-IeE-M1X{*&37d zHJ;}z^f|uZVL=~I;|4*W^-1&z^ol-@DV+j{1k48zfmh+rtB3Y(F!`>ww7z6(XaH)_ zJU#qAvi^Jo)SfU&S)6C2DR&XB=CKSFI(fdSKptJD2?B?kwZmJ2auECFO!&!xBh=alhG)4A#k^nRlVWTT@U=+tq>@1=1xu5_Tb-yE*lh%MEnZja z_3L|*NJ}qUQCmOnE&ZP50uoUS8rQ61cx%mtN^`rFAd^S9b}R(%wungrRmvQe6l5kl zI>|u_CS?h=R5oRsP>@uy;=7>Fm-^WiK1q3>c@$yn?6U1l=XG`MiRY}z9NzO}eyS$( zjx7&P%O#N};u;fr5)-;mCiD`AYsd8~djf~;WUV`iBviBa5ncv5FO7c_*vwuJbUa2) zb3u7-MttR$8C1-JEW`^!LuKb1Y97a)X;ZSid!bOmO0ln!IjjN2xsm^)T}W!&Ama4f zq*&?Fn1Ye=J?!vPU~gM({^oA9V8hY464ia>JzTR)_wSrD%KYaar9E)UK9p?xA)4nx zQGv`3*-V!s-E)mAUVeP1oPSz_O{Hv8qVN*Q^}>^lUo>jfudaD-NRKjxuG}suH>$ua zf_f9Fwv7}o*^h4{zKtBF8pOiOs^8m46@sFwc;@8x+&YSKkY-dxS zT?zis?PKY-BtOFwlR4seo1BkhW?GmTyfRQ5b4;U>kDUtu4r;n`S`cMxk+Qd$pCYZs z4>u>I8ZuA#wRM0m#W{Dtw707ij-yFz4^)959Jb59QT$fum=C{LV=FF(X9l9@X8C05 zvl^xVS{!LMjAUgWE4{(3G}0$BIX6+bPXRc@)eNp8xUeYtjd#aNC}3}Wko(|>rL<34 z=Kh3bZYPMRH~aP?vtpYd!+?=p^f)~$Lg@Fsuj#PXQh@R1k?Y%K$YTt~r4R6~>YTDxCWQB8QAaccRiNfYd zblmpEbhZ#=+g)BB9FS<_ zEG|x|WbMjc@E&ZJR`a5iFsA)+iczy!-a=3bv`simd-iuji(GxlE{Ai_%96&2?`{rI z-KLkk#JS7>A*yft8LT8+7@n(j-h7S@i7Tt$wQj-tFtOJkiCHV*w}Kt+gLp{`boj;_ zg*0rLV%(zI(w(a()-7nCfM2xV_0j?pOWAV--e69A%|^2){8<*q7AR@b ztLSCDcH2&h(B9ox=++y}q)xP(!cVFmQ{1EWs;Ib|=GLp`u1Gc4hvxjwPkqL}L61jc zciJF4*B;iS#ew$mdm6HW$4*-8ZJ$u*>$5ng&X-%gYyYG=o_Ln=I*Pn$ed2xuKhCoH zhHy%4=EQMlcov=-h|WR57rIRgFQA8<^RSD<^2(SCpz>qR6JlhA!aoGF~c~w$wQ_H!?NLJ1%sycH;-!gzI(Zh1|>Xxt@su z(A`m0)JfoK!Co_$^wwlfEaNmi|Kr)(=Jq|3C1oCs|Tr*%V0>JX3eRLjtM@nLi{% z^ETb};%pxVuzYRl=@PKQcWZlMrmHD*Qg~8U=FIScybw8))|uay+aB%@1h2p@+zK;w z*XOhI;+*+A{7h>Km8r{SKkx*0OH_z2Y4Wo9Ui-YNou`JQsc?8mstz1a;lQd?D)+Gq zHn2$(y`dq&4n3xx9U4cV-Q^hzCski3QD%jkD}ck4kT!aFnWZ!7XBQin5j@&&^gp0h z65Hj6BNK&HB%PspJ0z~fMyZ1sUw#~dCiYmaDIOwmE|yge;zadpchDbP5smCUf3YJEMu7Z5*nJS>Q9<3=plQu|pa_tsNR8c%k32EGL$?~%HEPApoQMko|!C`o4 zl{zM8xmH|@6U3+2{#KT13D1OSK#y~a>a;A^OCPelM`U=o1r_;?s|jlG#@EU)*s;iZ zg5hs|m4x9x|MEpJoWAZ*V5o&}6bhMydqVN>1v(bkns(9o4PoB46T;beJVpdF$9jJP_ zg{sa9R}&1G7MAFm0;Nih_|6_B3MS~tOtHB1Uv7bzQxf$O@J7D$=q<%-MVgOH^NQ%P6qXKenIDUB(ggPYvOWAQ zOHS7v>IIx~sMU>c2dNm?RJ|oliNf{YQIj>q2^|Cf*TP4YG_z&V@z@ynUGmpb!rr)U zDHhPkYN)*5nlb?*tAUkpwOdw$BwLUy&mEZk&0nF+MK-wUUzr)Gy6u+i`R#~XI77w1 z3Xk8{4ENMy%&1SvaFQ0AfuL7Uv*09L#X(~;3}xiq0#;Er zR%c%?TZobHH+;a}Q8;?FwUfZp2|MaFvj8=VC%i5}UiQ8eTa&TrIX%ROzX^3AeQ@u@cw^;7!2vYHDveIeG<`P5(dl^O{LR@YvdQcz#5p ziN`SJP|FI}XIgkI4aWbGDEu`&A+>7k8Gg%g4LOY2%BmAiO%;>+9%=CRHm0tQbe54KZ!5XP4d_bHu z41PA4MX0_m;S$Pya=0x!G`P!(i%c35dl+SlQNhcb%{=7f*su7lCUK9~EO!&zuX@6f z!Qrwt?U#=R9I{+vSIL{cH%pr1nJ5mzE3fPjHZJ}~m)18=@DH&@6?cz(d--<0J;4$y z>Yd_Rp3DUl=JShDPCkXML;_eByM~?4rXKvUUbP=qwTx?4CC7?dLz(gO$?mEu3zA1F zf3Wqe-F%cyLIRa#C6vx7`@kCeB{Bvk3Jc04c1eEBy4h}yLghlu+vIn+xGf{GB7U>g zk?;MMy;@cAeI-16fnur$7$nD=(<#3oy++)j<4}?l)ev&H8m1fmT=N0+DUuNHIW$?K zJwm<_4HCRaPe~RQce>+;nIlrKoBe9#NL?32YnQP>Z*$1MhKgvhkRhhS#SQT( zgjru)P`$4-xTj_l$MsyV22Wc&DREpw{8TH@eqpt%G}u3!7!~ZJ0!77Fk8X`O*%9~U z*>0YN;_*}-!wxSN)(+#^%w^MNg)yd_{dMhp0!zsQP=qaTW2G zFT$(%b25{~3m5m{@N70&N#dE0m0C%I5-n74!@o%pr`5@R0QBbp{Zj$@nF{D*&2`l_ z(9axu!}$v?qr@z@*2#|GKEr$w+qNyL#HEJ2hUtQIZ@1U_PAzeH>f_dH2AIX zfl>8U>R)KHEmaaLCR7;#eJf_l;Ur&r?<%Qd3Yd0_EO`mJ4&p6=G?r!!v zF&wme!im{)gP!Qm2nKOs!s~h|cs7wLJS7bnsa=h;`;c_0CKz|pRoCj-ImY?7@Pi{5 zo)Iq?>o>pS9f8;B8qemPo_-r9M$W$@=t-=WIw)8?E4~CBllWc?Fd7mK45KFKakYj% z67Tt0@m#tgLz`tO?3-)73?0yMmi6~;F3F%LKHLwi{YF7>TW=tk|DOkeLi4V0h&&;1 zNW#Di7KIb1X*F`n_F(8#!t)-`X^`Bu(Mfv-j13l#OreJ0fx;$m1cW0H1XhJL3GhOY zVoqLig5uxB+n8ijD}r7U;CZ8Ng&1cUfjbmptn&(=-aE3ZOIkwct20 zF+xEfZ(B(5w3_~BPh+a}sKWY^y=d7FG<-n#)T4#v#p1HU^!*0LVSFH3m?92p2vX*Q}q0H85B#i7+&+~_h1&RUJ3hm~dRH#Sql()?&`p#I4 z8+*4aP;gE=yfceslNIa{Dn8fB-l1|%5-R8z4h1U1@eJwP6GZAQh>ZOLh?I$)u^U8U zF}NG+^w41xFn^C&+njM6V>F`+L_$@IY1vw6x{sV*b@$PVXYX5q=%~Z5WVf&BfLeY6@4HruPao$Ccv6~Zfzps6ulCvnxf}~v@_6lRE|@Si&(SOb+oEn% z(;2Cic`<9Siz6A;JTprbRFCwAe`o4WOz+4tgKBU8SuTd67tOu5NI&nCw>+E$np1iAJ4`5nO0}9(x$xD#snv{>3!}*=$FC5KHhK~bpqp{aoig{tA6reT zBzz7c_6S1OR>K&ILv1Vbz%uK?vvsYjtHdk8LxXIcS?I8RM5Sw6EfA$9gsvM zFI|ow$pIZXw1r=S`E5j28|+71mjb&G`f+HL!uuV;h4eW%FWKMChu&Wpkl?ug!`|D# zM^#>l|C7uFLSDE*3C35V37Q(wXw(J*B{$6I9htOPp<;cb#YWq@Eh{sCwQ6t@Ww=h4 z?n2w$ZGY|Vw!607ZtJ#Hz^XF|kno};Pz9uFK&y8ct%z+1P?`VtJonCI@&cmP-T!Al z6!^ zb@Dyy*JgINl8B9%PxJkjk_F9Lh45g2XI{Px?(k z!X|E@A_qwmP26*0k{&Hya5!~n_o2OXq$W+Is?6>*k@^p4#aczAddzn1YV3-Hh`oOz z^)lPrlOs}}hOTB4sT(sysyMw)CPXl$peW}NF>BLW^WR6Lzn`UK{@V{Axl4l3Z*f|L)WZtvmtaa=KjUf0XQ!q zN`8kZ-9amZ3(_sjB1*?^p^&4CWRtUKQ5nd!5Vl;HP7?G~r_I`(qG%AT9gs=FLGsR~ zKRtj$wj#0N@63>(Ih8@5`PK;u&}>n{kSmM))Iol*DLFPG`Pr5x zKX+%5pC?b2{B(YJ@}ue+M1JZ9k)PMn*kPSqWI>1KZ6>M5&dRGN8 z0BeC^2t@I*9N{@V311WxZ?sW-LZ)m4U<;EMDP&Im5IF?sDjbWmFe*%5XR`~;N^9Tc zit7|2FUqZjmW7H~|8)(zN3CroGdtC}aTJHqZ^=>AR&7hNo7bw=*Fi0`lk7%r4M{}g z;EidvV8UQ3n^H74IckJHrTIJhlOYFl!Qp1VO>wS1I#qL{}ZHbm+$ z&>gpoZ97g##(1X$E4`syH;z5olN*rS!$y6lp*8j!gl}Kb$2mf+^{^1Jr$u+-rG$m- z0kzisJgE_Q9`De4s$Gr17rR`W|A`zwG1ij3GJ2+*4v|?4IYI_BlHVulLh_- zwL`%FMW~@y48UUE>K(e0Nh+RLKh%rY!4;chdvl|nak(+?g|V5@B3vo8`|5j^6zEf* z2^JDoF*yomW_eK=0vE3vgX69c7R{YTb%(#c)31FB*H5@!eOYTO21u&Q-sQD&5T+0r zJklDDB`P_z8C6maG>XT7rDPXy8TZm-F)oVdpy--nXfd@SL6n;Vl?B`I#{sH~VWy22jH~{woDy+w)h@7CCoKi|GSdsRxDUu9< z2m-KEJdINV1)k6gQfw^r`w`0|T-J8OEhk&}WdPv(2T9^t483@}(0<;HsXhBx!dbh! zvCQ#C#tq9WP1K$gTNyk*xd?ljiqX75#qqu;n7?KsudCZTl(=v3d)c~|4D#Jl13&IH z3D<&&_uFbuF8ea`45Z%WvU!*xyR_71ysfZxY=CY-HNI_AdVb*zT>4 z5e8VZPI+K9IUMzvWrvM$`bB*)|zKy7o<p!|%H9I*rezftmIt^8&Dlgsa6}t^d&5uy1(jfj3)xx}m}r3dZ=| zc*WR;pa^khz)ghd&Lx+ds}u;8Q7EIS{XD+XZ^~)2a)03#4Ad5n#s7;@-5zjvkbm(j z?8gZ-0XO?RFb$Z`dCeCQA$>Jq{;+Z>z4GE?UI6b8ulJdZcuwGE(4L zFo)*F_m@it2o@~?>FZ+wZRU1RK~Hr=yx;J6>-XG+z}_yxU}_$%c?d}JRNaC02x4>bNz%xCjJUd*yVjAYIvvn+MG!96F5uAx{XFxU)O!*I=~L zyli3B4!=H8&6@`8F*bS}TG-Ls81dG6qE}J0oI?`>YCXc~jE%x3oXGi+V|!*q|Fg1$ zy*jGj1JF)XzgzB4tA4vd1h07>tBoy|7wTy?df1Z6!oUvO1C{Yc#@KY4274n>7fIIF zC%Ig|$Vps4fymv0fApHCi%9nkSx%xiaC9o}lOuWk+5WIayUBDIABHN2W#_5=d?)f^ zG|7>1_U3vA>jNwNznetnUbJW|vVjLN9#4%*JS`I}-5S*b)go^MhXh-!w<=vkj!yg& znP52}g%XWIEUzAVPWp2T%VHxfKi`Oc(gV+>J{6|RdW;V_)tJ>+r&v{m${rbOtt1zH zt)+NTC(u`p65D;X`{~3xvHM5o6jwqA%{iBP=;RKklRTxn`CIAcPlt808_*u7n>5`T zZTIshGA8wV1Cd`dyqrT1w?o9pfT*3Mb_NCiQ66Ob0oDd+&fZ0N zUh{C0^KO6kntOF~lRc_thtItH0ddBBPW^7J?e_pLIt#Jg!wL=TJPGkr&)AYz#H`}V z)I56VWf^DD8hqAk?t-ryhY`$Gk%zx0=wp8uEgH?bYI>IArd=fyc4s4m5SKvw^0vwB zzADnHUI~5Xki4lzAvjtVm~t%RplDY~9rtqhXP}O(wl$io)RX86P(k%HM(k(1AepJ~ zcTmE0Qp(3wu>ny>q&oEa-)U{{LR~o&?hHU=Yz9vR5v&#G2^L_4ASke{U77Gvs#U2)COrY0xbd;#fHZf|x=WpS-m#vrCsAI(Zf5a^AeN%r3QokU)8D~tY z3F{%?#L#4%5D`UdaPDk_w)k8DJ}{FHIwZQ2OJE7wA0PqMW$-rhbmrtOlwvS1@_7qy zh;=Q7TG6{<3B14>rZ&}Kj(>+UY>L+2Rc1x^h8^Was;a&hQU7stO}Bu!k7Y#z#EK zVB?dg2>rgh(}eyP9wGGY!sgi;>DpHh?PDF1{GegV@uq_l+&*=9H}V9UwXj0;VbNH)mNh0d1!->nl{NJ%adPdIfe*~0f6^K z&S%<+>eI%T7tc{7yUJdkv{picgAWsA?=u=wF5=^+=q)T$>p5+Rdr1dB;!2S{KJ3pd zP-)ujEKr+6F9_xSp>C6I&1bJrI!n}VXc#RK-KumWs#;3BY%0Pk<)=-FRlL*9E1RPC zdBS4c{5v|On-iVvu+Flyr{w`+Pj)I_u|!QiLDAc+Kb$S2i)M$uT}}r_4V2CHSvw7-wv z2HwE!qw6)26Jrb1>^vYopt@RvkljCI?{YXCXnt!lgn+Iz55Cg-U_D?u_ zK3kS1(a^CpMSk-=8FM>V;(pn=FYp+jE zWeO_?Dw8!zs?T1dE8V2%23Y4!|JBh|?A^kVk%B>DBM^-1s~d8X8>P{51bVWqG3 z)#OF|2uboP@4aTh5 ze2=O>aVdF*Q|iB_d=wB+Hre79l9QdtPP>?Tm-x(GnfQe;`*L)Z8kgy7ec4E~Q7o)tbSmd3;TwYw`ij4mZZGFNBXST0H6arR_aUN=tl`Mhb%@ zdwp;8M&h!44I|T+gV$!@MHhr6s&01-PLXr9c*NjzD+Z^db#u;go;a^%?zo*$n1AE!%b_3N$;LC?y|9I?+!R zYepPfdX8R2Je9Vh`chmTBCprirKDNdRr}XMUHGTrwY)uap1*B(aO@$J;nbL;wZ^#U zoH+5oY~+mxDUfn}#I4#x z-Fii5xGUEO#rJS7Gw79{E9Iw3ukQ@ul_l?4yn7htYJ;{Rr?tLyv)JBiZO7y;M8INCPlmva~Sbq&8Fm@fhg z7)>PLZL1omw6@7xt*wu|K6j^>l>c5GvGqm2TPcR+2v{K(wkf%lC$3Rm)~nw!pH;@> zFJl$kwkpe*9GP8pKV*bx@tBe?lR|6zn0c6zZ}hqk`rHTf@UcZpzN|-=VoLrQX8F#b zA;O62SjLn*(6)-1UAxIPC6BH`5V&0|$tw_7la2L67duFS&^%0O!mK4hbSvgDRw z(5rD^5*3^?kJWA;V$QwzPRDq;Gi}Z-83&tl3mU`I%Rnk~?whztn{&&!Ds%4hxq+FN zudS!%W6pgE2|8y=u}{}pzY3iiY>mCz#<;YNItZ9syJ-Xy_0_8|QP)~8rU1dXb%*wd zarkYVNVhG-^HvRlhhC4};2?l3hQIB5N{qPQ6Bu9o@<_l){6TEM?4AT4JE>j_GAVa@ zaJSQgr);C}cVTUn*8Y3nCD>g`VQjvM2l8s7Oh&)HlTd5iC{rp2 z!7&Mk(8vZ#P{-b8ItJm55j#@p`mG;xrbPGtut=OKs~o919c(P5@1z_3%W;a!WT0g1LltR(^?^hbzw#F zlu5WWPE5k3P0rx@+z>@I%*j#!by+O^RN!RLS9FR=_{X3eym#J;Tz{#umt*rfokf?;J|un3fCtbgl6PQ3B4!#+(Isnv-|HzPv`+m)E{ZduXkTJ(_@0&U`eQ zmq#*Y=3;x+cjnQ?9jslN2>y|DGE)Un6oO`>FReUu6bd z=*$2uTu&Kh+sLyZaV{?%oKKv^{h{6Pf)nV1vMxs)X$u`|ly&(uL1co!54SECQ%7|K zrX_s@re(wl1S__;J1=tq!e}**M1`Z1ZVf@Ww2{_MUB%0X<)+$D+~<<)BcX`;aWBNsYx- zXc)H`l*4S;)T;wfD4G@i!b)ylN<@U5)#D9rF0jDxLh&QRs7zCfO=LjkxvK^!%xoyk z^HiiL%&*fFM#2XTP?%@6wtj#&KwjzM0;page_op+clT<>y&`L_4#-v`+&)GKLs`b53-%L#}pWd~NGEKCVc@*vx3aOe8CY^h&0FHt3sW3T1)* zZy>`bY5T254IHQ0w%>AWzffOs=mfUk8?pUHQDobGkB9bo&8C&usEO%!p15COi|WJ` zEwJS=^I!xKhah_vA&VtjTIj%UQq+$v=mFuSZ% zKB2sgUZ8xf1W#99Sb~L_2r(HdFZlX=Pvj%un#($}bRpOnM5U6Lj7 z7@bQ)Qa1I(?b;L?TqdWKQT!y`V>5ev0^?HoFs(J|`}QCAJ2C>Hr5h}AO<^xCZ$H~ znai!CSA&@0e$SFKU|DO{zMFEnWE>E)U(HzW3A&pjr-BI$Hx87QhN{32kB9h;l_;rc zcZW5GIkh&1md9^e1irNcL2yKy=25c}gZ_ehF}H2uS~ohBud9wE&#JpRM;@dnNo~c| zbfxJ`jGuR5WQV1|R^<^K_s%xo(I^e)$btCsx(Dl9G-P+e+|8F`ec)HU5q>vkv42@y zP)}du+Qs&e(|DEh<5q!@dZt+~jNu@4O$uCVt^n6Na@V*p8fh-|fqT?*x$L^p2n$ zw_l~kBo!=^I1b;C;R)e*iQP>~n^cTliFSy?$o&n)1{TcEH>P~2j@wWvL|JRqrB+m!u4wO+R>)J$ol7cMUnIM$i&3Y zq?`y*KH#03Bj-qy++i&xBe+KJCE~j%u~YJBk70D{YMyeIp+P9=O8py)PSclbe4(|9 z+w{)S0?~x%Ays1#v8u+j8xnIFS0Qz0jSU@IL!SGM`mROA3Nx^WsXJ>_=#bc~s>Y(= z$64Y!*~eg(V;x|7iRigNue$}^rj#qJrXyh0{>=20gW^j5kk4xxcwH!XJ_%A_md)#DI zD;FnxGP04S7g-$$XHfSq6qFW%B{X@17&*^p`N7LMes1e|4hRL_7SOKVASMmv)_);# zk;N%A!TE3^Q>-S4wfHR%qU5^mcMU?+4Uq@V zmO~5k6nX!!-kFunhM|1sF2%iNr~s0I#`Ra=Q@E*)KEKO_qW#zPt=?9j&{Ef&$GTYy5jnTwWuQ41ZHi%1|*U;uK_ny zXYF8lo)W54RceplThpus`djYp%@qd9x5kOU*H9O-gn@dMPu5tsdldsk;(;_*wZ{6i zO03i#m!L39Ka{ceFkWzBxT&16`$EhWp8mDJIUYY4`b-u-2w#KS?7 zewk2Kyq)_H*EYohW>Z}NGiP}Aav`+Z)f?qZ()G+AMONY5?9Xaf_zv{#Ix|&q?;FWV zMOF6@@34O3;!%`Yo0Q++Oz0}qoA^??c}zxP5Q2HLC`-)hpP`0<#C{<+n1HZ}dqpMM z!;qeNix`D_%A3qZRUZz|22IKl9vnPO%OuRVRp=J-cOg-ScGwq3hl zU6XSlJZpRjd`EIA@8VVw{)5Nx`aB4H@@2`M6Ff^`S%?KhctME^AF&wgD`&z7!VAV9 zlkaoo?vT9YgCEDp8Nx5|7Rz&iVaK;vCQ=Z^XY9ZP#u6r)k{;lM9V3-KQU`TD z8F|LgZl9pfKSfbz_xZG;eO9YVa>?*sznInQQnq|fuYuvo^|}DvOS;#qk=@w6mN+!` z+r4hl9{=#21_<^%WscqfRa{uU+{kwV2X6KYKl6h1Glc8rtnq;b-FaS6?Hp?bl)DW^Pul?TZkCs0sP+ z3hg+`brw~MH>(V{u+T>?nec;9Mc#tXtY{+SaAGOTst2BL4EBxD!$Mycp!fy793-k1Y(+!6AYOC zGV1}riEu+&AFQ`IKC$DklUSHtsnTEJ{tQZfuEGK6M5^>Bb_!;(z|WXMR(h1o#WtJa zA3?G-Xn3>E`>J6bME_hUOG>$H%q8yaA29JSHzt0-JX1R^TM#82!s)WLgS|!|EBiY3bN*%U z9I5*kk5;87eF2jb_*X!(@5`8iPcRCU=BfJeY_cnGZ(d!GWmoK0x-+>jy2A^E1(ib^i9Pa;GaGVp7 zLxgtp_sS#|tDu) zx?M74THq6zT>CmYF8oXC^mBw{Am1a{x)1m?NrBaZbnn39kD)|%A22T!=0yi|3iyyf10rHit+F=yHRQxb&qHs%8f5Qg;; zx}@YK*WARw4DF^GD4%cWKs|(o<$Dj*9q^9B2I@MM_`wHiSo`fU3Qu2g=~pICyjU0Y;@ZM%3rAghPd0OT}8I<-0-$(~CrA|8J{eGP2Uy z{sp4pHutldLYnSF1+l}APWfWQ4#MIsz%dV0Nsgkma3#Phayr(&ZB`LE*nwXP22U2- zo(61%x5!N$A~1ZY+{QrzoFgFt32jWnF1r@dkB6s!;Rc~TSBftD3@h(KvHp|w z&U*9g!zuQl=wHI9*I5vQdmZLs3EVR3^h?h>EJt6}efZFoC#h@71fWQR_( zzV)$8b@!#KOMX%6devCQguf`MW;-A#peVvhqHBMF;J$S(R!@Z6<&JLK;YK(&MkgBHmx?icR?yZIFMC5& zdqxxoX}Hc=StmyYHy9CU+=3^6!5d%gn*sAjYq%qHjyK{12X`Bhxg~_x&Szg+f~wSS zZn7>w@`oxmIVQ|`zK35Heqh0`V|>-tCwZRtn_Dfn%5#7`$H*g^MX&i}m(-y&0;bz* zE-gYnln*DNj``IeLlemmiz|V@dsJ>xIrkd~vdeUHTdFj<$qw80x0FOvriAY;%f0Jk zkc4x*b$@eCaH6;FjvNl+uNXTu|E@7pjU4SkF)BbIpX;rw3hh;P7>O(8FyyiFjs4)-3gcANu* z2?dMPdA7*h?(1}KrO@OALeN_~C)jiXDp1hrdhtc+W=Dx+yFRONg3;xQy#apKy%b3P zNsx#tMnXl*EN7J0XPSQ_IRXoMnZbwxXB}8JMG6k(S>Hd+4g%CvW7IxlJzP!Q(JvSS z2iq|-WV{VG5(}NKb{S`GGAg=)PZ-M%tIpw`Sf_LGB?ZQsOvj~j>D49!C!8ZB)CjEU%%E4-X%9VCW zQGvgdbSdCz;Q{9McW~~?q9Ul(KK%VwvhA#V1$&61b~i;wN=?2DA_glqUTj|{HemQpoVj3VnY^9Tqvv7 zQfT7*lcI^ujBh@R$vh>pY_8{MiJV}t)vPmUr|d%O^mTGFLQiXgYqiJO1R=6(;e$nI z5l0mz%h)q=Tza2Z&&`38d~8$lV(qb>a@h+dKcPK7r*b|Kv9~X}Kzpp6{4brJ z$zP&9hFH;A560&wiB7*gIm7u>_IR}t19u_LI3+NNYe2VGF5;f~c)hlEu=uGem>+p^ zvk>?g4t#1H_-Kz~qOg8m$A?6^+U<#hvSw!FeaDTp>V3blR)55TJ|x!a#yKa7wOVp2 zR?l{<)$ftSI@m{q*~dwR&+Kg2DfxSgY?1@AnA*s4e!Zhd>`<(W81z80tXblui~5(PX3Zt2)Q`v*tSnGN?Ddx$Z|fq z;I_x()!~d#{p=<<(1L@yX<0|7*-MiMpia$1_N~bQFB1RAe6<~av2Wbwjb4+JDm@Et zf2>8Pq)H27xh@Pm2}0V&J}UXFnCYOWRKZWVBG=#}_#E5i`(_}jQ9*N~7~?zd+<-QD({-9>##k>b#{wOQ>Eu;TKq4fM4)@0a)w!YC(D_zUNV9n^$jY(WmpfXK|XirAn(Nsmm^G4 z1N{qy5krRY{q{@g8;CqkbZmkl)1Xx8-P8k$PDqvBPNQsq@4LjFddPQGtyD8yW#Fv+ zLuE+e>FZ`eX-AYt{2JbRu;A$5PG$$c``i(B@at8gEshYwtM_TmyLD>j$L+_# zYmV2CH*ugjxF1hAa+MRxhsKT6k3ZwUB`yE@VEvdu-6!hDg~#p3q+$KQIO!zhLxyVe z5J6XMR!0!{zV8u9jDC;t_`Lsk<8kw4L&xKGXFN`9C*H!IZJ222%PR4M%efLsWQFPR z5a-q9N{7az!-&8vu2 zZly_z3@UyZ15GNe^G9c5kU7(8iq0xqBgDHYI@9t;uPcYB&GtuUm2jPB71)ia8_sp6 zdG9Lgr$uTfikm=~ZF}p+zM#gMjJk`352&yq;KYR3#|`O_Y8CVLNf5<>Z#pilz2+nc zCiDQvj$Wt9?1Hnwxwb!kgeWve4D(Ncs3$hd^gieMq(KX+C6#>|&-+b3o%8J-Nk|&y#J8V_GC|BnDMPq9{rk4H% zXszyW1#e;%55Gou=)F1kYZaE57 z9Znv;_>T5?4!gFv?E;BW&gE%?JuN?eI(+3j7KmvA|>=S9>`jD7gRV44>x4M~mxKwgp15dxgJ8kK5@06)Z6PL>U z`s?!Is^z!ErX@cKY;LPuC}{FhFlKbNi{=rlm1v{eYArmRvR?03u6Rc1YA-!8M$N zwj3#z5S8)erzX$#*Kb-h2?`Y|fMO_BfXwq^KbsDBoZ0TLkKYwbY>+RJ5SByYm`pxf z^9!PGPLTe}~VeTIyY2&&S9s@$YmV zIRRS1Bc3IvGcE2K@2`GQcR!~+=5B2HO<8$8%U*CF@*4L{?WtDv4BLFFbvMg-r%N={ zvI!KAFsT?$0!OnryLTl&-AB8OU_Gt!(!{A?&RyeH6!MrJ>g9p{`tT8VXjtkrN~qqI zEIIUoz-9saj%}93(r4PzvFewY>&QPP5N<$xFxGBgD;j+3n=IgFx4r9Jg(ThVvVIEb zPu$EDuO_~3@vR3KHuK?x3|Gr-ho`@LXxACB%G`YK;psSd6t~bV^g>Nzap3qrLi`6$ z-@n+C;_W{f9p4yOuv-P-!3dz;k7VxlC)66PJzmlrK5|CzsI(Y)wPq~l1r@4>abvSh_RA#++2HVVXm-VNyf`h`BB_#5#xZ?UJuJzL! zplVuJ9a}Lm^G*5VZ;b*2Zr1JfG3Q+aKd@1^@jfA>OUk1)$_EZl+am(~&&Ws&Fc( zANZ^yHzQv|NP$*B#66<&Dz~)_!>R1?Ab8?*CstAR*}3_F1$&7-;4>{wc?n=!PqzX4 zT_%nL*gs>#DuDeRS8x5K*HBGsVTp6?hcAy#FKAF8wK*mZs!!mZc!&%t4C(FMJd&%m-O9BIMd9|Vw5M)5 zIHh*aHKzAqmH2pq5Y%~>f4A}neCLhcgWJolV6C_}JYP3A9O|aN&{@`_WrtJemRXzO zza7=-f4iUx--aCO=9^9Ck>vg9+(Br~n>}yp^>5)%>n&Kv+y2~-QU&F-wenrLvm#sq z=2204o@p&nMHW%H6`+z%9COnCPf)N3OSZyPoQ6bm`&BEwg;DB@v}%@E>^MM{e(il%}wt9)H5g>u3A3l zz*JxBp5S#L<>tl}fdlpW)XhQQ7t}e=hr`%@d7-jP-g@8EU7-uod8bL<)5%+E=RG_q z?=<>g{VU2`VbmU^K_U}rU>2Q5BMkV7#+I)isB_)>73H={SzxA0Yk#WN%g?s_MvY2t z2-AObOo8abm7-s@msxy>_q^#fH>65m{fT4`O-z;U<3lL+VF*1|NMfjUHo!;4Bv#Lm ze)&2&?dqhChgO5?hZRbBl$$F3M^&WODn3-aQ~pzZs6F&5PwwB?Z9u9>Hzv=XF5O^X zhw&GdM|3d5ZSN&l=QYQ8Lg_qAaV7!y{&Y;s#LI-(%T2h{a-@H5+qgzj@?S z(W1tt`kqB|bwz90TQ-LepAoF*w>WerBDCD5`uL(#;GfGvMZ{0uqT8NaN7=`b{ce~s zEfBprmu<5!C{HD^gHX*39H`6nS06EYQtnh@H#AFm6_R0E^A4vqZ>L3e|HJ)x;O9>G z340P-|A}g`Q+zVH6913y!u@}vwS9w|+EhZEs&UTuOlvuLgsA>t;IrkRJF7diXnscX zdGr4gYkOki_P_i#vv%3`;5BOJy<3bnF5cM4sm(?uv^FBM4;befmVNrK7L^vtXMrz^ zrI@E9tHlPIQxugs!O_-v=Og{yYpu>vVw0URB_=a~Xc)PhdQ>Jya>IM{J0s6ssGLk> zwQG_zM(jgWdtzCwq+RuPyOMKg4w{g-Rm?e#>DIRn2?MpoJYanv#E@pJkadmC>Q3v^ z?4CHQnMd~IsTlrOiBhk?n%7Up@PaC4+7@f}Byy{>3k@QTce?x@T^RKGxH8L6TzNbh z*_4S{GBWHcV%F-QLs zVeMb85EaBvu<^tZ%Ap$vkU0H=II+~V-PWWd)G`xSDT6=E@uO-K6j9os3)q&Kz zxlU7s)>*lBp@0{@MCz#v^EZ+69@hVZ$D_V6RuhZ@)b_pVz;;}D&t{7@2j%@*q3ry- zA1>agh^HNaH_SBZyLE99z%p@KI`sfY^5cu|!(=A$dLOfIEkuKV2WF7Gs9LN`J}*1$ z(+pWs&`(v;8VAcp8ND)OEtU!bD6i;KT!FA)%_`72#~G3hz^;(?cK*j&`C zB}*$*S;^uvxgvq_E>=}+KB#Lq6vb&|4}T(>*+c0-`0NGb<62y;t~b1JP`hC>f9=vs zV0d<|N}pGJRJHX6(o~)rd{UgC+vH7@>=s%(5a zIVVlAbG*iv>-l?*KWhCdAZHrQ>mc}HR{TRgD6LW-+>}?NuJgKSBF(sk>PseFWOrk- zmn-Q9XwushxQY87?&WVEfBQ+Bbin?8a=!W|^KQG7k31!%58o;+o%eg1PXkM?xRYnf zV(|BzZGV4L2k(1H>)>yzQ$8KL;aUD(;+=FV&L8gwI>iY6tt$Ga(l4rO$$p9~edZR5 z2c78CqUSDe){ab0@)oT5Q{ruiZ1c*{IkckqDzbUay!+{ZHJ2@2(n!Zgkhg~Y_6zd% zHHzzhS>Eep8jO=j=bpb?>5gayIP!?Ix+KYs2n6lV*^YZzdh$TkU~I9qitazz4FF z_I9#(I#-amc@dBA+_ZUpd=c19LLPnJ@XihK4M$7Pj!534C6lk^x_;l=KR){o=Vo$> zS^-$EN^MlxZs4J3ZP)sJd)IEIfZ{t<^GhcGkn8$=n|?Zg!~cD|gTot=^Pc0?+PsA- z@4WU6hcn~6l8Q^0s`Q)kTI8CX*S+EBEt^T7)Z#SkJ9f=)Z+K_kChF{2zc2CQN!O`H zCVo8mOY$~(L(hgiH|*oOUES}vVgH6b^M1c!&rPoZdW#vc~j|5x%MpDe))#Pp3(|qJ2j%>uUCWbK7Rz z?xK!yV#;Mdwry@!@3hD5m)Y-B89S_s_H=p9y_a}7@o;a69=CE)ALJ9byD%2smutr3 z`v_2;uhI))`!@Ah;k};19zDD_$Gu&TbKkBPI;|KC3+?fqwPF&BYf!U&k_btp6mLbG zqRsY-xKpONnbc)_U68fHxIDO*?QMZ>6~?(8iJkD$G5$A)dr?@0d(mOVdvnd6W{PbN z@2inllEQmWb9isQa>FIhh4JQiue-UhT`nUO%!g}T^Ifirc(8K1s~qX~Y13T|TndP~ za>^R*n#nKi>lhj{T;;$N_urEOQx41`)80Vi<8yR@l>HF^-HT;~3wYH^Nv}Y__p1eQmDT45&J`rk@L)_vveM zq5Xc0t#;p1Q*}sKeZ%7h-rA?%oNRQQ>5Gd~cauujEUmX2d{~NiJ7R6U0d8 zj3>&-YUk7b3(+$yc>dZLy7cCXG*V{LsYohN&ui>FU6Oy&44MJ97PbpNto;|9ccvlf z{F0BF!o9J=_z1Z~*@;`Zh8EDBl92AS*KTiSqx7`Q0377Tnn9v`eXR?zVe<6ma6d{M zo|qKLLX?`aq4H{8?8n*_4(d+`>VSzKvoY}u8xzOY$MG`And$NS+EXhI=z_ug@ z4BD}lr2sY6;`?(Y^wZ`-!UGW_1|NsH70N^VwQMoaqch zF~i`7gsqVw=vdQ0gZP#E?5`F1=$%0an5Z&K+nJ?VQ?#jYIApUSb>e$jT%mGhY0%j;2||PUs#+hj*WS&t_U;v$ zoolv3u;Y8(YRP0l(|fGKF7VsEDZbC+Eo3QW(#I(H1XwGwC)-q2nPkY2LO_`}j9h$w z8AOUk)b zaZaf{eyq80n*xY>_dM@5%VSA!^ctF=zTJp(&G5c*$^DXu8q1msw}_Or1nz+2e;A)C z!mq&J>|@q@D`J@?04mWnB6UCU*q-cLz`nl>P)nP04(&4A&)h^m!+XmQ?NaR_a#C+e zVVCNzIMrq3?WcVE$zwm2DDe%#ANpC?b?61jn9D0!pnAcZ8SkeHM)*90S@ue4gwI7! z)5VcJCAbz1e})#MZIx`(4y3qwjX7vhYVnSTBu)Ga{($V5mHb0>u7qBog^)0usNinp6MBv)i~#@Ozp5=|fyN|Mix3f+PA zfrd4YuXWSX)0DdcUt}x~h`u<4)sd(Wlv@$6?41@PUfwTqljq3OfoZ++0?Xjf4{w<8xo3xqRlIPgXqn6mT7OgEp21XCor5Czi*o{%B zzk0o>a&`vlpILO4RIgvSyIGGkdbGzn%$;X)U`;JevmHdSt?(7yN|Ql%r_RSV8O|M0LcuL>%&~j^cweC>ge?^ z(N5QQMCavvJy(3}+&1`RHGV8aVs1W<`gOT9$9#raUL{A?T2$*mN$blLAuXGqb)K4| z)F*N3K($jW#2WDQQ-UbnD~^9mb_>O&V<0M2UXD+UYrlbFxE}%YovG3%qZk|Xj|zQ` zJZ}@?-3T9kcgd(!Y4l+`zlisX=R-L7w#uce)34~byfnKUGURGVm43;|T26Pm0_Lm| zFR(YvQ;kU8_bD+|x|cdc$Hoyo&GMcg z3uHOme+-|bAZ(2{I@8S+_nE~PP{$BxO|uJbQw8^@ptqRE0+ZvZX=pR}Q9M`Wx5wt~ z6{=AK7TOt|r0pL-VSo{yzYA4+KbEiNK^P%%eam@rv$&9wQl(7{nz;)c_)@BLElm;} zxRtkWj*_zNdLpVG2V6JJIuW>H4&)(>a1KGFYlXyRUv1Y zFtrflS6u5^$KFAqwJSN+S)9f63Bx2)vtBqR`n8j$5ht>#pT#;vX9q?MnbQev>H}cA zjdR%4UrR&8w*H0}xMEvxnAhSfu6W;>*qJWKZxV00s+Y(fW*BshF2v})2xg5!uB4EY0pIY95(eVX!NOaFUPU!mn*}R{8XtwlItSuW$a`@tA^d7!R#>{ z*Oy?=7h?E${nly6Ti3n`%bYn|qx96Nq`jn_P|y48H%C~}exMRRgq|1MEp=oVdtxX8 zp{y_t+t^q~w61F|&qBRK6o9sES~}lbpZ5$a_M+?ka=xncPp30S_hPzDWZr%Z?}|2o z#O-3mpM#I8sQ5F+-nc>NGVY#n-zRr9%KBEFj}UHBX;2qhPvP_{d6CqOG(oDzTQb-o z-&Z;K!Qn&NTW+;wtW`eH`QPJ?*}l@_joFLGa)ylAE!dd8r)@#b8zYR_8;tgcIuGTv zKkd5{V@d3*!RZ;YLdzjUPwk$hOp)u$PGX9T;j7FP`7`QknIcb7+yS|lDN=@(6_WfD z&i_3q1e14P7QRNEQG5qHhknVC5>9g9)lnVE-01D8Bk&}is9`F$Sc@k`EW zv`1%+550rsPhWRsPH3KF+W5S{tTR9P-|OZ9ndmh?wi1|N2v0lO`s#0`!}#Tm1#7}a znM98>Ol{o{H2B7FyvF(w_UqKGc-(T~CAU~l09hk)j<|I{p9JN`l@(YFgIIeTJ}@FU zP-d7D^Qb}|2ga4LUyoz#5yl=^YsJ@$HyZ~)aLoV+GDE_eHYV|egJ&Z16k!o^oqfo> zAmO6s(8FE%2&(XOj2sTdO?Z=Ml9K--YSO%22tC-aB9Gr}%cYP&Y2F@lb9htEB-tyd z=gnr1wr>Ba$WZLpX_drzw(zUW7Ji8+v}D<45#c2B^}_8*gje0jvKm?_CY)#po~HvH*dAk(ID@)7{)uhdK6Uer?uOq7k zCz`YAHYK(&f;?#J4xXBL+P+`gG7LpyZAtyuyba}!D_^oufh z3cJ#iMPZi>8D^5;mb|gYAJkIA-xs$B)&jL+$44#2Puj9k@&2jKEtPxCedca`*{c)X z`EF|zgifN0gShd88`S~ZxS0NwOn8LMw9HqrQCDM@p6m=6*lz1~6yoU>(mqLhLP-Q< zz9V_I^F3vg1P0^Oij7XTr)4Ddiq4=j=LZDdogvMc^rQ8{=aadG&+E(f*>irsn)Cb9 zbNm+R_!f8&J45!-=0SeCQXi+n{8}Wja9FD zDs$7Xkj+-+IB#|rzNBze^X}%eNrI!niu#SgGj)DS*l0FPm$cBSdg050q)COO$zpk< zD^&>^lYWJ#kS@8&4Qlp{8?0KF6kOdRxVlC9E1$JY|3g1*4_?{V(Ga|pb!9rCMw6Fq z%-bo+EGrG+SDq&Me3BKIoncepO%~WM$MDkJ!qC!xh>47-t_Fe!2Fj-2^wEB2({1{1 zzqQG>^ENYt(43PSyJfFPSHj7L;F-&kYTydPM@Jkt*%*tdFl*#&Ayc*h?*w?ArdR)e zyCMU)4w^9=b0AxoWbWqnVI^i-Co0*9(Zx}%N^ysTA!GygZ{rM$pLx3ik%n$-(yJ`t z@MPuIjqIY~LPs;e+c=g-DPF}o%s!roLV;okuPnZs4u)TuXddp1=Lg3VeDrQjF~3&X zE?Cr84kfQwC!!i!599A&Tld zGX!1@4s5YVHI#8`gY|0!^`wTDFaizXd+*N;jWc~uhkIY)edy=mE_cNDwAb|ADqFq= zDF`tWU*mc1tKt!a0h}$V<(8kFfHegC3}sk zy^3E6e)A}XdP&*4cdO%lfl5R5#LA`l=@vJ=C1USRVREZ}RoM*?Bxo!b9jCN-a{G%- zj}yTAbn89feJz|r8r}l#cWhJ^aKEFC1Ax|5bd}U$;NHu70e8;Hg8Sq90rzI63*goP z_jJ21;LQziMkogO)8N)V8`D0Ec_nSA(muO~8<}`h*q9&Wm4f{or0=3$aA5ynZ@)BD z2Hmt_KMO|uBZj@gcVTw;m+vwP5$hqvP$=L?r-WZiOpsL7xJ>H6@T+}73H*l$jq_e8 zL5anYV&N?QHR9p)P>HKdKCkFvfINsGir}Cws@ zreWpajZ>V-BbVh|l+Aj{2}#seGw&91;;$m_GhD;dXYuROeDO%$RVrQe7nw4r5?5b` zqqVhX(s6q_-7I(6!enTzxIZWKMQ@~Gmv%j-z2jzg!|Zcy=;~~Uol7~L4Qpgyot%sYtAYAm+VwGoTXlA9 zJMLi}MZI;NC*zU_w3`+>^^p9 z_3^9pu}iyt6LZgq(MPVc*K{`g!tUcE!}_S^u+vBG5qb^lBf|dKs;57o$K;`3($m@2 z)@L(4ozFNdJ;|P?@jA;MIs68OO=ne_o=VEe?+|3R4V@JCjm1jvH?5a7 zJa~?6<#UQ{<>R?5mYn#DoQBIflVuGnI+Le1w7wZEVriDI`hvN?%vs@xyAc-D$!ZC) z!66|1DnBVlzGl2HUXHy%9>7js_DDXrf{w`x9`SI?TyrJQQYo!*o?%+CR}jUqys7AN zW9&4180@~6%>B&uM)Zy!4=lK76Y|RTr5AvShI#M(vgme#>~sGEVej|3x%vBA)j>|T z^dX*LJ-zf?RytnYAO6By$5=7H@2sCqKj+~;SU$aom(=3}pI5W39ER!N5-`fAbF-QowQ3@-vo;~PS06#UC(63{ zcgTGL(eGCF(s2TTRq0yQq62>OmA`;%ltJ)%6nGt=4rbgg?PE)YNqMz54KrLiWWnqq z0JB7^dPl1|0>svDR}hJfw>&>l- zRZe`K38J`VZ|mORc)zyp_hS|nTievzqX~|WyPlGH=52jVYyGu=gd7F7Sw-}dqpg1@ zBZqF4yo<9=!TE+Q@tVQ4fok{sy`Gs2ePHy=i*Ju7wkN?4=U7zw+^g%W|zcxy1_3~0U-*W40dIz6WPOxCSWvQ8n z;N)4ncHK*TH*|WfYde*9c)qnG{O6`c*soj|eLx6z+jHP|p}m_Bui>zj)q zkP+M4?6Sjd7_)n?myg%UZFLXzU1aX6cq#H-b)q>~;A`viuGolxq_4-~>#By zv7pcT<5P;LPq2x4fg6f87yxY+gRPnYlp zD1~qd&=*9dzRh}Yv!L0#zSh@ma@rr5E3i>?-G+WCensam)mSE3#=DcMEOe_6;_$EQ!XzTIJAOVt%1KSXyon!^%-o zmg5jcH{Y(^{xl3wJf15h)>#e{m@y-<`Zb-IO1*pL3I^+0XbY zmG?P>Ka-pCKg(s=Ybi7+@z?T}l}~gXqnW;vF{&WL4Aq5=@|^I!4KAD~lfDk?_|&=h z#Upr!X^)u!K&9F9(Zc&m&YeA9F6P*XF*|7pB=j|}@QtaLqh<(qq-alVtSQI%tu6F5UY+d7|ptN4FyDiQCmjd*{3@JphG;#tpsM4+Xus~s)(0!Hq~ z$i2Xq`vSSoweJh%9@o;6US#Hkd)=s#*i%fDpRuy9s4|uny5_@(O_V&v{8W$Sv^n=< z<-QouEvra?dkiH`E@m zN>UsWV2WyP5D5^PQ58O%6D*DD#{le-GV3Ru{dkBtkI$2Z*7wxIxl&emn515K1-8}f z(#rXrgTF63r0Z;$kZHagm-u_cY9KbHBsg8iFJQE|?<$)SVHSKnfg!{$!HzmxOmky5 z3*r{*R5ZuXd_poXO0vh9jeq?GI2E+{6(i!?C91_v(^u{=T1|BkU$5z_jQCzPeN_>k zW%@3P_}&2dBfbNs@A8Q6kCB_Zt)tuMe6*?Cx{N+Kg2I1?VV24cB)|Ed&>fz^)+Jhh z6miY2@GCQ{i;!&$QS}Op2B~IWz-_J-mro9`$kv%#4)rYCbbm`KRnb*(v~U|sY)#Ab z$?OnZ!AX7bhG4n1g!U%S-Ke$=E|&0`@ZP7b&yy%}!6b)Jp0?)56B<*5MYh_Mtr&c72MRkdf#TB}6K)F3bXai28Y@{a)X72v#kAzFNnt=MBA%lTxykg41THX#UOPPA*MjbKc>wJU*I4FXT z>iXIkoSSV*6agZsAb;(F`>`}OV}2>x+ZNZ_eg?j()v`=@hV=d>?v868R@ePu64aLC}B{3eBk3_pR)N3@R2W2 zS;Fxd;HvJ+q?9tJl~?~{@kF^OI1k)U zR2fbhtPx7sp;8DtPRgh?>^xi@`kMax1%nXS?XTfLO*hA7x_L>p@=}mWrJQmoo}$|! z4^(HAa?msUq~37I1{Ubkz%^W^fwi0?Xc*54r+K5;g_Ysg$H#vB9CLP2pnm&Z1*Vbj z-W;g!xofPRBKk?J%2&VTu6;uf6Ar0D(O$>eV>ib25C4m>F59eMv8|w?=NZ*6W7;bz zCG3fXVrphXW!##0sGGwE1BN!oBNS_zK1=_nKz%5qRecl|m7A({r<4QD^fV(SDOI4e0O#FC57VR4X_92g1^0fM5y*r2K za7H{{(kv(w%IPrTn@SST{c>n=iDzu1k>kq8n#^nII4&^{VE!uMl+0)S=3(7D!-&7) z@w;CLL}z-e^VUN1eV)qZzFi8%&)k0K1$TGbb)Mijj9HQ3tDqv!Sj~?LW*|uwTN;Xe z-{P?Wo0-~8sZ#fRVd?PJd+=5<$o;K)>{>U*>yJSt&T+DNiTD zD;M9EPUJ&t1}%(k1f1b)^X#ErJ>j$9wXGR^X^kqV%AO|23;4CX>dB zSz|=T=kR#!6V&x@%!BOdcEWzi%K%GY8B1l!kg@K)In$X2r!&*3&nkC1BZFP(bS6F6 zzaj&jDYiRv-y!MDZT#AuxrICF49-{$*Wwb1b2^(v9=_KgRV9yITmbO!QA48yPjE~f z$@>J~Wq12Zp6NC?G(Lxq%jM&wd{<6xe&stN2bV88PtrtOlZxZBC|de%pZJDBB9A$1 z%!qh4Cy8WT+&P_I-H8nQLm>PP;9;<_i~QwG{`hqPnhAxKz4ri!;_4dyXB7k#W$oDF+EGEVqsR=1 z1r!uJ#w2tErK}W1qY>0Z3{f$$B}PSKAy#5EL8Asc8VhPvY!OQoqe%c8_WwEep1V7& znB@81=X;;`d;fc3=ge=;x$VrIJF|1|%=+5(IuquT*02TMKk{`w6JIABX2?iIzH^pJ z@M~NihbrRMM0lwv#D!iG`lth1en=W}QLntQ&-P9mRZgGHdg>%N1Ei^X>OKu}JRaxw zu9(yNLr>G*y5DAKJ^zK?`c4L%7GAaZ@NIBti&<S0W6Sw$`59X-WXr{D z`8iuIWy@u3xq>ZMvgKE7xrQy*vE|onxq&S$M`6BO*!nkY`7K*+XUp%|atB-fz?Qq& z@<+DZ%a;4u@*rCtX3HaN`4d|nXUmgpd5SI1u;p2{JkORF*zyuvUSZ3tYZ?NUB zY-6XUjCUoXVE5Y#GFsL)o$qTXtj1)@<2; zEvvHStC5&mF153wfy<+c8!9ZhOjmMyYjN(?@%)5^9B~f2`?YQ9aSo>(yTG zSGlk)@eg=n2Hv(>F|jee)60(Q;Wvm;pI8j96WR~Yh33E7pAJS961w3WVpm9EG~5%h z_HylA-8#_+R^bQidRNyby1}YFuG+)HK{NL1yk8wjJnlWC0Pg&=OcIug`0%pxz3@}R zM-u-4wbk7jh=xy^ZDlXJTrayL@O_`>UZ!^c6pYup@L&*hgN2`EmcDxAX%U`SHN`a~ zJ{q3xgj*MIznC32Gw`c#VHdau3_m2TD|BQlNe+eX5UKne@i)p~GG9$db|ob)pV@NWAU`0}RD#Q|!71Q>46pMpi~Q6y`4>leHW?EI-_d5KNDVUz_G zWC`yYVdmTbrix#++jZKzVqR~T8a^;f3~rD7MOVWL3-679vO!V8;WbgL5G-?eprQrd z5A<>?g5|_!_dV=lp?F}G2xUox_js`^_rlkmM%mc)-K`$(0rz2Az;m?L2@SLH+Q+A2 z&fV|rcIEoO`^-S+3-e;JK+sYk^}j0@+b8%1Cv7kM1h*&t;vEb_c+I$8U2tb--<>s3oEdKC4``$cc60E3Q?N@g z9sG&v{Jqz#y=UAgssb~G3+!OlBzOWQgTgHa;~uF9dE~R~_>O`1_?qdh#Y zgr^9YLcB+E-G>hINQU1ky$wIH4fhf35^qDXaX&$NJwhb+_^Li3M|>;h5+?kJt>fVD^C717;7HJz(~L*#l+|m_1VD^C717;7HJz(~L*#l+|m_1VD^C717;7HJz(~L z*#l+|m_1;ba} z%pNd%!0Z9D2h1KYd%)}gvj_ecdBA-*ye&)zzYu^g3Q9YbW?dLO3x7Tp-p*ru*D@F} zgHA_MTrA<`-*yZ3rtLMT-G^ct@c!c8yk`5tJK}tulc)Mi2~l3~W?y_W^=x0z^>IjX zVXpv!r206_NV2y`9Kg0F>2#K#)q`K$LX#w269jx^IYLu_#O8(7r{lY}AeGr(P*P0P z-@5R53VU&oL!mYh%6qtv4&Fv1rS;K4$sOMPhp#0&<~8SIJw&@R`3ZaHkii-7;x%-@ zoxvZ8cM(A)>Ah-LOF#H{6;8q;q|Hf&6rgB&ue9Aua5XK!y6`<-I(XSyA20L)ymYLv zKi?JsRq;9muS*)DX4wpe&+8oVFdJqdpB3}5r-ZfLIDM8}(}zt0?KGHDC3 z28FqgpBP%cs!_w6uM4L}!&{Z7>ZC;2o6FFcUTD>Q#{1BcJEgqOTX79oVJ+AOR#@w` z_evY!P+u!IHl&_BvjU}NRy=os1 zFHa5cCC4)soLjs8wYqLO>SXMJn|g)deuAIWDTSY@ukHG|Mw)R=@tR|M#4F8WUvg-! z%S$-H7QX+!v0Es6u+m8a&j34&#aS2ox-;32BJt9umZMf5coF63#Z`olL1$?3Le=4Q zl{(cL2DR#7!55$NLfwyfz0Ao|^-@9=_UmVbXFzXqDOYYf8_G!sPv(ZhWvc({8NnsX z5-5pi3}cLG81pETh>J-g*zGcd83&x-y;Hw@t$(2g6j%vkuWRt4+ErLM;yuAO#ibEk#3xvE%DHPPE+OA^;(=cM zUx=nUv>;-cuM5o8rsqx51JlfA512h*_JG*~W)GM>VD^C717;7HJz(~L*#l+|m_6|S z7Z1Q)C3E->d0^&5i486Ohq5iuq|GX1H0o3ia? zU;DCLrB+!klb9LI9x!{Lj0et{96vXkn2#T|gEqA_`$O#y^SapsW)J*x4xN8sMs;F?esBY*cOb>;(}RJlrA(f zK1i<*3yKr*B`Mj%xDLNKZW4q}=URS0=3Z#UuCJ`g(2p1=_FxD!(d&tAxLQgku1uV6 z!WqQ2q|Y*mzl*pM>2po=`6gUw!llHbyw-PkeMEWeiK|fh4#cATory^;xe()wIt=c_ zB7GlXoH>laj~IVw6vHqR_BXMA$3!1!!l5P{K`i!9f{8wfSd?dqi9XqcXPVfjn(!wk zoKB3BrZ6lp(JwLKFHJauSomkPi9XXrztKdWWuo6^qR%$rT_&7k690e+=bG>_6V5Z? zpG`R5gf9~de-)VUO%wY<6TWA{MZ}`LO26^;Em%t|+NX|Kv=?XMT736OekS@r;u@q+ zB5p{WK@2mVSjaWe7n$ho@AC4A`0m8bD88P!K5;s+jyRjRF>wKLOJeOkp1z3hObovc z%tCKs;eRh;cqxKrgQwq=*pJwOIF+~!aSm|<;zDB4KbI0$C%yJhp1$ZmJ5zfk zwWK4xuy-LA=?4-U+843#PX=*4O3*ZY)Ber0e= zdLSSmI4C|WR5Vv9ARr_(EF{WMhJXNlP<%*`VM9Pbd_pL&*boqq5D|$6v>_lMJSaXv z%@e{x5@O@T7DzuzKtMoPP;eyA3euez8J-Z(fpQky(S$o0Sf3ErwKI_f<&F!BPl$^Q z!HYZy0Rf3IK~a%oV!}ch3$3WAE+&j!^65guqQVlwn2j4OWm%GX_LQV1uE4~q+edZ3{b*x>Qp7CH$hC-~qxe6WvnlG{k_L1KRc$w)mRKA1}~NJo$kttIIL zknh1~3Vd2Zq$#k{2J~&=;{>1f@M!@b86x$B1X{xS6!^RcpTG&>2|>Y8VXYu8hQJBI zCXAjITF@s<(uc){8#V++#e#t@J|QR}GDJ5fF(@w7pkwKw6Jy30wn6&PKEO+`JrQ># zX#)9fwwxlW?EX;^14ClL2x z7a2ercx>S@gMshRFo9BFY;;Vd4%=vaq_LGj`bKB+BhsXiyrv)hu89TDFEBbNCTL7p z=s(&C5XIE~FLwso8~595o-VI}sqDr6Guc1o#e#f7C&dIs!yy_O6PXYRJ=x^2I9+&b zoKCbep$~#Dwvh?ycCNC5bPSF0A7yK>|Cb6|jvxP#b1+_+{wN_LE-WatoNmd`|LU4H z)j>2Phr|X1O$>^pZr`xIryKUV(Ef%&|EKF679SE9sW*0ClCBqaYo1X-@$o9H4!-P* zGX#rX#?B)yE@%?@pQ3t2Le~=)5-~}Yh`Jk+be^%%dOXAE1_h6Wu14nr{jaJVfk82` zF_WTW6XSKTzr*77(4~k3JV*4Anl++?BTvC((Pvmy(+DQY4`}p8`3pm9Z%fWIo zDWxjk5Old|EmV4_TSRQ=YX&iiQBiQl$Lyr2py=SxAW51K8_7@Zu+5miA!}wkwUthq ziuIcSPRBkwEa`nz7?=@oQ0Umic(4&%rd_Ifg@~{yxD*h($e6D{|*;lI#|d3gc8GqSZKwOQDHhpMka*%g!bq`J3D|U%T#5z3v0N(3X6)0)W=80 z^TS(JG>0e#=8qmd`#2Ew4kgji7!yokpm(E&HYH75qVQrCeD2$vL!P#W#HtDN0DpwVg+sT; zEW%$`3V9tWWCT@SEBe$PgpUa>QT=wX~rLfN?d;98qd-YaaPIu$-V-tI? z%{={T)lAF+j}zr7pZ{$WEd_h`9{ zCn?hZCsKTOmtaL>2(VsugF!k9m47rCcVH6lOt^UW$ZooY7J|EGNQx49E~ER*I9tU@aWB1jAY! z(?>}iU>pC46uA7mbmFB+kaCC=0r7b%9bwJ6Y$8D8SY9!(jFLJ@#(uAC`emaDU*Oih zQSly8aIRHbnCSb)g+b@53MTq~VF@FGq7scZCiD4ZUl zAM2B($`QtOUcPz(pXVf>31z(+^{T+ff~44NkkIue8;&2tR!I`~OY!9~s?Go7R{viu ze<}5YZasOwcfe#`(r|v-)$xl0*x%&&# zBJ?K-&^tv#U!jxwKo1qidaWi>W%%=BGzOMIV9^6C%7&iM@1ec0&_QZwiD_ZVq4Sld(s;6<^kH8A-u`n{SEdN*x3lKH(wgh zSMNY-7E&da=CCr`+Z*x`@e)*e)V?Wyzq~h>7weM_dJ&M90E@HAKdE2A8`8(~p*RbM z!5$BVea9}=DKpR5xIS>7#4j#3BrHB&lmISJDpa(vtYl?vQ@M(5)oOOy>NRTCs$Hk9 zeZBe(8a8^Xv93weX3bl)Y~|3pOJG!#mz9!!fPV~KG80q~< z_H*F+D|EiAM)P$i)F`|EGRb}cZJ%b(^*8DJN^Wh=d+GbbNz!jM`F=^!(T;9JeOG-lB!@` zL8@pCYHP_#f}LN{s-jd;va|vVD>SNr*ORE@!Mc)E2|w%)H(6O*;fMV(J8p~i*6a_B zC~cmDAuZJWr$Z%HNL*@o%LkuTv_`IEUBOz?SfJ;)53McnkGl?iWDToehtc2zezanK zv|{N%{mGMPMg9X{!m2fXsNUpF$cz_6vI0+9fk*MfJ&2b7(FIN&`k zSjF~N2R`^61V7l;P~tVCJ$$g;RfP{WSiFY9W`fsV=ns^*4JBU5pboD+g$~ojxG3@a z1*WTo4{pQx0X67@+nc}#w|9XLvIjBtfyjRF!8k+UgLXqnjs%J6V_%GUN5Kd6(eTm1 zM-QKd@QH&DmNgkZSk@Gh(?R0)8Sue$X2J*K!*#9H8a~U3SAxWHtcDNfvkpFJ_dR^D zTqodz`t$HX{U~rCj>+1CQ_w&Eu8?ZQ&x1=yW|GV%De@T$*MUw_f95ybHko~M_Jp$+ z598qK(n%V?{Att=lhB{)(69>6Pe-yjNe7aSB%MiiCh0=boun5@f07X-6G$eL{DfpW z$ps{rko=Nl2FcYVGf8eFnMHCN$!wB2B=bmKCV7*jNdF%31Cq~4THA7e*pqZ1=|ZwM zNiULqBm+q%k<^frQ;C<5%p{pjGM8jN$wHE)B(1Abc}O~w^dcEZQcp6KKhj+4TZbU>%kWNShY=^WWv7d#s!q5!TV-X-t7_!1G&_Bb_1{-wZ zi220A5EPMwd8*Zzzkxk`p}&U@24COyp`q<38445%!BOW6L5C}oATT>GuO89SJ&fO^ zhO%$rOvM(y(BH)v5w749;k&vqj06fbBIqN)!WjC(86?t(aQ+E`@8-t9^9zNoygWQV zBlG;?ArE1}ckqD(TZo`!OLq6*I_JtgRjm3p;A$Xs_ z7(Ceh3?rl7;B?sB-^8ED*ak%K03IU% ze!S;V_HG8RM;zoSLq_lJ4l^@%i;k(b}N$9egUHRR<_1b_2V^71D@siNurHBXn< zBeu*o)bRS4T8nzUzTE@%00uvjz98GfJ`9EBB$elJ3;sF6)ePF;pU$uaE!EcWB1`z| z0cFN}R`KvBLKw6LC-`=X*G=YN^neb$S@zEXzCZK7vfIliFSw%ptG}6WMQQq1);FINk$UB7Yj*ITy>@BDW6-tT|> zSyWtd|G~pYk4v9CefIpt%UA#98!T2e_CU1XKMe?YHPI8!cE$;e;Uody-EE=f;t`l z9^416IERCsiwOssaH@(uz&?|BAdG+X0?twC@m^a#@!RZ566TAj*c&ms~IMot75!&SW4^% z@v%P6Erq{^vh)H~jQUg+WBIaFJP0^n#aJKfR>t&t1AD2sFR)(4eSkAmjQb-`#a_Ur zD#mYIItOF=SRXGHqkocAjQ-A0F}9Cf6{EijRgC-JzO^y^QNZph9s#T;9txxSSf3@t zVt-{C><3D$eW@7J&o*J$^uH>g&($H9>Wkl8QCC3R4_Y7kzmypJ8{D7PZMgqErMKBQ zt39!>cQ#>vV(fpgz3GX);NCd;Kh>ar8!X`dzX@j%i~Ms#=A_yPHcCASa=_D49pMWQY29}z7yQJ!I?>V zR(702S@!Pa>*=CBri=3&`P@s9GMA?5Cx8!mEpZMMmIeJ}454s`ErHe2>5aZZ>#}>v z2~sJ$e?*F}+u{B(22(xXKantQrS|6Q`IT)&#40(|EYwa8E}<3&s7XgZqCvNC)po2EqQ1 zHA%oUej>Cyb$DH`-Yc)?k9#dhl>n9;)4=xiS1qNi-J6awc*dbjdQsq`BuF3c!J@z7 zpoV2bS^Ic416h6Fa}30eV|xtme+EGsc!w8#Shg*cwZk3*YlQcIV_1wZ=5=Gf^wZv4$3*?u$+B(SQ6{DLc+)YBvE= z#jA(OV2%6s_5Fj#I9{#rz5}lnVwhbFY&8bcenOlF#97$1UoU$eH>QI}H1C5jA7c>L z7ovP2?97c@c@TXX9_#9I;r!_^s1?q0epA|*0=7GxL2DXcTu(WfTv4IVCPEK{*AKj1 z8}n74n{gJmj`j6eA5nVj&*C7qX{~U(aX&jTU*IfXV~B?`;>czY^^kveo>%Mfnvi=# zou0T(z_S;g?aKBw#`xR=rtx3DUT6vRee?AK&Rxg-i){*1M6Zm2b?gzOJivs>#df3{rU&b@oWL8%G zZ9<)XhyN?-;}tKqeyk08NS&ke8*}`-`tYYZLLfc7ro!uUenf==i5$@PZ}QpSr7x~N z@u*U#XIkRFPiGR82#?Ni@PSAP_h$Lt{=4*e%fs`RNDFIeTB^TqUrEesyv<@tyhP=t z#CK8o<-&4^rzf1Cj(A;(SCrT%^O9nZg#EkmiNe>*iaC^@KBk4&Q~X>u3DUvm3vu7z zbx=5H@EeWzW?Xj9m!FSlaCp^&KE&rgL|IL1!0#>KkuwI`a4f|5`+EE<>8m{?dgii6 zW%>J-`zw^4z3{0{_4AXs4@{q7;r8V{|A}7LgAe$%T@=(0uXc>jTdC_?{*fg1wkE(Xd*~zMJq8YCci5QH5|*eJ0bhF&6c;v>y-i5tc ziif#t_+pHxuz0e?Im0zXVj$rmPY-x5b3)ii_1ikRfjT{~>kaQa=o=ds9h9KT*9J^Y z?E1vuiC_hNP4f4F7hCZ%_{HiI^*nFW`au4?BHl6Kv8w#5 zzMdXEi^MC0g%D36T7fO3!`(70GCIsJE-WN6KFlK?U5^`h-ePG|FEn_q{^gW&czjq~ zZ~k^BUgUxBViA#MIpsxr{t^?c8~PUtEaoqlputds8Wt88 z9T~&+jxT$e3b*F-=GFGY*xPmt`LP)Ix|}!J4~>YO*gI@OSQNett#@S5n3&jjcw}0b zzg8aJvf(vTzOnF5CvIi|LcQPN;cQ+EH~>P%^@FLeLGV5ZLlM~A{%VFCV4frEEBYqJ zu!pprJ9Sm*aCKuhemy8;7O{}qh=t517Ba^~pJ$>kFwqy8=uL`K2E7ONh4+huO9MRy zN-;tF+Z?Pr424B&vV`pp@vsn#dhda~1!6o0=m8mrwRLtjJv(YB9Y=5O2W;mUIuqmZ zfuScc?hg!J#FiW-e_}jNF$5B0--IE8ShP<)u?<&CNyONXV@M{(XEiXS660}$A)Ofe z9Slo|#lFuV7Hub!Sj)|&EMj~%1Vc8l=)-e}YjU-eOI(XMkGM8*J~2L{f}wyIpV7fk zNL-JjR76~#xRkg7vDBaM4}3NTgEcWcFV2FN_$^|4;>N@}VjZyqaT8)^;-_^;+*q>N5#6V(v<_1Fqaa)d(p4gE%iP(uanYcZ1DzP}8(}}y0 zehIPoW}89Wo%ET+;ypT9#NwgAY+`q^&mrc$GmJA6dy+nnSeyv*iE+#jLjiF=j#449 zH*pa$&UwI4N<4t0Bn{y0VIZ+J@gQO?u^+KLF^*|t&=HICuLCiTnPYGv7CosK@ieZM zh7rT_do1`9S0Iicu1K6jY(XrZf3hS_C4D90CB#<5nZ(v2KCz9kx8we(LYzx_TjG4; zs>FrF)rd=p?TD>?czRl5d*bTE;<>IG#NxTGn#2xdUyIm+RfxD~NKacklT;x@!d#BGUFi5-cT5IYfP6SpVMCGJR^Pu!WfkhlwRDREa~>w&z! z-H7dpU5FisyA!(*_aOEnb|v;FmWd;X72+gfcj8oH58@@np2V5Ny@_*)`w-_7_a!bQ z?nhio>`iPvh}XA2u|4qsVh3U$Vi)3p#9qXMi2aHEh$D!H5GN6jAWkJ7NxX#kZQ@Mg zFyd_Dam2aAQN;PgDa3`u^iZ-?N^C(FB;t8Z{;)BeZ~eGGY)EfUT$$K`*p}FZSWE0h zT$9+JxE65)aUJ3$;`+p?#NuvhCb1*wvx!}a^ND5RLSj$iQsQyM_Jeu-G;~4bKx{$m zLTp9sMQlUtPh6Qeg4mWgiMT#-DzPhZCh<7pY+{&L%0e!&1#v#H6>%Z44RI-PWn$|g zyneRC_Qdsx9f)0tU5GVwf#*eRLF`X#MI1qFL!3lhnK+f$mUszqed0`FSK?e^4P7wi z6Wb6M5?3ZJCAKBD9?I)mpV*$*mDq(?Ll=}@#5TnK#FdF7i0cz45xWvEA=c>l{>mh_ zArIq+!7EXbd>^f&u5TVZix* z7;yX?1CHroz*#I@at^0*;(Q+r5io9p0cROu2!oU{MAP^?j+tW^NAYm941<`xiQ_aF z#*zIvN)P8tU`V8N6R12mUjzfrLBW7CfVkx4$M?Qrh&K3x>!WEq&S=Geejdlx_yWhD zxJNkS7!j{IXKX7@GzS{DV4HD*Ind(!KDHevn)8o(Y%fkQmM*@3W4m#J8P4MSKDHm^ zK4=U9+mREbHiRR14d3e7m(N*-ZP<>Gg&y0J6KH+N9@~`@%)uT`jO`2cLk*0hV))bn z57@q(V8*tH9|JW)9z=R)S8MEddIZPW{YV0(3f($eV+a>w+B8Pdb{i{%sPVLQh9(diIMgZT|-bJnp+*uJs+ zqo{t^&M`l6e+Jt-?mv+~wtFWiow&ae#q>S~|KV|f`HA}B@!$m3;{FXD7g#@E$`6kZ z{^tFY zw=|gY=lu&l6~P0}|HAz*%7^DE%*~(lynpFs*gtq)!v0Id=lz9IAH&i!wg=un;8RIF z#54a5g(I~5_Rf!YWB;Z;K0H}p97QRK^l<+f`v>0sdKvt$ZcpXK7yj%6b;7{?)yL32 z`S~87I^lu)58qG71NWbYp?~B4Gaj$pf1ZZpQ(gb^%EON*WBo<>#5)gp`Fsq=7cbvX zLwR}md{pJZ{cFshm#?3p{GxnffAaphm#Vzca1CNS1MvKN8`>AoAK$;I_K%OM|HS-_ z?UCp2Y3Lt${>Jj++#zh;9I4_T{p}c&5cpKU)&(F`G=lS{4-p1=1 zJf8nLKRm)ki{|+aGqf+BpRvE?`SmvVL!Ey4`y1!?n$~9!9D(Zg)nCQvpAm-op+9ho zXfeEeqYQdpK2MY58{f0Z1IEWaR5rfoeen7NwY?1cTliD-*F3-ehV-~SKJ_HZkEO%6 za`M3K`7^G#MfgvQPw@1`(I}3`0fzUVaeF^Q|HJJ)4c7}ieGgUrG5_I)8?O)Q`7@nH#;449Fn)jF9>Vs4L5#DAeprlaIr3;y zPB_00z^~rncPnVzkknEh>GNqr0r5rRBI0jEgfTq53}P+uJYpU3Nn&T>v&8Pir-}WD zza|bO-a)J|%Sd6P>5FaCb7V(e7ImEfdNi=TOnmCX2ONon!#}T`beG_7B z1ouY>u^0!}5bH=Ut|Og^;b$aRa3}trSd5!jAPywGIBxuD|5=b;PkM1(luSHJ#3y@8 z;&jp*`fbvSarg|-OuUiUo%jf`AMvNefy6tB^~48>lZm$xrxTwe&LGYs&LS4) z{T$*P(&rJMAr|u%Y={d;e~P$>_zJN!miy;Cv6lEKv5t5=@$^| ziPsP(6K@vriN$$6gZMkrXA$or7UT9}o2;(ZM69R$9EhDsKUOg58xy;eK8RS% z4RA<}mseFo{1 zh{e2(9>iIspH3|18C55C7{L9j2tC=)Ce9-sD)f|pN8$p~Pa^gweGB3u(vKnbBYksX zDVpcc@5;gR@5FOSpGx*^iFKrpCUz#CL2OU;!S|yQs zNcv^Odg6)1$;64o>BPf{#XPPW#2KVtM4UxDj5vpQF|nBURZ}qO=Mal|K3xTq{sZEC zYHziOi%360*pt3Cu@uAi$4Fu=@e*Pk@h8O2#4Cv1i8G1CJhVE*ex&y&7W2~T5(ko= z--UqoK>MpF>Gh=lkT{um9dSDG1mXgvVt3N-BMv0qO`J@;mNb7C#! z*MK;O^j{F?5x+~EOZJ_J3rIhi*oF3&J8==|KNd{!U5F(;_fIl$De1ctYe}C%Y)|@z z#5&TyN9;@-BlKk7h}fO<0mS*F??UWH`YFU>o}!L8ko3XC4ix__Vm;{tiStO`nK+sB z%ZW3H-zSbB`&Ps`q>m)dBaS65Ag)MUM0}lC8qfWkPOK$fNvtE@O6*L$p4gqZFR>r7 zp4cqR9{Atv0X}YlPcrhr@8bl){TMX|!{~>aLur&y+(*KaRjqmK>dc6Cuj&B?d;`&Ld`r;@6zdIgM&V6yN z;Y)lv+n5qhpO1S58}j4hmSV&k$HnlzpYd68eqR>fWrEL$y`CN)=ft~VJn(T&eA-+v zj{D$qbv*EK&rld05{&opFxpW_*6R&{5~SS zcSOy>hVpW~apYgHC_iUoeK_O$fYj-Yg}bY2Ha_9b?e&KC%2|wNi~FMDEdYXz?VsCE zHndNE9}-)M$Pe#B;!})j4uO4FmQD3#D180~9*?5^@^N%AD+K3<;QkP^ zRrq`r{$2*2J|8C(vsm~%7AF|F5!Wkx+!@~}!vh~D9%nfI_&BVw{9>F`Y(d8NAPE2Q zapiG_{+*A@GN@MV|nlT%WSobB?@tir5yua*bF4}6}Bv3z`74f|K#gBzJ2ae_sB&Jl+4amFX(dEgvx=ubE&7|yqRUX3yTH~o%Z zat#|v+;gy`w3)bBWmpBaq789+@9;R%x&QWiLf^bE9aq?*F6iNo4L`1aXMb_)5dOV6 zbo-0WmIqGH3jg#;ZP%#YEWV_@kRGn5Z(iFudvW+@9YuH8?JkL za7=V={N?CPcjGh|Veg61R;xme+OPhz#rvm@>;JquuCe^vvHP)wVpFCa6uc)Uut6e@eg%Z&)qWO z>lOVfb=^AP-GYG2$(7f?EONgvH#0A}{A2|d$QfsQ^}iX^^y>?5+Mc`P z?*BSJq4ubps%snFi@MN8d*&9Trv31((LsY^BHO%g-|)JhMcd9-+W*nYFXZ#_N7mN4 z(|@i*JL|f!G2ZoK>Y=yYJGOM+WZ@V0)|0cR7PS81_~`IO?Oaz~n))zT5rW=k-RFHgx$^I#=u4 zk9JI4Gdbwx_cg`_!N|bP>W$`%**`+pctMY}t~N`pBlWxYgiX-hJ<_9d?LMDl$Chs($}?iT)2KU&MwSnfWyQ( z1&^Zl&G#I9^2owg!#7+%*Xma0mutUqgLsmA|Gaw-ic*_RI~ZNrKi1+$&;9Q@m3moM z|D)lkjHeDo4~{Eq+SSV#e{R>T-jP!^F;BG1M%15_xO$!>UE8{&XJYE~&*~`0$Mx7Y z`BaodnqRGXFT%N1?`@y|;gRy){-YKAiw8$sSk+>})H&k^LJJCg zc5BAlC3c%eE~vgeSqk6YT6gmF!Shq2l{F20zd!zqe%VDgk2>EEJeoItNzI$*(|foN zx~^<^5zw0pb?xHgjUA^Dh?9{lQ&Slf0QzxE&eChZv13$`%7{2n|$gQ(`)@VMy z&r~hEp`u}{{&izUZVtY;es^FcuJvn{8F|DLJqzqEAZ;tiEw zZq~fN*0F!&!XMvi-SEKS^{3C~PdME5lR!KYnj11od;6!wg^}l5%5gWheY8G(bkpvgzD%^5JYfEveohmg#C&nvy-J+}rJver zivmijN9}LXEA7dVW%H}VZ<+GS@DR8&=g*A}qjxp)aTIX>W04K-TXMuU#Cta$fu;o10($F=$NH6}7)Uw|)DgYKvUr z=kN2rdu(yrfQ5>S-J@^k>uPmNI(4r-bQ^TL zS7k_7(q4Hm#HP=?*LrQ++^+MtU&VfPT#1?NuJ*doIsjebX&| zUrFC7OM(;T*)^$mY4dkqwcA?DZ~dGN-GA%VdC}spuU^%>Jahkaa)n75-Js~2rC<6L zZ@PTgag&=%H{V0?d1In~tCYEPaA`@!1FNnL$>`Bcd;aVA4}0&tP~&7p`&s&>JuVL^ z9J2M-fzRq%wO{MI=i2!Vl?VME{K@lWW&Z{HocW)ze3>I@Uf;+htnsWqYz~?#mq5(dWpfPRn=ge7SK# z$0k1QIv%enZ=3&8-}S;fKYX~jR<9TJkM%9R;&SWsEUU=6rz+HcS-f4|ykW=w*gvcr z?%^j<_x1bSQ!Y#_b#yy_ZTynzu-EaC`9$>TVXobrM=MKKrA$i39xtad$JNJ6aBCXc1KfbK_{FSBM zq>wQ$x}FW6;CF3Da3%0tP}Z3Gl{Kexu36@}#@D!{v|I7j^<`Uwu3rvmv&*98f~9Bm zL5o`4*ta9GO06c2jT#4zt(m>b_4Mrcsl|a;&mTS1_G)CMZnLtR|6b{{@VhbI^LT`L~dElBD>&%tQ`^-zo9X9v*$U_Ooe%_zm zD<nDN1NATMT)2JNz~YsDx1U@dKP|+n?TYrlENhDSN!r=F-|IP| z+r%3#U;X4ZX!+?B$K{V#CmepVfAQ^xV_j|rZ2U6qzSYxvsb@FteOo?pY|DpwrSY;e z(N2Z7_EYP|E{J^Zn&aG1ukI@sRxhyY?BBEQwgr#8TJ0X$a!R|4X^9!>$*wiOyX2Ja zbu#(`i<`|q_hWgQ7ymmwPyr6jif~>Hq)OFKN>)06H;->yy@Fx30uoq)>|HR(fzWnr|NDzv| zGy{%?Wzj3cDqAU|O~ z4fa1D+6m>GZQvDyi>;b@2OGHP)w{W!lY1H%)4?=Fdgv}Z6`M2zq5f}^II|h&Y7d7Q z$j!^oHGTQ+(O3`t&s)Z!3|zP)0cFO71@ANI+c^cLpY_t2D09ZYoP{zu{k=4lMPq-M zi!x(I<@qQJwr~FwrQe`{1t_JVR*O*P?ccN*Wzp&(pQF@0dH4lN{r<&YqRgn|vK(dB z!E-AZYj$R!)Lomk5@k+>;j5S&)8s3Z>D7N{GFg+o8o9t_`Wlql9Rt>)be~ac9m<>~ zmzm6a`c)?5^<%$AnfJBxdX!KOCZ#WSZa_|-^T9@x+Or;;P-cv`*o;yidWgxa&9k;3 z=QuQH?XRfiOeWJ$-(b?&(eoSByLVp2WZ+$CE3$S-0Fwm~yP5QJZtyK`FUU+{()r9; zCNs8l+=kopq@onk)>LZOa^N9 zGwHmxVK&=daRQUh_9vNiztw67ZcmR+W-?=QK9k^|owz+CAeBjd-c=^Eo_GBLx98oQ z!=&@R3`tqYTWpS;Ipy8lcj-K(r;Qos5n=jIQY%=@_hASjwcXPQzS`mtNhS$()BF zOcv~$#iTT81C!AHn9Rs1VNzeC4m%%YMR#X1dFwk&O4p__>Gxz6llo@|nasLf$Yjy( zDn~KDWX^B9qSY3oauY|Ag_~r+F}`PYz+SDC$Ed zvwE-NY;}amobP^P(s{7$F^uPT-ib@^K}@=@(=+K@JfCx`Z<$Q?{+UUw|3fCFp>>X9 z{Jk%;+_m$>a-@nbg1c1(WHgb}(7g@dA?>(@UB3 zE2xsk@}JOvNoR|;OloKMVA9>PKa&MXqnIqZ5y7OsZxWNq8MBzwmMmh@*>x?GMelEC z(r?=VCIfGt;dMM?A z((hstlkQ*7Vlq&_h{=rhYnX)ofytaj`Kz?yTI)D2n6WX9~TnJn1xJ(t%H zGMQ!ZGn0OeuQQp`v4}~X@{&n?Z(DZ#m({C2lLg%!nAEoE%4C`ALnt>3^K@IA?y9`i z?dPiPIz`%j<2Lg22ZdD^o^Xqd4tDK*|BTy6x$BzW-hSX#<;QD1BRmhdRbO)`@c8T} zZY$a~*2M%UcHvWd$-l?dHP23?H%JMF2CAX4y;sp z-H)xTWnPXt^62-*Y9Dp0Bo7FlQe1Ov4Y@~f@`vSaHxdwYoe#uTtQF>UHH(>kd8J*|e8?Tx)ydV6D3H7lYzo ztoxy*JY#0T_IVFpxGk*Wdw6O4W^zs2NnVBVPuybs4_WUz_LjV)|BxqlYB!OyJ9HT3 zUbns6#U->w+Q|lT^6zPlG6NdRH!rk);@iKuyuh|;zHUhk+2)4DXI@p>$S=dzZW!U) zSPmK7wO+by6S-@vQ7@D1O5Kh&%x#f6L@SR?h@LuhVSyX>kG5@#0E$bJ?QC=AaLz*OXV--SK|^ z6GyqxsKvF5erqjveZND@+V%D1;g#ZSM#Qy~hi#nvyi>!L@{mg3g$Rx@ooSC-FBnzw!U-1_nt%ijC4iPIgou`i}oy%nO!wL%78sJ677 zY}+NcUV5|Ea>{#2E~&8{3LxDmR=k_wv}LMQ*>>@6q9W|DJN)Iq_2pLu@o7YJWpD^*^@=x95?2I`@u3p{cmj3JisCLCw-r23fs4EA$%ZHENEx2>PzPzz& ztLZ~ebdh)NXfrfnP2b+(d=2HdD3y=_bTv6Wo<$?w}*NG;@y(%TpeO0-IduGiKrnQydn%!i7jB_X1FEI^IpK@rU^PhCdlI4U2A2!XM z&_llQ(Jw;|RdbWK_t%E3fstAn$#&el+{KKAAKbu?JZ|{!LT3h#p;}7>DZvSv~5Lht*-}FX*@%bx9qYy zu(*Dy+xqW+Y8d4p%b!(l>RlzoL4L<^)!y1wUb*$PX?VNOurBh4(UnS_Z@J3dqb?L( z{k(;ok~Qy}507<~b2HzPqWg808=tAOJXPr?&uTNNs&-^2`H?1Q^Q2R*^7TjiM`*vY zm7iIE8LW43la(>2lU;W9kk?La{Zpr|j&gL!nyA>Y@2-(Ie%4c!@&+Fh>y$(Fo`q0ijLx1Q4=@{=x5j_9Ug3tqY{mXt~# z_;-@+SJbF*+rBFuM_uLqfz~tES}AgqVGC~l*tw@%#o41;(Kjw~NP}}TdwD8y*M#ox z*@X0vf2p@)#7Dh4%WE%e)qHxitK9IjHa(`hw33}aty?X%dQbV~kmxy=-8#s1?=+o# z_77;MSH{i!bX03OtyQ}K-%C~H16?Y$DPB|T*14x+YEiGg@_YRrty}s>8~J8n{~6N; zw3ORT^1R-wYHL|DsHU~9m5)67p^8Nv zTyy=dC+~ctldnuT8KN8ALH263{{F2Qt>p!GUOfo)QDnQf3#aVd(^t-3JMcy1m#*@L z)d4fsjBP8Q`rU5Q{$rkU!65eoJ~^%BW%-Gd2gJL}HR==`u;|@DUf^|NU)Vu+`FNKL z9<>g4k_Wnu8~*9)I5*GB9u;k#>f{F(ZrJGOwUhgNY?1b;!2o&0*H5nw`9qd>huxHH z#`U58!B-Bv-tD7RFHM6&XEVJ>d!gLm3J4`h&s|+uHEd$XZ0N26(Z9 zX~W{_Z6loIDXTA~7F+d@AI0r;>iooAe#8ACaamxNW)GM>@b?~Y*A+B|zgJ3;)pO0X zoL5SXr<(N*SH4nor74X|Q(h_CFJ)}hhP+b7_v*hqtT%AwX1yP^c%@i3o>H{e>XlMq zZlBV_cU~$v_cY&H9eb(V)$E*{y!oXv=KG=z9p=AOZu%`=Q$OLQlJKkMNRN>(mH7IX zC(ZBiQhAF7kOdm}f2n-@QR$6yzrIk8Hp;lHIr>7ml(J(&;N};~$J5?wR`Tf!rL$x9 zuFjM5mp`}pDOiNd%*uwC8OcNS#2DjDisDyesZP`Y|qfZ|5N2cC+)(y z_ns(D5##EvIR8Ycu=3`>Q~RDM7q!EGYrgr3!tZB4QC{WDt=j&>CrVtlZRt(@6J_(n z8&!UI=ZR8q=iKuwuP4ea$EDK_b$+6>zMkj(O!q`No35!bsOl5tsr{Gp_C6_9ly1e7 zhukVv&e%K8(VQt&dc1-!9zT{U>+g@V+p)1!`Es`AQO@V3O8=}4MZbPjs_ghQXIHC) zQpNtGAowp;YE??wCk-l9uI$-5d2!EDC1dq;P5(BaXQ5Q7WFMHUsZ^@CPt&}xeDGLl zH0bTYEv`RS9#~HG2*`V^OwqLa^xHj;mHqb$teb9ntfY1SZru8%kCoijNhv-bKUS(9 z`l7n^q{qrPUw6KFdCX%aI#ILl=!nNk-@5N6oa*yfne)=)U{UAC%C2AfPIGAfSh1P% zWpq-_$BI6s$~y%W9xHVNOX>ucJW>vK^Bnj1+9M?>H>Ks;Q;(FoQG4q|?R})U)&Hup z_cxD}^thp?dait=5y$3HN|@{#h~sdeYjM-P?T zwezw^-+rj9xqff|nEZ#zNbP5BQ;$4U=0ELsXxGk%O3vGwah4k&D(jCmD-K%rQ2E_I z#rgEyhf1KOzh*@8L#4+!zn;I3f2dp^GG*uDkcSE%zj&y;oc_bD7X2P7ckLc{*>r!X z46w``@v6;3rFQA{->e!vR1O}feyyn;u%8D0A1X_It_07!|3K+(*?wKYuMZR-$IE*> z^B*WNTUyM@KKekpHgD|}dG`Zl^p8U_&TV<1^w&(-G;P%bWlY}I8{HQ^P?EhgO)XO& zDDT(W-0#}t2TFM0sLm&%A1Gg(e0cb$zz53F35Ty=82UhYb|E;dwC@AO_m2(Et$I9A zW;H(BBHZbLGI-Q`Ew}3)D79FC_+iyfO}7I3npukG*?q-o%bH&E{UpRYTxxL~2)eDc@SBAH4b|G;0eWjM`H#J?qxvwQ@xJ0^^~?P^k@uC-HY);7ynA2So7DDM!y)&TzBLOr zPU?GK*}7}w=$k$6D^DAZ{r#Qx_mv;DZTsJ7c3=7K?j8S$_V<%y$9-0!)XYk)k(FAa_?}ql@^os6(xp{O zwqJaS(n@n~%C`|EO7W-3`lj!dC|f7a|6tkB66Mq8-tb?dj1H{3_wT0AaRe6pwY zd~mN=Nyt`Q|GZwT?C#%g%)|U*rBTYNO_fd-E29b;K5u%kSZV!xU-$k$6e~A&mW-M5 zO|i1*{rW*W))gzus~6PMEH75RT=hxv&;`ZHrMBravOX?WYS^b#w@)cnW}a(M@8gNZ z%B1*Svn$0EE1Hha{pN%gD^*)12D~-8SUGa`#aBB97b~vED_0BfDps2J>pZ8LQmj>7Gz0?-HEK*jr`1a}V z4~vxaFK>-|c&|vQ9yon?rJF^{qQ3Job(e~i9?QFo=zY3KalN=}(D)-o%6N~okJjZB zDY?s9+`ILCk+S_>ySVmSij;NQh{`EziNs%)1 z|6}iL;G(MX|Np(iJb|E~sGz8*R8&-C)Vi&$sAyDVq?A;Ypo3zeOfVJ}6%`c~73;bi zySXkEZL~{8X2lj26%`c~85Nlo6_phg6%`fL|9$S<3*$JT?Y0m9-^$C6pU*w_+;hI? zdmiqY`*3dfT<6p>wm)px|Ig?5%zonQqeJ#B>Y4rB=yeuKV$bZyUE^AhIi_cJxOEQyhwi77OGUF-ojvNhAAcr$xAy-3-|2z;f|VYi zDA=og%=O+Mo;}at$9#6_GSUdhulByjYCcHeHn!E1tm-dxlXt)Q9&@;{J;l3QJVyL6 z#&(IZJ=NGQGq&}|p9rfkw!@758;ou9$$^c=wt1(!#@IHWk*G7a&G&-07~AS`W%bu! zY{%+bB8|qj{`@szO~y7)_v(Kw#`aiayUo}(--GTjwxf;xoyNAg&chC4JIdJKV{Du6 z<@Xue=6m>Zqt~C_$Fo?U-q@aQ93N_IoAtF8A(OnzznfKq@PUpweDZXzX8?C`;EJ3f9O{I>IuwlfR{F za*I7VD?GU>@uB}pja?=in>`m9!l1q%&24Xg`qXc~*;>t5QfjL3yS(*%{&-3DeFUZH z)L?x(`!p|`@lD<-vKja@@XW-(`AMfYJl5b{vhp>4m!1Efo1Icu<9(>f+^5DBHI_Q>c8c>Bp9h`@+xxfI1A9HN*8_V!u-5~7 zJ+RjU|4Sb5oh~NN4wkk$r&NR8{i)-2_{8h;(dt;0miedV;(8eWsq_Q=`Pz}kv6;6! zB_8bVPtEz#TTuk4XK2Gfi}2eL<{ zY3AW;kIE;|pBY!}Yv9;o(oOZrC(tn}OxaWE6R&m%dsLcc9=`Udd;vrzQ-$j>V4w1paa>X z(lqn%wMXR>=+BI+_J#jCSmNtRcZj&Y$E)L#iEI9)`)C!W(lY;i?NI3l`t!A;^Qd5{ zCtm3gaea?herfTE*NOJGMa5TXntAxzqw)##XU0|gX5!Q2yPU#r??6#^3RA~r`ozog z(JG=!%lz}TL#4m>Z_hliXmQG7%M~BTYfm13T;sz<_FpFNm!kYW@5n6mZTX_C<8$&0 zvQi3`uU(zH##5BV_smxo=B)O9Xg+J+fd>*{d0|1?s%4p3p4=i&RtEna>~<|PvTubI z)StQjqjziX|9d^K*8_V!u-5}Wmj^UHd>iQsk;sf-iA+K-3RjouMT-iNDAy>7$`~n8 zNnsLI7}+zr)7WR##5$KaCi5}fF-c=(%;wOZkWQ!Dk!?@c(=hj&Y`2Jgh9yx8u}Vmi zT|#Eqy?L48W;}y~N7-eRD_BNh*QiA!+`ZhSQS*&=&lUNw7;%?F=gBOgl&F?bGPYIT z>QD2gn?7KtU;4)W#9$RZO+=-y&SP(0z9NL&cyT;mNY|{NQR%;ON5!meS z@7-4CmD)Oa&g_-LDqUN+Jl zmK~Zt!t`yRut5IsFORt$C~knT=&`hiLQ7&SV}to_f1ofez_A0qH}f2d{p-ws`yWX= z&@pOZ>S+|uJ2|4XuFK=8YQC{hemH!sT*Y+IRAu5NTK12i6JtvD?%oE!et`oyonq$ zk;Q-XW7NL9AkLAYjO8O3%Q;sT8sk~GRl>0={BvV$Rz9S?nB~;j+z!P0*d8Kbg~sty zMo`|vDQ}WY(GHd|J*?8w7S`mo9{Z<<$@J!EneK^_>8|lIJ!zaw$A5!f5sBU(dp%<* zMqq%ETNQ}E=vaK?8I5luWc1b%>Aw54sUu`+Qi4p?;$&>kn9hi{QB7g) z(Ch&l%<)IJJygQh`;=Yz)<0a;gJ%SJg~;eazk1N)j%1uL($M3E5jRvuuQ%fE7bg38 z4wd~}hsb_O2g`nZSUjd@LT6OlxF&B68FlUPJI-kl=Xz_Rrs|KfPIOVfN!0IVT1k_) zmFR86gAWK-eo(&g#`kFl>%IQd_XV;~^#{+c{Xvhf>dO;DT}`B}CQw(A-nvp}M6;dx zw*kHHhB2;(%Bc0mxNi1My`560zUA3!v{SvGhDykKqfMLTH+iV>N0o{GHJWxj`g5QB zR9*TXGu|QNXe9Gu_jJ{#&h;G2iCO~uQz z>@+{rk2m8@amtiH`_1<2&wk_FK-vAn$2w)K2e=%}v+OcSO+7m3%E~i8@uZ^bs(KE(+%dh`l;5P%mBceF3M9uK|y)Y?M zCNTy~;&;X*_D^E}q#4mY<2%PT>AutFdCVOdUt<_2VrC36ZyXzp@0s7atTHwu2>)Be zn>+qj^|=gI?E?FDnRlCI2vojtAu=u_RK_KZka06c_k?$jY~qZRt!#^q36haoj6U~Q z<7Ar(4ZKC3>^rPqTfRcKdIe;r{ifmp_d1bH1WH z1LrC|Jc96W!beHuX74#HILabXTO$+A-#*K;G`SRf!Q4%;URI}7oP}1mIlJ{g=DX80 znMmAtj!_)w7)@_GVU#tLvW}pvw539$ti$ZHSgaDnyxEeixxFdld$a7OPyBsg?jNqb z1ZoH7aYMBsHP%x{lV?omiRv8J7TGk~9g%IEOZ4>o#12o*@(0K&hH)qG)V^LwjRiThX2wBc&PFkHb#eY?R~5M+rG`- zL_5f~=r&kLYt=29TnoOq+o7}Cw*N(ws4atYf0ge*UVgumq7S4k|Mpf*=GSV{g6)dc_9O7uMp@?ErpeL3+;481`%N1Z4^>_xeCTT+ ze)bOhcJmMS-`2;_Fvd{E(LiJ95Oo}(`p`{-zun&YlO_jj(xi?0H2-v)3-RS}^Yd_T(h_|D=SS_( zfN{(LQkxJW6G(f)=5amxZ=xpe?`Pe%eMZPWNz-K?jo)9pjAGb6%&}hk_6wMIykXx! zdo{;qKh|vs;D0^b925OnA4f+qCmuOCCmyNE$hp`%M7#E0zYJwQGJ^RC^O8k_e%3-P z>UVIWX>0UEb)Dl_{W^y_$0w^s$)BcQ*9?_0i~O!@4i#?NZI;>GHhHMyh6>-^yva=0 zWOcslVt(Xde&jOdM?FSa%s3{SHV(lNVcz-Fr92EqK)ZoJd}DE!8|oY#uggC6ZG~P;Cj2i zokRF+z)sVLqrBH`l<$gv7#y?Dc;E1cX{*U*`Hk)9$yVkxp%Sq^BweLZYouY;_0#Wq zJ9e;&&u=<&oP6OO&J$gltl%8H7S{WVH_i0uQM3cvhf1%*NU!s4uRReyjAODHZnA$`W;}n^`{Ag;>ni4cGabF3Gw$-6bEoS8 zLxt<<`CNzf-yZFh(ahoW>t&1dE2G)EFO|LYsptdLZ{!&2dUQaam8!`6?c^(UEyg%L z;58RjCgMaya-Yf=kJWuZvyYwoi6(b~Zv*tPK>hho-I~;a`}Z)u_9^FbFd;xc2$cTE zq}}(iCffp~ug>i=>;vP}QKY*792p?(0UwRF=+`DA#%MAEAFFXIPxC$xWR8PrQ!HM; z>ivQ_MFw*U#-p9CbC_+zWV4M7b8WO8ejk~3nE9COA0BR# zaBZ9nj>e?1hhfnNavwswNk;SpcMi_B8Na4si1C7=Hr^@Yx!yXS>&N4{PCS0A@q2%F z_b2pg#eUb8_t36D_W#>$_4oHQEB9IK>i)fZr+V_nb5FIYb1LVx(}QFbXz1|vpQ$Rc zU)V7B%LdYEJ1I!s1oG-&I{snad8R}4cdt$UZP6^lc#B?d+8(mk*MAJyE}GPZ0{-?S zj@Le)u|C``;f$~0%qhbcg?eq)e;W@m-yH57the2#HQKJvFGX+LO*UT6_1ZXmoPqvk z`f8Z5YTz8=-v`ZO2hLsG@9{l%`JdzT?cl+Ck^bBIoP=wajIoi7u>;SfsC*fpqYvWV zpoe>cF762?MaY!(1M>>~w{o&xL&jL5&V8nRdb(Wu%os_!Tq9j?+{g2?FM6_i?u6f( z#8LNP^xuTOY0j`DMjxi`KiN|b}}$`F>NsUpYii>ZN^OB zdiySY zM)woXA2BD2;(GQ@zvGQEM$h1$rE4SiEpOnyG58EZz-^y%hk0M!d{#ik_x&BK?C~Az^m|$(xu+E-;}#9{ zh-@{CdHdKfx~{@Xr``=i_^<$C2Lt`|*O+u=djaeOzzbCf$2|^|A)>419Q2lA)GrwMlk13r%atOsb^wm^iE^k zKsz07?AP1FFmtv&ZG(FI`47x9hN^p`ZS2W>e^25J_}y%CKi4>;#;LvM1N|JhC+CBI zSv>?A|5RQ3o||_!-VfE6%r;}PdA{A#zNM%89~j?v)3-ErPk^=?;(JY=-+4oZ4>zU{ zw@*Kp`^>5IX9L5y9~;WO*by?(dykNrFnRx@`*a@%I4}C={ZqI9QG13v?x)(Imo31( ztN&EEzx~6N^&j2mpT|$#{zvm2?zo?7!+)xN{(s5$r~30J#t(E&zVKk~`+>_F2JhJ# z^Q`nh@vl9|B2{4e9>(97v=c$@9>(8B+Fc-J597}zZW^%cVf?QWEF#2zE6_cNq0SEh z{p|C*RNwEjt+%&f=Ai!t*A0h#zF>Fu@9BB|zjO|*&$;GuZdLOZ#W92TGKYQFz>Gii zys1q;X9sLAKIi*?^?tqn{srg$f3@BJ*VF&6JP!qECquQLK=%^&hI!xd^7!3j4dfSd z{4hCCoPQ=vfA)6h=UjI89L#RV!QG6L`q-y_vzX;Gd8pr_+`k&;9&F%!#&Z?kYsWs< zW{qbj2Ckc$&pfF2l-KjjaF|8H7TJB?S2mvI@r|dREjDd7f7|-AK1TWE8=!1~=1pe@ z+vH+!>mJTi!a{5^9lXDX@pFm$JK*^Hp3UPP!ItO2lL6A#eV~5#Dqona&XcAu3?D@w z%sVu$X08)ICX=*>c6xuZ(|m4Ws4*{~AN{Vk>2ZAStDE@;@VU1=gbm)u(C<@(OW0Q9 zoxa`G>u_lY%5SJK^5+U4%HE;EP5b@X>@VhVfy!bYqvBjbJ?nn=c`w!6?_XzTxXJ(M zapOaHriEu)*84xj$31ra8NX#bTuVF&GPAShIj{PsQU9S`%v+A zGX{IF&F0C@Pu6?yc_y0AD-MouNR>1yOx^%H0#vh=mQ-x!IR1J z{7ZONDMNqfQom1Y#y8uSd7SBMy(|IVSq{_=%`{B*ODlRG^?qCg_Y%WpT;broL}iEh zUc5d=6>?tj^HsE--{AOSKKu1lwoRgPY;tsfaZ}qTSoU!(<~@Z)yr-~Gcu&wh@UE{) zkNY?~t$SdcOT517#aCb8tDXU0xs9ROdwvL!QH9>MMAUO+`(&H!7sw9(ex;XX z1bKVY(A&Q~NbE^m-_`G!&>#MhHtz3t)Boze7(O?id1&)KB@yDiKDnFrK5#xAs!f}D z>h=!tPN)71E6=X;%+lB-o^M@bJi|U*UpH+x+04h>{;6ypZ*YWO2lyX*%r#+DJr-PP zle(@v1`KM<*&jF3&IiRsT2NbD4U+jJB z!EDn*v=O6Tq7Mz@d8|n?B_oDsvLq&&u4db z`1{wi!({*cL;1l!p8vM#`-8#`SL75*2i(RuT$Sc zT6&upJb&r&1FQ?POP;Yj$6vVflf^3CL^Ivtp8xalxt^b1<^w46{**b+JKxXtmce{4 zaF_h`GRITq{U~$XK$(Y(zke{#IPWjxGvaAO`|(ajoT#TGmCXaknC&-!PXhT#Q_lo* zUvHp4n(bU~b3B8|dm)j$7c%f1ranIUJ)5b=4KR<{DXjqaq)c0fI^NI6{{9>G_wkVS zb4`b5DRx;)%|EX|nGL==W~j%W*Ra=7i;YTUO_&o6}8<+_n}X)%r)iw_P0=C;uk%>F)bO()vN zFXsIJiV(Xz2W|^sgIT6Pb$1?qs03FAI!={+8DqA7EzfW5r=jXI)FPpUwsgI}>+ctv zZ?ch&*{02FRsL+&Z-93ie~k^dg761+Jx4|;`N_iqp^bL*)w>a9Y6a%)2^3ixN%5tCjrh)${yAei}vjFPJfS{p5ET};5zi4#*1S8 z9NtlgVw`2&%}%w-$Y4Hx?OIRMFHHB{5buua zBaaMpvCp>ho%++$R{84fd+_>Zbi9*mEUcHn{CNWN=Lw&O>+g{;{n7uTC)o~HzxhWT z#_DeA-Z_zZ-9w){YFCN9)7oZfGUiLhyB|~ILnOZUGKuwE&RU6ANO(rMIFqiFo@251 zIJ-22dDkLW?@0NFY2)q8#dtq6^j(=Fd zd5nMm9$}LatQRnX>loe@z?c*BE~ND)Z+Vh+FW^7@IG^j2dOwfgw|KaW+Uh+r`k=6r zcKR){c-P+|nPz%sTQqs7zNd$?ZV_uFMKVU4YZqzydU^cTbVc)fFiQW;X+G1fvWV8N zw@nCmy{*Zx0ek09Vg0s=tY@g!H5)T;f$Q?-7^du2=bQhQZPSk3jrnT) z-IF-Ojgw|x!^JV{Rgc4X#(dux({^1;SRd0zabII3&%pD0k+E-5q0ck$!{wv5j{tM$ z;f^tF^Y05zO`K+(s{3Ta%p(t9$9xEE@gLh}3^BGv^6cfK{;Ruq8<)P$K{M;-a(;>7 zoegvCTyt*FQ*M_-uCz=G*D|d4PAO)!!b)Ih6GSGJbEFlC;4x zMZ4BActzPe-eenTdB>Z<=Qq4_WAF1mreC&RW0&-6?b74#7gYzUjjB2{>w4%pN0YLB z$hBnjac<}9Lf-oc{k~(1z8Zw`MVm3@8_3_ZW2kG1*9Xh>NhuPp{aS*19G$kNplt8T z5+YO8`i-6iQu?4>7CmH_{xO4Ny?>bgdz)uyHHTUgdbUhe>yvtZ%{eDodbZeQ|9k9` zMjKRrdb+MTdf3r~XPDvaQ}K2V!5+I%E{Twn*yHNb!pKdemsp$E%U(Po{?6Tl4 z&Ut1&W2`c!w?v#>7wF-KY_>~>xepsuT>mitG`#ny9%bBb2zZaG-n1z7$3uZ7wq^lfuhDBa9qo`F#7yZWtb+BL-5p}IXg z&tIeCLM4uM31d0us<)028|Gf06;UE3nwbR-{YTa6|UHTY3#BU?Bjp;t|yH}-$ z8S7|mHs)*ljW{WKaU?6q?|NQRV_B)UnTZyxN$^dKk%8LoKNB|8x!aguM630G0-P7k z>j+st*yRQ=s?qOvHs{6N9ozb&T}FsQ4h(SY?w`{PFy9E(Bvj2El&|K(!^|C~IvjEc zINCpN&RgEO0MABxc3ShO%{=G55y9HCqaCs`z_I!{Y_re(d}E{=I5$M9-)PLG7x~1= zHlEc`>pZHyzQ}h)AIdRGzt=XnCY`a${T{akt~L3udk~?{O-ZbUz&Z$KxiX_1k_#^N zFPEC*n0-&eeetik)nf+DqGBbUj-&lLvxAeZf^BhG}bJ?5BG<}|( z8m3(ydW1vH1vmQF0qru{@V(jhI)3Glpji%iBtTqmxy^Tte7=7%RQ(x#2sXz9+6M2R zs@0_i?$cf}&mmWXPV!T%*QGbTbWP2Z)Oz0m{1Ck_V|yO=8kh&O(hFBKZHd-&?_9IV zsMkG-qqo7))aeL*E9cq8@wWHif!~E@9qRjeChXC``&FoZj0GNUzRi7~XzU)#y{WO- z9^wwpcKX}R`l*wOd8Q_BB=M#bZ*stR1MO_uNSRg~#G3Y2#(^>F-izM~UWRR#_%PS} zy=z#GCU?RoI%T4V-vYc-JCXC{#2LmKGs42M*MbdFcN)A7b}`gdCBtOMm$_73A?y^qW#PJ|{A%Y2SgW4PMZ?eKZN z&0GtaHE@0M_x{EhJ$znzd}WVM+4L}d?HuD~qzc&kx7P!EJ+RjUdp+#AjwvF-nqk62D+Z==EcmFj09ovb&@Y-3KIB4%YGB)eRtUuG1 z&wb`2Dy-co=ToP6kN;=+BIB>aNVnBU_ouRH?@;VpKL-;@;Rm1g?R%US>$~;yX$$F^ ze*XDVWu8d7-Z|;dnd<*WTH0>@EPj7M#^2B79n}WapV=_}7475avi1Lmbn0*1d3-&1 z_MDTK<+zsSHmrt`mtwSHX3lonsr}&p|gjl&cZ@f-ZCdoD8<3 zQ{hvAi({?liyQ@N(P?lg=s{P)w}2h!I=CG;?{`Wk{3QrS_rqBwJS#^W4_pKK(DiUL z5aP7LV=ti0gvY~ogBElL?7mQ>1YHF;f_iid{26FM_rphA#A9pdJoqAzk1m5h1@WXG zT1wg=3Y~T_&qRVmbPfFJB_gTlluJb}1T)c9@CP6n9aSb$1hUW-a0|#scfgUCVH>&( zeh6$px56KS3Uuw|BHw|H==3Y7w{pslZoiUms9#O_(Ww=b5pNnIEdM3OQxX^X*==GEfod90}%FxyDW{{6=fS(2)bQ}COC_(RlKL;7;Uic5c z#h>U-xCeBiWrIlh_1J{2HVk zIPle=1ib-%2;`$%;P*imx(7b$25dv8!>d3%+6^DFk#>U4hHnQc=qA|lCwzpCf{z5T z=oI)WP=;=VzW^2J*iBqN0I`qJe&AM+irx+{{4?#X*(v#O9f&8q5k9z@`Xam>{t)yM zZoN@t1&AcP6n-1D6W$M>aTD!?@M3ry=pwuq{@u;^5#0ozR6~D3m%tIXh{O?p7W@=Q zC%hXz_b-$e-40)RE53RV|HH2V7rGywSc~7#aqumm6disWV-BcAcfxspr8?0~e-n8R z%z6m>>qMr56m$Z76G%g6+>YNsHo6Ml2Hfaw`0zVOADs%H4cbVv1il4ypzGmRK_|Kk z4!e`F2pt8_0X^tE_&wkx9cMlHfFyJ=+y(lGBX^1X7DN%=0EcZBNkGTJC7=r32~W72 zc0&AFa5?CH)F~U`>mFshiE-vhd;`jf-vt-7P)83_E;#LJY#@Fk>}Vz5N1T!ce+9aT z6Z5RdOQ0ETeNN=KHpVRCY=^hLz_>^H;ajP@4v|d4H@u43+enl8>VqR*!{?+Q1*dPv zKg6$wo8P5e#1G#gax6$kXTqyKpj{EC9{zndb%)LAAEQ5^%-E3ismNMTL7F8>e@36; z*j{+V=d>kd4?Oz|#zb@le9f2CwaV)&>IxKdtb9$o?Zbzp*#!4~k57n`@*|%M0vm}_ z1wR7Zl%*9`UsPCD7}Cm@-+NU-o-Vh}@|_#nQM%(Hpn#7P;Y z$uD`Kxffjw{|;mmXCr(s$U`^69`*hU_QXYM(lb_*8nkO1$3|&Vj;@EF1a9KD!he~d zNgO(6q9*B}o3dxa(XpB&l2__fzDGNaedu=h)ajb!qf6j>K|05F!E56*X~h1}eaH(G zQ{EK#I#7k)0e`u#Chf#`??<^nE9vyY$?=+WQC}Hw!2#HV4Sn#H2T>Mu;=!6+c$g-s z=yskHpLGN_psV1QK_+QN{(|pCAE`+#;f=rIyKG0{E5cpyFMmzB$jc4C3t9=c&er5y z;39kj{9>{uThMWHs29*koMgqI8ND5TcOL#k=cQo7(WHsZDaT+7$fJzK@I#;!-490` zNBt5%Ax)FTpoZ}?3%>SvzB7m34*zd-J`QsXtH!AZ4X@yKb%LKL+72P$xR>;d+On!d`)Jequ>KTI64uY3u4i! za5jiS=fR~Q9$f`bUQJoh$?%ULTj@3Q2@v%p{Rn=^L%GnU=V)>(NJ7`cuYxpmFMPLStv8_}Vq)GtVD zrC(f3y9MRwm`kYB%jr|-_;O9AUqe~Yu4^^9pb|f$t-s-$=)a}?pzAki^6~G`|AZar4*0N5)HQL^;3vQi?60Wi+v7k8mm6u%V8>JHT(8Oa zoA4Fk&G7h}HK`ze0(=bUL1)7kf--a~JhFyoLx~>?F9SWKvjM*FFOO!ekWM#zWCJ#%%i)v%jz5W00nfT0f1;b>u1 ztU<>;$v1IZ7!%M@PigYX)7bMI{pcA@K5W$_1-3)l%4PdcqJ%D7sC&LN^}=I<1PGv zPKAFDiqVbm_dwdHm$x-p0>aTAxDM<cbn*0f5qU+)FyELgrZ->7J*=Xmx zv_}w+j)Ok{#psy#G+7AT=sfs-kce)B<$dZ49SWZhW}AXZcgr5Lq zgm=NQpW+8}B76!+C5{WeO6eCFui*PZHo6)95agkI;R!vAQ|M&)T9AaU_>3_eWRhk- zJpOZRBRm%V6-Y;?z)L|nIuEV~*~E|hg7Y1yBD@9u1SFuP7Y1?YGWfsbe)9UaOVQ5#u5qZggbIhy2>6Et%eszpR;?bFr z7Wp%XMc2c>WF4g)*qH^NFpj(luYf1=oz6bOli}My1G*VLAj%?b=rZ_D;GsQq!~5}V z+o+crL*OEiiY|ly3fhUY1%3zgp?fCqj{8K5G^3;7mKclFqBACu-eikxN4LQ5fL3%Q z-~C+z%FtDCCn!OO##-bMP(@zJa5|_)XTg5}wdi`d2h^iwszpu%+tGEfeHwYAW8hOk z1G+{rC`UKJZJ-j}4hQpn++uVT91lv-Dewvq{t9zHcq4G4YvHY+i#Yx88FBcW@M8EC z5QUE1$0BEfcytGA^N&4<@_xd&0q1~?Xg7R22t_x--++9ylkW=52eZ%_@NdBOkEwUK z1$4fN&2T^Hc#Zgn@GSz6`VQv;*aa%zAbq$Bl)pvU;a1>!9eZGVqDA69z)pBB2t}vE zT_FEe{C_C^1|D<^oHc`bL6^Z%hf!bXWVjtP@eKMItk7p^{<^grXA2)~$$4?m~8$I$+dMH8L{=N^asgxA7% zrSW|R!d=HxcMC1jO?Vx=`2;lKy>Ndz{vka1MEt!7I|=WGzgWyZ!jm#A@~e~3gqOgV zos8cIZ-HM}f`14v%e2T9r%)f%X$$M)>Aj>Wla(E3kQ`MG}Z#0axasiPH{m zTgBLdjycmJ)6TNU29-YiR6gynoAg(c{ugh!r79i4BHB*L@c zeWAPIFDfjuh4>q;A>V6B zhq~JizjGaRgpRAU$U(ospJ+F{Zar-P-Sj()xU1-Q92@fo@~viU@4-Jc`vWd*GLDCl0oy-(ivS>M09lx87xu4>t2&9`RjwGtS?GPe`W~?!V6> z*@Txjkk|dhQR%?1H4=w(G9P4Yc$jv8uOgfH9{MAsPnsoZRQ5cNJ#Dl@WzP%P^CCV`_Q3rw;Rj{U%h=OF9F-3I+BV`S zdtSqy*YTUO=MC(6lk}B6o!Ij>b)@Wp?e8+~kxnJN_I=ukN(X-F1L7!qKE$4G`iZjV zW9<2a{)={fianpv-<3UZ{}=RkWlt~md_^3>d*Ijlh@0z9VfoFqi#`aYBEKvMDb6WU%u!VH0;m3f7b3rToDTvw5 zI1EpmA0!*PXrJ)WAe(g3;UbX9IidvqGpNOeTKE~z`6=TA{58lUFIf;I(?K5TB)}(t zdd^3g@cAH$e9PclK@#@Y!!LsEwDaxokDwQyIFAmJ13?w#N`jYw)J}W_UkWncV~m3D z1ijeS0KW#hu%Qcfqy|YN+UgN&1R^0b5G1XXy#}7)#z&Mr6MhdQyv=xic98rLWa9HCcwu3XSgC6d zY$+mr>N+027c@~9+u=3mQeW7U!F!VHN`fREd&({dlJJYMlRE8%%PynuF#pNBoVI)w ze#V~StMU1@?8Bbz*9FPL>uIalQ~X=n$nS|y+1szDPyG?wuqXKj+WaQ`tJ*Mp!c9Ta zjZYG94w5f!36dJ@vECjeC*486z@9odzCK9uv8Nn<^)A{i_9SkmZQqUGNv927a1Zul zPYwL(z4#M*QtqP-fM)DzfM+()@9ig}PW`4F~| zR|S0g!?a=Y>Vu;n36cu(a>189O1+R*8=UYM^+H}La5ab{uLd}>8Gn+O`*GUp6XZ=^ zWpMVBq(fd+u%`uIkyjmj#Z$CH@@j%_c$%`1S37*?GxRU=s(Lm^-Uf{voAF$bYyz#s ziF}^E2GYoPJG@^THc{7Zxc3G8M!uO_;TQ1<$0oPKFJUL`E&gT7@k$W)I_L`>`2JPe z6>0XtC9l!P$+r`}>UDfV8GGSPZ_;PU%h?$uo8Jl&H)V`@o3ZyD{7idG>cR!U>xWsP3)=qI7r_54EwRC_j7Fi8k?~vsV|5dok5%*2!~%5t8B-f zHq9y9S2+GqC>1= zrEPa4q7Nkx+Hmp=tNa}#GG2ASYYxL!j@Qk9&m#V>t>VHz-S81}NFV>Sz$qzKNl@c3eDKlONx7Qf*ki4d zk39|WvB%>>?CF8i)2-5jJv-pk#iWBhop9mFR%yhZs3rLC6su%nkNZ@s9Cn&jLb1mM zug=2f_^KW*I^8N6*i!?qJi{s#*i!}HxD@{=d*EBM@elTNz<+L21 z9dPOS*oi&0a8`*`>anK+j=R7rE%+x5?gAd{3B8bZ3o5av2QI$|o3JOm)GC*OOwy@= zqc7%I(wPb04z`m{D?H~Cj#1@;UjntH(+jV<6dOnJ;>TQOm8&kN z{gD0+_~ddcHr=*_-J8G;_O8iv#fLq8LdtC5>zhE2ol)|oCv4Qy2a9J%rBz_xw=56GQ&lBp% z7nG`V8N3bbP<{4xtGos32=9Rt@4(OaFd25;NgKfCdbquw{zCe(cM-OkKF+a~@T$8R zCuz^s@VYJZ8S<@%ue=A1&zs=hduj8OG37qSlLo8w(+*n{|DEv{U!~n|mBkN`4t2T# zzM&ES(+;=8?>vaj_@wM1tL*nM?OD|+{3R$R{n#d}d<4p|KlTyQ1U;(nKWdeZ$7m*a# zy7?{U{J|<00xRikgwuY+PINJRfY@XMIunl6Y*LF(fqwvr=md*Rwu2P3Gsq^7f=qM| ze3R8C`RF#d!e*0FbR(Q^w@D+q3Ql#{qz&zX_jTH&3+;wK2Fds;gYQlK7NmSlJBQx_ z?dTr(aK2sTL8rpEf*N!a{2tiBu|4oO)(34u$HEIh4>}z_2ehEWS(ofU5U$dJOF<{$ zp=FxuA^jV)(dmHpxJj!qdjvBoCbiM@HGijZTH_ z(fArY6FwWHsQBp?NP4i1YUO%)D%Kn=PA zet(ip63}^*ZE^{SLzlzT`6fXNIt`u}Ym;kmfh|8P3=jf1)?Qzu1rViOz;X^@{euQ3ufW(Dm@wpaJbXknfp*CUg><0jkkia0w_!m%$H%dUP8+BEcqA z=ot89P>XiKn?NPH4xV}tzCx$L<)97S0?#>wyuNixHGJTq^b2%7{MljD0lF-S`khHS z==@*WyKAlTC=(-fXT{Isbl9wA^51jq< zefS}eMw%_~haeK&3m>`wzo<0f3&2KnBm5RFbD%;?N$5MCXRSvH>j=q3yfVY8gZ0>^lKnL*?)2J^H zPn`JUDKDr)$1SwU6JQqU%L()aU`20-!_vtQ9RnW^63}(<<0sN?Nk4s&O)dhd%0F-` zNJe+SpMsg_nTu(k8TbcX0~hj5CfE0zBjAxs$QPXs_he!ly8aZK9CRx6OZ+Uj7qp;b zPP0kS>GWCRl)xV?rH`P?v&l1uG7_g)F(^Y@moct@5_B?r9@u~`hi?ZJ=mvOgF7<_u zTVa#Gfjo38JbNX5ne?mjZ1O$WfUY>pCcn(5PSN@BHNg4<<$@mvq3AaFEznP#_|-N! zVh#4AOW>#i+88<+t}3Mc5Z_&7lNZln+(Xx$Ym?s;lNY)beqbGSgzkeUorllS@$m7$ zjn0H$1)1o6_?q(>m(Y+m2LMN2l4mHM_fz4Lr21gfKc>IcqQoNSPy(N z=ttMXZ-Z`h4?N{M+6g)tzVUaoXLS1YHaQEVkxnUm1IR$vz;{&9w$VNCv`w5Z(Di>N z|7yyDo(WI589$)iH8!~#Y)99@Z-8!e54`#oe2cDtpRT3-plffl$zz}k-3qt=6(6Fb z{$`UcpbWho4y~gsDjYrC*zW7o4 zwbHQTF~&4>6MV$uv^jJ${4J# zjqZlap2nXl9NzjYZ2(>I9CMiG@fErrUe`vN=sI}R3-|;b5C0i7p&Q|ow$k>eu?wL%glSM!Lkwl4!F^guQ0y?HRxnGtONfj4ZjSM(Fw0&!)w$Z+PR&+^*a3* z-2kt60~^rIaKW3{fZhmC?4(a&&n)=FCgRZL$=kqPM`> zd*q95`H=DdBkI~7EV12`syN?Z8*rm5;P*i(TD~O=RH|_JQ&59;erIED&-oo)2UqpuXLLJ! z==by&bSiuo=tj4~NB@8yC`%sv4v0cqf8^W>64BZ4pTJCX9n36JlF>169&n>e;157C z+N#-Q1}H}-!)rj5iUYrF;TtFDgdo;S2G!{8@QO|(v9weXY$RH*bwRnUIS_fFNUi@9l8!~2OH5F`DVhg*Bf1*Sn_`y=6$kDBHRwKg|5(a`o(Zo8jp!2icCZEA z2!95e(UH^m2G2g&If8oGm;L*(-YU8merbQ!Mkh}C0e0EvK>SR27JOHNUGmY+gY0tZ z!T1hc51(|1U3L(^6s`xIDld3zqFoY*6MLv#Y)N)$CAU$rZ3u%`e ztM~`dkG7`Um;{HPOIQ*;sS2b}`H4Jy&$i)kAtlPOM?XRr!}C_*XQkm2&t%L(m&2ce6twd!yPORw&=v3(AP*gy zZ89$g7P0us<|@Mj_-x=tm%`tIVsz9xYy;Kk7WflTrNYmn|AI<%9emXJj1OoR z+y)}~)<8FWPAU10X57A*y10Zm=nVKvFbf@fsa>X(;b*i9zTh(2B)S<+x&mLJYv5Vs zq^r`0ue_3S5#A1WRRF>puCdFiYpHkgt%Y}h40Ip7oM_0f{R?^4OdGLq7v5O0x zw%#t6-AvuFet+k!todAvZwXI;PX{%G=fkC-4qXX947L-;cb$Lr4S<91z;DD+ybe^N z+wP{eZNEC`<(*yy@HqTrVa5O1I2HEP>xmn9f(Eyeuu&LI}7T23+sWKV-+`o zaj#yf$$xLO!(VvjG1WHYqZbT@eexw4ZB?Ord^uQ z9q`sp{D2OBi+Tic=-9XI@-CQ(j(Ugr3`j%I?6S+NpagAw*DfpHqpzZy;7i}9-Hd1M z3K#F-9Ez@kZ~B0GM|Z;8KIB+*{6}`V5hS6T;7hylKY9yX{4xGl8t(Xn@jr@w_bFkY zQC`BU;rXBAJG2|#_Y3L(odJIWYSEFsgnz9mIAc1t!zQPY66rP+!r^Nq)4;3UNpVx*o3698!tyhJR;a8{Gu24su8z z$5z4ZAe`_nxWwv^TEgq#6q`fZ&>ncC-64(WS@6rC3vFfX`4q67V>96MKs&k_{t+~z z!<`N}4z!|O@XNstDVq>1Ng)my5$ceQXbE%3i=!Nphb|9iZD-b|&qmLJPhySwQ1nLl zy>SjnMfZ(&$l0v%-h-}$lcKQ!oelSa7If?chctjK=uUXvM2Eyqqz%I*ARb)?w}C`- z7n~I1keTS@Ne=mFnnRM&67P_wK|b2bchuhl>FA9K4tePyhh(BV4|d4k6CF~HPCV2h zF8~j^A6_{Ff1=Ca5r<(DIstweIAfUGv-b5oAm}vs3eZEGD)>XthL*z}5(E0saq!!q z10Bg4>sJF0$JWBnfqZn{FR&A2p`9}wQVpWeE%24Uq-~%Z6(8x41at{}%&#afdLw)v z*nw_>$FVkh4LT2AbQJcWtKhpq4?1f${sDdHzGTvyLs=#<4#Vf9P)2n8e1}{ElF_yB zvIW#5x)Q$cXor-d`Eexbu?g*j%Rno-27U}Ur(h@iIuLX=Ym(m% z!qLv9_yi=Qli|}rI@$$43{ufO@W^c1AvzAe4P>EPVadT?=y3RLP>GIO#(cYKR>z*9jhdOvs$ zsNg#D(Qr1fqSd$NF9PvghrA5l1S+{+S_8ieGSKRq@+0rZ2I8o1fFA^!xDKYir+Yjo z<+_3Tw(Tk){FYbWtt|tIX!YIJo53u8N2_nYJ_@X8^$pn%Kr3<7cWFZ&ARV;&e(Hgs zi#Y1Ls0%?9zdhAAPu(CDt-dXJE$HUAoB9Ui9l*tJEA?Hr=RgZ{OZDBfk3bT0PW7#@ zV7?)d#{5TpH)da@ImfB*z{~~ZX!Tu|9AM=fq`tFqAxK86Zao8yP>< zH!!w=7PR_4Md*XHImRgUt%G@>k8wkNx4^B!=~H|E_IhBi2ljekuLt&eV6O-EdSI^y z{WU$NNVuPcM`q^M?R~vkmgl_XiZpm%gO4;g-QX;P^9=SFTyAic!GAS)i@{9>w;KGm!F>jgHvF4l@B)KR zHrQqGIR=*-TxIYb1~(hrX7C#Z|6lLDB~N+lugYluml(Xp;7o%T7<{n76ATuEKQz+W zX7JMn-*50=4c=t%wFbKl{&)MixW!v;mG2#tq53hdA2kn#{h<19)8MwheS60>uW$B_ zYhFL>9oPJO$bWYGe|22rE?Ryui)63zaC=?XYjV$BdhV(Ko5dQ2JXJ!-8P>M1ad3DWnta*I5L1?!A7BE7NKtX#TcRetVLB74)0_NMJA zT*WSxxs3OQklTuaHJ+tK%X9K`)k>PmhUNLWIfZ66!aF*InfaKWuA8g~3JO=}tXZBruVC#OPi~ z4)F=i$ScgvaS9CQpdv??cm)p@y#(^eIEQaMCE zurBiC&&zRp))tZ<*%f=_GZmIbU9EL5Si5GqT2X)g8c*RmR#a7cPF_{$S(}r8(i&AR zk?VtwDN4y*wsz&p+`{z2+#*$R9k!F!$KQn~U;eh$@U+Z(E$}8FKdyRVvnT zCkyv6EW5r$Hj%zj>Vm=rxvcPBm}}-!p<*9j;98rXo2qBGgjHSVFIqT1?XVfTQ{`)A zvDei3#c~Bczz9Aoa8|A>eQi;mUM}4ma+&YG1^MjshI>>VX*orn`GtiA*uO;C@3TEe zBaz&~d4)Ka7O^;2cbLe_L20=;=j84ZK2b}_&Cm7hvf~1u`tdtx&KlQZ_o_8|dyp1e zMt;#8^=SkaFH{=yPR_|+n=8+#EsXPSJ*Bo56z1m2gPNkWRm%!eOe0UUPTFzqs=>@Cw7I?mOQO>HO+=04e?PcZH^yL`^s(q=JMAd#Z z=xh1VTaPYpwUDBH2@c9tv88;l*3`E8vH*D=ph9J=n7q2qgyxeQc$SqvGYE6!Z z2B3EX)}9_r%bS&M{|-&1Rj`_FM7h@F&SAZ-okNz$!9MwU`wuHKTTfW)p|9)hd9mL0 zv21w|1$28|zEan^TjdIE0X<+|enC;LT%+p+tM~w&DwA%-COvE+T}lNlks4Yub+gJf zPq|i&U(L#@IrGw4`&wCZ!u;cveo?nIT{VB6Pd$EZzGv0kb)MXef+ee5x%2qIg6wZM zWk$ikemPF1F@McDs|pL&tfm`!3s6J}8ub8f_a8Za_-&u0bh&z;o#XrO-@E;v^}r&&bFmPd295z`;QzIE{-Bc^ zR~%Q0fJ&v4J2eh!0)h}wsUsK!X+%PDautOX7KEH-JBGCz3j$}QNKj+nf}0u5NE(g) zx(KK{RYr|LjbR~;NTpJx8smI-?{|c_x}-S>yYN9PSUqXJZ@zDu*{45&$KWj>!81U> zUqB2Z@GI~L{Npq9&j(+FufTKgcTfWgo`Eku$GZT)U%^xG3HT8F0sIa;27i8rKL6lD z@C3XA0`NBYCHMt+mCxUvpzra!=)a8Pci>}u|1I#qg7ZJ(_%rZhFyQ>>IBH@I&y=56~AGd<~w1F98Fe zflt9l;QqNQ@Y)qvu6wTVZY1h(FAs{Sh>NtCs-;?`=%;?^*M7(QN|Y6Qp{@^0G-42o zIK(3XiAYRRLdZZSvXGVRM4=irs6`#>(SSxYrYR+Kpc7r_N_VPcT4rQc=44(LWKkAp zX-2Xko3bTavprLo#tddLhj}bu5sO*M2pibM7PhjTDO}?Qx46SS9`K0AJmrKBeBujV z`OcMG%Z=R1o!rZVJj&xd%}GAwQ@-SDzUNAz6-HqdPT>{7!)Qq{6jOn*?byeLgOQtv zVBcc+h!Wo7B#3mr#TpT9zQx-R@wmm*5!FQ8xJ*k@4&_o_%C*#Mqc&@=_UoXwI=2hE ztD47EPX+(4zm@=^LQx%>no!k-t}c}Ip>0T(n_>qvQ=ys;-OS8}axS#e7&=w4^N^=}J%fGLWH+Cikds{GDtD>W8Z@?Q2Py}3RL6B%lX|G9da2iXua!n?jK*r5#%qEmYT_ns zNHa83vove7H%hCuMr*ZB>$O4abwL+(ahG Date: Fri, 8 Dec 2023 23:34:19 +0100 Subject: [PATCH 10/14] removing exe file --- .gitignore | 1 + test/Test.exe | Bin 632320 -> 0 bytes 2 files changed, 1 insertion(+) delete mode 100644 test/Test.exe diff --git a/.gitignore b/.gitignore index 7bf0577..2911f85 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,7 @@ *.tmp *.ilk *.pdb +*.exe .vs/ .xmake/ .cache/ diff --git a/test/Test.exe b/test/Test.exe deleted file mode 100644 index 9fea3c520bc088503ac2d8ddb67b3fd027b9abef..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 632320 zcmeFa34Dy#_Xj*#MkXO9mJn10K`NFIG{lmLOg$kX_MH&>P9~Px5|fbem{uvJRaLE8 zs$3eI^@z{r&pi-p~7aqo1C+_nvdlJ@?#m&pr1% z&rD+aE!MbcG#YpO?{H`|yYb0?;R5~};G)r#t+BVPW~b+gn!8=1Pt@!&YIK7Cq$v|e zP8l-ZKYqxB2@_5JLx=lMNu1z6dV+ssm+t=KCk`9l$lKd1z{z@TLaUJL<$J{C|KB{W z_mHcoH;?N&WTNIqL z!-klKXf$v1h8D6x+XtWf@mb_wILxP!N~TF}0z|N%tccXpR-;-7aSZvVx&fs2(dIdz;pQ)KTkKfTcn|fL8JMA z_*~$rnsg4BAvhx6S83 zx1%DeKfHx*d#?J%gVnMj0K-xM?rsO-=PBTl zL2T?4h_-{H)f&dW%h301EZS=8!SrS@sxiHQ2<``vN8*ds04~o2gV;`B@LmEC`_oW; z_zS8#%Yjuw2b5|pLR;5&feoz(F6}O(TV1k0(Gpl633N4<0Zf?)I`6S4NymW*`jg|% zN81UqdORCF9IH@mK~@iwPzsO%E=>cdn*cClCg=hVqTAKUAZfc8)t(X1ecVsLcDf71 zl3#(i{5ufizQPzY-v*+^5(w0@FUM#L@M?Pu)VVF%KHCVAAIGCq<4u%0_6DoIQ&IIF z11^s^t(#j=YIqNAlbWF0(v>I;<)m#MV3j)q*bhpf?erW}ANm4J=i<#xLaBT$ls@YP z?5c9$oNx^c2DzYb%*&9}v>esiyHMR!7R1eU0BdMw@iN*zZ-;JuDaNF5(9PY5YW*mb zJO@Lnlu-azX_!-j(8HU`ZZ;gC+5{l#H%8kLin}2f-OP0{c*m+>^>8Q z+krJ!0XCSUb(({=s<%#ncw`vB&ofY6_Z>>VvhSM~kc_y6>3h}zA}|I6 zIX(h*&d;cBlmW+Z_+OrsKYje=;2?h9zGqP~LnkZEBj40LplH>LTgA}g0 z91VUqj{uDC0mK73fUC>FWde=nYa^<;rNKFK659Tnj%vnBVC8oWZG+zcgSC}WjUqoE zoFTS}1JE|%3Wx_T#c0wMv{gtz+nkN)`wEU>n>(j)Y!IrijRW1EbRNH60ciIL5Jzi( zUraYtH~fJyK3a>m&pEe0*P|_$PG-kj;5_9O4Ee+t#Ea-bUVRB*%t2t^It-=<)}cqW zt>`oz3sA8#=sHaU$poCrwv5kF{k0hwglSP76M^c5Lny8I7~mLpN~0|( zwQK`K&QX-~Apmbo1;5L0qpfucB*J4uRF{kauzm^l(__HpQ6%VU?E$FL0ad^0;8J@U zfETyv_v{fk2c>gOFvhM;ptH?JRiOjz;sef2FQMf9G3Y+#8l8KGbU&i4=NgoHP?HlY zpvMxr*V)0K+sR#f=@zQ4w4BRtlV2r({si+|V~lmbp%gv~GPi$<9w(clRHZ3;Bn<}G zLT@&dCa}!{2^LYOcRBs0bSNh}qx#Yoj2qS#tUBHX;@an^Zm0o-jKIX!i*q~3(b77A zLGN`y^y6tYy90=0Zvou3pl!@m@cTXtTq@E@FZDx@rVD|%9Skro0@cc0fpuL3>`w~; zlIZ5v_XFaGQ{Z=kr}O4bsBWRR9Xc9dcqZC%4uh^kFZAu!6cW5eez|n(XJXOzc{kAY zq|4aMz3Oojh(WbcZI}zu{I~-?_z{SO^MHt==WnKR=@TI8{)D#AXbg`v0FE8tQtAs3w|NU=Yz;y+p)=@C4g=PE3HqM@3~hSu z>7UzyT z?P>gfQDN(N7=9(8G!ap=?LM8`I<8yNcz|!v)s0w9?Tn#X{H;7wtGa0$kTYCfByC=Xx8>-hD0qjo4xaW-Mdx)HG??78c zx~d?$`YByd^`#E7&SRj%3_m)udX3tR{sweo`=MJUE`^1ot>IML&0rh(JtX2mCzRYM z+LhhF{@QF$Zcq$2PPrZG-BBksz@;(B@wUs!O0h?ffIEs!u>>MRCIHM{`cHG-}Q?R4jElQYuRON@Jk?1a)+%2GcOlyo=JVaUl7OtOk??gKCulp2h>Z41^+rIf`VrN7w1`IE16*SO^q@JwJKex)r~xuR zoQr|BdSTp;D8X7r@Rv`cZQO9s)q4!^Gq=HvY9R5ihw6F_N@FOCCr_)^WcoW}Ti1i2 z8%Qs@>OEj<(^1SjiMA$mJV}dz82LWhBIZG=a+A?*RW!iT_koQV1FR(#65Qh<{L2;q z*DNso-hsBQ^i4B60*vv%;Cn`b!9Du+{+&Q~p95712DbGkaLL1k(AKXbIFI)R@aqNQ zu@twe72q~K|8bhY(rQ3NaK3diP};c_r5hA?f-A5`=A$k5DwwwCXc1KGpS=N^akUoY zq4bmy-l;@X?*&1sa}<06jsI)9-03O6cKH>u+#HCiVJAvi8vx`s==-@I#0?qOrSa}! z_5|_v*5J}y_?%KG9pfeLW*X=Y5)7c=ml((`Uj^c*`5faQK>xu&ETO&hiwS%X2_?A{8W| zG|Z8uQECwb#O>zjd#fCV+(H|_!db2(s8}C#y&2ssVbnbQ6%fy2(6M7V5I4U;^#r{@ z+IwgV`V)Pd{tASx9EJ?2jUMN?^FIFurQ1m;wQhwT-_m@3;Q7&<%VP=w;+@SPxqk`O zgF{g*!&qv^a&UQ_?7b(Ts!0a6gAYn`reUCUwa{bp40?LG!LMVt+&B>L zAgfxZKw|R-zcO_29$#Wc{qAzyG8p&ca~#7P-6k{!@gCkp4x9qrJ3L`O`3!w0^A^46 zH4x9`)_9pq_67ICPU^s(h;A*i0VWRsb^t>cM^lho-;C1Ny)atqKfr3RA4-*OfUavQ zuv;11CXlXQ2I#6E1vZP9DL3x7F&v}%B@l;mj5k-Jt=|KXT&s_9R}4hou?awQ=BC^8 zJ4y#=)Rij$TZsp~k&ZFvW6-%VYAL$_eG_@d*-fxM2PAb@1MwMeMXfskRO5`Aav2RX zK=Ku@GFzD1_B{l-KPc>8>+zSz0&^8cYsUT6tq3$CHTkIsP=CN?2-Uh2-SD1K?2`7sD^Wb9Ui0a6;8p1RKIOl1CWHc z0eh03wQm+mqj;*l(*#`F4noOB;;)#{$ZQ2xpL>8y%>(G0au%iaF6hxQ6(t)DGu8&; zgo+^krU8iWWPvW2fl}{{09B*W=E6%z_&pE@aq*Tv1tNJLs=M>h*Krx8>+=9EOaa}G z9DGM3RNHbrw3#6Gn}BW|XhUOOM`;-kAn7Y`mbK_HbUlch|H(FPdp&oaR~sOj4+e40 zTR?1i0&s{2?q{!pc*Ps2dQh=*%&6Ak0t7STb!GuTzq_bzWX9pgju>NRS&#^RwkTA` z@h;xJBHI3<+w99Y`)q%dI@JPpK5qoWYog>wJ21C`UVdYk+@u)<8pkWV-V8)rW)dD& zM_VL4!x?IFLL{nPy8s(KA6Pp#VttxG6?(m94*~Q{4Xx(=_Z5mZ>H+A?3^hh@GCg&W zdGlhF4%frD9k~FBl>s!I$^@PL%Gi2g%B0Fx|jZ-KE#S`RQn2 zmvND^$-W(}>63dv96XJ-TRes4K0sU3TvTHopgJl9)h|Cswety7znBdMFHJ!;^F4s; zLs5O}DcJv5lXO+U>gG|DER0{I7>u!n=l&*M`iE>o4|krSTbQNm$Jio+8Ii0tsOFh~ z?MKz6u0yvtF3%P^#wEN;C*K2!KWEvSvDE6LD1Gq+h#wh^G-kJ5jAY*Dr28;P=$-}9 zdeH=~jR#36o#3}L$1AOXs7`ks&Af#?6C~vu1Ch!p%qmAZBe1o2Q_mpDPDW6VcrWX< z9Hl>#G43!1vz2!MJBOeS55tdnM6c%=I)XM--5;g2Z~%{%K)5bNY5YJCKfVa;qffx< ze^9^`AH}ljpSDe-9Bv$u$I=@bqmBe&Rnhsh5YR- z=(Kc}N+7EJ9{~*Ft;oom<}6ONb}iUY3tkmGvr&y^EI)Gqq;jR}(^B_YJuuMH?f_R9 zI2`-}bbb|3`rstmK4H)?keS6`8q!QAL*CV*G`TZMXSqg=Uk31E*f@k%H{c!irPI1e zN6|bQK*K0#WL02ae-GWNbMZDeLEBQ^buV^9X$beA`%{pdc^|Bra-cTff%Ahu(3aqa z(yk9cl5qpr&BFjZ{6R9bDiB9_3I!iQ_3)qIH-=36a;xdI0N?roySyRVhQ9{TnoH5{ zF~A63k_=R=UnItOhZgn?BdF%90B+4k)lO@l+5*+D>4MJAg#=62p){2Kui;7{0)|6^ z_P+y635J?3^V0g`E)3+xQloD`cY&^I)(rHmMrCi}o#Zpdv01!+>4$^(haWJ|Ixn=1 zV_V~~==(G6xjGNmXoeMI$!h9fkg6dw<++?-|Jvv~Z#kGwW@cwrPgHBz0Z!6l*Bu8* z%5UI2jajfUQDAlCU9bvf^qR@5;Awi0hGzl787rH6q4Y-!5I66FZWWoT3$mcvnHQ(G z7=}b@<9N9C{~4w02DDjMq4X;~%`c@f z+994>mpg(%F!TKFnTpu70a#-%bW5XXatJ1Ks1K^Ai~s{#13Q?mWf1ND{Tg84^Af<9 zerVf8&UYGt-(nsUK~%(*PH6L{FG=@BsRl_degzOS6C@u~`YqIWRbF$q(HC!~qd4ON z#MC=rdYOlk#sq}pKKq6N5yiHY%D{#kLuvnHVE-hxBH3p$68xDdpNI4+Yd!=R%UJ%6 z-ayP|G#5+u3%DM8sq74PTfrr(M(x((Xm@CT?o1`V_clNy9?aJ6z>cbdZa1Ey^g~^= zeMaNjOskv8362RzbuvwPE6;%Mc+jurxaD{*#C8EIc_~VBq5v*)q2l%dJ9aKWi`xLh zY3M&X06NS9XvBQeXIDV{U?EDE_}rxC%HlL5LnrlK_CJ(POf<2-nVJ`F|NPd|gM4}I8GhPC&3 zIZI}u(ftFIJ}M2)*SU-tuK@d10KhR`GT-Ik)-WJuG2(7N0&Nkmq3!Dguy4=@bdTt5 z>n;b$WZnp($!c&lU{6;E=-Uh=*}Pzl`~Y;XG2`%reUs>~YV*!iD-Wd;R)9&-Ao+#M zb7&8$%a|YEFcqc4FQMDJjCW5ZqWWu9fNFl|yNOPwI`4F&DgzsI2G#ikfUq(_;?n}) zmlfc0k%ABD3HHISgKi%$PUY!9SMp@vc?fg~3`onaLE8`>kPj%mgPWu-z2i>|y!!A? zH3DC@-Q^9fsvX@DsjFMdfEYO)J+3enF(VrY%{;W-pbxwF6o@}t zf^O%2wB`K((2>`^J+Ff}m`2l{xyUJaRlv4v1_m1D4KTPS`mWxHwvA6fGTz7Q}-<%p?aCv+)e<~7;bIix%xh1`Q1OD^r#ZpPvy?5&W)2!llrIv z=uW?a>NTo8U<$yr^N{rVFaTe!%&0(s9lijo>4CR(2S{HCkQWZnRzVLd55pC%;PNSt z-Vx_eeMmoD#7l?_MQR>CPZ97nUK>0qUi#$#1Y#t7#*~5YD9SbqOVPt-a3)=b|+WIqz zwS=?Wm<#rybftRcR5vw6-&dI7Gi?XSKHjW!CDy5K29+gWpIdLw-9A(30`<14c4CdI0eobIn@X_{R|2#bD2?K2Rge3!{ArZFm<-}rO6t)RZSxp5_T+tQQZ2O2 zWwjQspuV{%NnHK09Q=>27&o;HzyKyMDlbOgcQ1ndZQei9Nph9%R-ELid*W4)1A z+)@38%JF2>^09)_)n4eki?@zcUM@b?qZ-0T*!P#A&6@ zs*iYSSj^WE4$|v|a|-REA;DgEAWo%&WJ3a29V4q&F9G41jJBO8P`b+;%4-MFBb9q* zC+(%ecpx^>Fjtb*kF`Ovl$(7j{mX?h=zF{uNFFhq?l=J?qkRFkZUe$G9VDme1uR)$ z@R-jq8uO`iSzftC&S(IiI90Zx$C4z_&0su~`zKf(`vz_M8Qc1{0=U-!Jw|e6S}@Kr zP))fbK|JvuN^R+5XE2Exc@ic4eb9MP(t!-i(wP12Ph^(F`xSKEVt}~zIuHsYt-NdKvGyt2 zJo|%b>sx5+&P(A!f>Xhu3*}0W9FEcmhK(*KK$6Bp#rpYZySNUZYdZj)8RPEbHDh^2 zu)33qA^W%i>{x>yR}KJc+llIcuR*e}HcC^ug__V$N|Z0ek7Mv2e~?>pjRjm5@CA@s zY^(VON-KH*B=kV_I6dH7ElLp;xmr~mT` z!QfxF14$q+4eLqw8?%GW2Z8+}zNi#31#O?Fg6?1vN-J)o+X9{+n-~RUj0Sj{{$)pX zv^AxVZ9|Wwuo|)u)o%At{b?V@n8Zxh`j^q>N^3vD3{@Jf>C#@X|KTn4Sa%w2zfyH! zl%fnSgG`nO53D|J;q|!uyj^ zO8*5U)p$?-i#MRzOiFC!1BC^g{)EPmxgqmr?mR#8*zKDG=iZpl8A(Pq~IyPf;|Cl_$}H4R`cC*AQ1NFH7T zVnu0iN#IFxeKm;7G3px@kLvHtV07k?E*5~7$l!2)bX(0?R;Pby#tTux%jnT>7fALn z`xeY~yUGQ4%CqcGy4*z#(c>fPc_>euZDWB=zYe-~9HXfQZ5ye--Ap@-oCNF}6wUj0 z^xeQ02(L1+@Ocopcr!F;P4=a!p}j0=dCo*$L60*`NIuO&+xz{&`2Z#Ol8*6b+R(Le zKs+9f>Lb1+u~57l#lvA3-+UCgkva6X)`gHIl5Zu3@CS@f!Wm z5r4EvL&3QoWjRgGcg6wHjH!qPOzBm(VvMu(Q8Lq%ckxm8Wybg8M9y~~+UAF%n+qR{ReTHyb|j)S zlv?{K4A{jK=)Lj)yV?TrHLo(kCjr{gJ9;%j50_?O5Ws{`Jx}OmHN8sIXpFJB1F+vQ zE;+=Mg=Ig$aUQe!7ARf$o%7(u$)C@eI?*<2-30Nq_ki_pj?xzT&N*at#0#a?)MO3D zqMy+5Y`cL{Y)7=Y*)Vu7ZXA~-XiM@yX(m$<^Sc9d^#Fs`R9Ggb@cA`Vw`lkJTAcn_s1w5G{S`NY!J&Se8}r8P>I`OZmP zLm)olw0h;B^cnRR$|U8|&HycVK#r#Q#H|6C$pG!*1Rzqmk1Em}k8yKWS^{7g4#eg* zCh^4dV+5K z7T5O}BmJ8UH1BX)8&;riJr2J17>E;j4(5_1Xd4hC__+H0sbG*s?^yYcyGDEwp#+p@ zphN>D8Ys~~i3UnEP@;hn4U}l0L<1!nDA7QP21+zgqJa_(lxUzt10@D8Ys~~i3UnEP@;hn4U}l0L<1!nDA7QP z21+zgqJe*}0m(8Tz(=x-3-FUHrU3umhF*r=lKEEnUVO7g6D>cKWY3UGk@9}h1v`8{ z>*lGEO##jHyX?_&uKZ}R_08P#4oC7spL!b2)J9RVK2kmwo;E8WE>b=eo@NRd5+(l- zo;EIE=%L7f_?2>GK%6Bqz~A9J0F2Cs-5rO_PlwGa6>{H^Dch4B;j8dRE;dW@fPhg^ z@*znc7cfb}aMLC8fpEiM!=S;L|9(crDKM8n^TSsXJtf)8;adu$hNOdAU_K+xOUL;` z38nx)&OJCkpLUkhO!0<3uw5rj14)b69?0e&U$BP1eplsna;pE!qTp zwn?jizZCL{5Kk`c@LeD4sky87sXh{dMq9N$LS8W+hwoD0xDesc7uG@II>bVA!T)>> zim%Au*SKD(N1V&m8!{AMuH#%U|DL^6JC$#NJkH_U0d#xuT{ld^yZ=}Zjj&f^jwEL} zd_V1id01m|j3Md3?)VytwHOu25*^?#$=Q+|ljHEcK^nQIB3aofCI^IZM;s2rZY@_t z)qkd-Auc8~+G-4!tiBoyl;P(TYd5n8!j<8Qa&7>HoHlb zd@eFAvFRaW$V%B5tcsr78GG%JyW_CgF>IDch{KT?Dc?7;@F|<|4zNeyd z&VfcbgYs!$vC)><4;;Q};G?PsYO?z7c%Ku?bT&GCw~12E2PAR$j#X>9YHgre6O(rM z)+^}aD@v;ZHegV((s5#&4;q-iKmXoZ{#US$I(aeJP<18?cvZmf1w1U^9sxfU@O=T_ z6fjx91ObN&*jvCT0mB4rC}0ghh#uY@=If8I%xN^rzO4?2q5#NQ%10|vZu~jQ=M}fT z4u_zy_$fIbIUFhJrUYg7c3831`|%FY-QNUoS?#Dj>~N%}Cw5b2eTc?acd}+G14?-f z>hnlG_aH#fCjjfQd>E|929%p)FmTo?D^{U)kg_ZRA$XO-miOqo#hbrfO zR<2+YMfS01+dyd+2^r{*ZEu0b$y?xEzr-AgD20(#gwt1>0(^vH0Fmc`jpzh!mV^XteuD^Y8(cRqM3helC03uSrj zrvJ2EPziqTD+sdiS6!6)V0l>E1if8>wClomxrnhA9#ekahp9Z?MVEbEGKXqRFT?XF z_n=tlv^*S-!5Zrtazv8d9KNeYdTNw2y9;S6k~T}FFp*biO2H z&?8ztEXikNow5xJ3)6`ILJZI|Jmr2ORu0`lPH%Hj_N)gs(_RG>29+W#X%@CIXf}RI zlW&g+IV$G}4=Cj1Aw>nT@4##b- zkOUmX`g7_1m1eM0>gUfrs($LhTJrV7`2~ZC|6tn!7+G;qgwfbyK4ZJO|CEE+K~UC8 zETF}Y{rWqdkC3ScNS!j3US7ye;09qKgtSASQ_mmlf#AFIvuU?hdW*JclE3x)kp%p#WE}<%iqRhqQf$#c*zmisnKES zQ?Rf12ikvueWacimRZsKdVpp&ZPW|6vEj_{t6h}``p^Kd_$z%hOf-!ca7Fe7fEMjwao{cuFR=~5Gxuc&2f zjK5kx%DT}X-F&2s9DgYURlpV7Fp}J6`J1HbnPz< zR|bJcSZ1QBh=gM>ZlQ!dibxp#jD&&zp@e%v3WtKaGq4kuZGi~zFOrm(jp`g$|NTUY ztTBr`J@DfZ!q3E}6&iJ00SGTxCB4 zPAneEq*KfE&!ZM&jm^3MW&c~E;0k$*xcQLumfFRi>oh!+C>#3Qe#!4|)gH_*o9he* zTPI)M$$LuH%>m($z%%()I-G%gVNYdD$>CccGV^4SkDYjBj~l(jPY6)37p*b5hTYlj zXt;qmf>np_!M0qq_Z5&y)@As`H`I@5{hr>jYR|Vj=J~UGD0qX4E*gx0fzw!?&!l`klxJ5@=BStBSh>}Fj;XAL5r{;cS zzyO!sybq7i8!=PJ!yfAPFBsCc#wz@Uut^aIIDC7cH3A z#V3r0NNbyqgLN8vd0Z8!gi;RQas8nWbEZxT`(=u) zFtU9{lSN}=@S4^{@S5JVI4}SIkQev8B)j0Efd8$&Q32$p-CqYEK}V&a{fH5#xg0MP z0W@_~n$^W-wo? zfV7=l6<*HKxHwuE8S$!|n zA|B^ndQwza`qZjulGxd*%@93bqyXoN7VvndI1hjDa94TEF2>_U3IZ>oe=#?wOdX2z zYXar%WD`$bZGEtW=Ab`ZB82ir^(|E10F+;-ynLClqE_wonw)eNZ8-ze&eFe=uNX=8 zKGFy5tiJme!pjP+EpsCC_l-|M>eMGBJ>-afZKRxGWDe`JAvt$~Y4|up@*kro439#l zO3n>AVz9P%F_zBOuQep!=`egkqQyPHSo#$9pS%1JURG!65l|+vzhw5FxB)>%o!oW~ zy>wXH8x>8GM$;y}l#9j`*e0%&tHxBb%_M$Q)oy+G*kOL)KP^DQ1&{y12kJk{NT?Vo zYs>A`X$4$rnSv_o`=tm$7sP z`W{7>!`iI%YWg73;(ZWB{oWfD^=AB`9Ss_`qG2D?6_)B7Ra~`%8K8J6Apz`NvZahG z{!-~|2@~{}kP7#&mDwsYu{UzGpf+de4r|Atz$49~9fgwNex|=E)STsiSlbm)aZzr^!AMzzQzc675FRZblzZIuiIPu5$}yTKx3dfn0)Yu+!QbIqqXm*o zSLY)XK5T0a7?N(=2F_9PH2wV6)LG4AOXM-mDq%*X+|%7)zT$6+ zG=>~WJ#7j_A~?n^JwlGmbeF<%r}(pk11UG568iW=w2aL3Ni2mbSUO0N?6%D%#_fQ?k?lAvR|xw{KQ9g!0DWumYwp*$Q{*GqsM}{hwsj&>e*WXSzBgyH}Y15 zTLcm&x1UkjacOUz+O<-CUG>K?9J`+O%KBaDQM-502jG7xBs)sKC0lZ2EOdccUFBUo zL%~&df8n5168=TYKSo*l>!K`UeWEN0e!YwPKbMgEaD377oy9b})FWWOTN8)@tX(}v z&~e~t*Gc3r5e9sR4_uByjzn47?^ZJ3py&_SD~0zL=5R3o@X%%+iFpi9{UmD_WL2_~ zTKXrJ2~TSxIgUtX#U=4~$vO&mm>3_$ibMpH;vhEYd*cDzba<`r^shwnYIS&oelEP- z_tA2WvKeC`>lmZo*4CtzNt+ zFz-4ttp^?vn{P?UErl2FZk~aQL5ythZ|JXGS_SulY2lJ=2RH!~#l=D@AhPxTK_< z=A(ux&bvwlaaZw{+ZTv5^_eTmZse9EOCNu6NBLB(1S;PqsoSl{NQFh1zYk?9*fUB3 z`^m9=?4DA~swP}jx?w7(6aTPAFvE*9RYF$#dp(1$z?pFy&oPxxZWq%9pI*uBxD=*Z z_6o|+@SEo8!J0Wb>D&nmg$&ze>^`Cl|F&W!MT4kbLX6c;dwB&c%+7D z`(v&q2ooVzI+zOzB}ZUEK^6YM?$2~WAU2nG#HWbCM5t#)yr-PRBRGp2BkTjgFU+{A zDii054+S)*gI7T+MYKNv540nKDBhl)U}J2k3e>Pij`YgE-%W- zC?~fP20g?4It)5NjwrC6X(KqzXt`S`Zs28NtP$?fZW$4B#d4{q=d_Np_VtO1*L02_ z;NuSe7G=)#iE+Ca9dt>*OZS?7R~bJ;(2+zP+=UU3-Rv;+@{XfX=5%a}x#F5ZLlI}Z z{jSny!QU=JFmn4mKzv+Uk3Etiz$-bvkOF zi}PQ!e#^xXQThp(%LBcBff>y7H4t58b&wa$)8u+;V%&}z9G9aleeXnC`aT>1@FX&= zuOkyJf1vUgTb^c)Q2*u21LR$_KN6JShx$F#AG6n=#dzf9GrO-c0>OjK#Uu3N(jk!l zv@*z-yWEY?&y94+%`~@Z{~m4%`guR$q=*jFwnc4fB^27AFwOhE_NCA8oKm0q+f#?* zz}4A)=`NUbl=*UvD6UWJUcDgCy*Vu}T>Ja!!nVAu7YJ?I5puH(Y4-qQPA6PzNEaV2IR~H4)f{{)Vk$?7$eEC^Yc<0qB<#nUVUWwY>YBN8&C&|yER4}JN&Q%?eymYHwyGcL>PNQv zkt04_a$(5oS@7b${Qrm6BL0Y}1|AcBk%+~7q7G*;oUrRuEsPNHILZb7?M3kc0t#_P zBNtY^1HuTauYLv&im?5r+C`r3T9|>A!X%$5r2utPJ@$B`p?G$V@wfKEYv3Us>SRqP zn+#K60UOaLT8{9E4hsh(K;2Z=6R$|-R+>b7J}+I79H*?ED>z@k;W)v`IT)Nf0F_&FdW_?n&9@!hUe}u4&N&EJT(?K2IWPrFa_}q z?>P5xpL)R^NA^V8_-b8|HZFdDdFFmnlo9?y41kmV4zOU(A*xxH2i69W_k0hoUQZ`r#m7@HqDOd-6ClvQLI59+;JqY)8$ z$Z6$=)tGeZB~wLky#EO~o;Trzlw-|zmP*Y1!Xhv)rtT_Nt;`Eo;!0h z&UbeF&25gpjig?p2T~G?VSWx@xegxZd4GXcyv~t_9HV4D>Ik_{>m8}`#BE@p?7b8e zN>j*)aXRl!LSJjgWMwoG?6UVX;GEZt0KC+vlvc?Qn`Sx{hY0K@Q)K0yxhTXu`WD zdd!pdj+g3|qMcD8#L-7Sz}p6YZ{cFyv43VF8{mf(v}j)kOY;MVsSfsi+jU@{rIg0x zpr*2iwI8BEH6Xl(@w>_4aK6p)+$6|X_HIO8Fp)A!7rZ!N_O8wu6v-^8-BgcZ^RVE{_qj+A{Fx{h3bWr zC0CBmcqn_%Fg=KLd-0Mnb z=aVLZ%*_rH4a0UWuus<_=c_zReRs|<=x<@{;@mQ?u7`2-{t8cp(_Xixl;RlmY6jmN z_z&D*zUXT1uFyZfSoWo>i_5Niq3pNdz5kW$KP0KMRb`Kl&0moJp6qxaP+a%8M^4y} zC()HUd1&;n;H_&(zN7D#8*&=YIs<=3CS}eY<-0TlujyEkuiwXE8-E_}nJKSAJP@Gg zj~zWUf{w4B$yt1#w=Fh5;|ckkB%f4vOvFs!(ZWS!h8LFgfgI;Q{SwME@(Lj_>~Ib% z=_kPS@8nBLsg;`f(&`JPwcx;2rET=Qw2QH23#HZm_oO|3TzuUGn*k<q#P=@{247g{idWGm3R#baw>o5MfM*TJ`#0+1p@~Rpjn{n3 zX!g5NHa)gfi9HCcvWf>pd6u-zh`>SU&Xe|a% zs=9oRmvUA-MtC-Kdq$rKbmc!ReZl4-J>_fG?tInN{w{p>*xAg*r1QvNJlZ?PLlb4u zEbOdHvbiQbbdmJ0-Hn3Bw7cO&GCXO+yO32c-9M9b)lIY@*pIeo(guU`KfZOqlUXC4 z!cRw9qICSe6W+_~?4dF0J7k#ua*0ec=%VySEFnYAqW;xsH`JtP7COQH(pFmlqYF8} zC&;0Ac_SJRu$xEAr=u-+Ua>za<7PW)CGwUC7tUShTp4=p^<$#BS}VKm-zYaS(^G6rSP z#w@rUi1;!Zac0PIWj8K4*zDndlP-V8TAVR8=hJC^(fOR_e40gD@LKo&NXFvwg-ATn zY4%U0r^L+)B|eu>T;fvyNMfwnGB}lDi)8kM3b0}h?fez_UI5Qv`WSF4j1o>T__S#I3fNmEmn^InDq*SCpoS-)9+LU;1Kjv#G|SIFEdavi@p@r4q2SI`+#k>tEEG>GpWVvHXE8?q zcYfgbq8Is*XZ^r^hU%6kupP@}aW8CR?L}9RvmCAT=n-NG(~e&8tr zb`cVJOO}v=cnINlB`GImSx0CQN7_wu(>3iCDuoL zf%lm5Cz61i(|>aJ&EE^^TBx$|B%9lYQbCTyYCNV&>%WQBDUA@{*#oevqr^`FTB|fc5bz?E<_{%4i|ZqNq0onfvoKOP&Tu4MF|9#T%O-eVgCqppmH!@y$o=XL4@d#31O6|R-JC0;=0 zQkk0b5r?T@U2ZSt{CWCg{)mwDn7iCX2eXvoD_A?aSV|+1Is*g!PplG);ASd|GqttL z92|l*HHhAdhHdII3?vS9>WR!NE5ZPSKmNxJ+u+9|*m+nxeT;bqj#P+^ba<4H9dA@) zo3@8I?R9wm(U9kBC-m&(hersBSD5O4HpZfVw0f6q@1a@fp3fU;13y`N@l8Y$@%!_# z@lGI=I~IQfcY}+`BSP=vzTf^*N7xLu?H9;_pQ{ zZ4)or@C*L=FL7GO1?1ox2mW}ZENf#hxH05*kTx2HkV_WhDx4G1cxN*lxlc(+jpypd zjEa;Wh`SD+jzEYzK+LFXE6 z@vyZotI+`Ql!&@~IM)ZJ6$6FfYi5j+V|iM{@+|sjj>BQAsFFV+InMaXvIe|tPw|Y+ zDBmz7|H^ll^(jYj#WKk0Mmf)rd|iXWpbQ4GmXH9$mK5+@ntbNH%^#W;O8{+uzs z&6k^eMNtauH<;n?VSjPJIU!Iu#5V-EV%>Ewu)jLRmBk-gi#q0?m8TuXa5 zN8yw$@6`PayoiNYQS~YKBkLMvB_xfm$zRn#JRvA7<{XP!HCGV>fz#DNh zD#+FM2$-Zy5gs#}LWC<5`(e!}qtbqg!;z<*YQ>D8l*Cbdm1Ytm0PV;y>T}0UyiQz z#0X>v`+yr0)IFdzvKCSb{=v$-JaL7rZQ=W6?~{x0yd~q5l9#;!Uou~d&T>YE;;vSg zQn$kjO+Oh8O!yT8&4+?>)DsJ-_r{O-h7e+Vn&k5&9et3=_~&*HY`<8~|Qz}bDtP78J~<+IyZ&;>H7d^Y6ctob;a zBt;c?Nb8hNpE?hsk|p>23|U)C#tn(sNcO)W>ZtJ?N|%} zO`_BXgU|zvFE$Qv%B120jm1ED+F2G=Ppp}u4uU4@YT_>!ZR1f?}z(> z-6LAIQy#oejv3@C5BhVtbWomTiAl2t*g|L- ze8LsDzRF03?uv?_3!rXtogUyMqAmRVOS;&Nz$>5Nnq%17Kp26#QX_^7lCA27)hH?X z6g_=-6Y8L%*Qn?mWjN669ft;c*Ze&&m=cK}l(A})TD(A_=m5UC1L2e~RV0-mMXDe; z_RJCDKsMzpf;q-uVo@DEu&9lSuy68W_IyQ%>_346B{h95)N`r1QyAg7oa&+UU_Qy& zWrMgpImdewP;cI$R8p3txOl?uggf1(U~v2Yj3G611fSM;x|LmQ#Vr`F>DQ@i*9^% zSp1j|x4+$;Xm$L$IGsetmqf=(&v#-ESz8uDMaqejG89)KlRjnJLy8oGfa!=nFD<#}JmCI0A+>KSUhCq4`H}u-Ft%1H&K)FNAr;D%zpN;tTT# z?l*2z#uq(vlnS^nu_4x(d#HkQ)`ma-j>zk99nE8nCM=_fAj9EUZM}dEDH4_$nz zbQW*p71jp`$S^C0YWlYiVrG$gqhgQ`;=Aql;e`>P;T*jO9k}HpQq!mGz_js2H~D}e z?7aT%41NVZHNzCbZR8IWW_!Hp3-@&XrfY&Tz_uWtOY$R4IZBex2&&QU00Z(1CckIh z71ZV2iV7U9eY}tbT*?>a!dHhrb8=}6F81A+SYkN@meX+vd(xV0A=ve)_e~@7859*G zu~L3(F}7jP?PGss9HdYWx%|T=R=qvpKn=z~p~9x{^0crH;SpTXMGbRg<8(FBF;1t| z8dGoUQ+~ykm9<^W2zM1vHQf3`Xv--7Zb-hym`1!^OiuuVg6e3F#tfVs-KaI-xeC8E zdEqMLd)CXsRg2RPu@_zIZiJ`|a0-Q1Mf%m`$)O+>UZc2g8f~zqY98mu>ivnri0aU= zDGqJ^`=QlCr0CFXUO2R@?KqE0@KBX-9L(jI>G;VZ`CRgqbkxj$g$onL?6aKji}_(_ zD!~(Id%ut)$$urG1RbFpj2>2=--G(1ncNRndz5Am{9X&*BPX>H2P?NnzGgxBqmxq1 z@_Dn&*X#nENUA|Fs-O42XV>rd< z*N%55pM=iT2WN*VwETO<$8p*e7yYB>7;_jnO%Ds7?W_ujgI(~=uH*v@I19eP_W$ay zoE1%Yl$1*}P@;if$2Ye+u%bPUXBSDK;dnm4w;!~bsM5{* z}AaHXjI>bz)M1W82O(*ye^)Xk5wPvU7*n4;K;y8+HUIj`jjbXNDA$z zPZ^B@4oLTq`*yGG4frge%qSshJwb|eBafR%{Wo}_D?OV}|MUx13TEE7nI9IxmP7jx zWyRhZSDcwh9KD%C3Ue5S^ucd@;ekgvKJXy-8p!L}GKjWRV0NOt&c;BOG+~nZR79Wh zAzGYy`D4t<<42m1iMMLqU_bc@`Fbpa;RS@=_5_x0<50DamgF|$oPzlmu1~O7A0>3K zm|G_j1mPLt1D82?cdpVaO8f4dH2z${0_AXqu9t5!SCHF4RA}6W0a87DM$3Fyh@-)S@a0?G0lPjisO=(Y9C$6rm<#*9It^JX?QOse1r7-*ejlvjiFybGjSp~J(%{uo{C<;K z7m=n2J5ns#w(4-qi`ZX6XQwFW-;A8e%BuCP!!3^AO@bh*6jhjFR+kPt>p=Mb((fV_ z_?`7roeNXwcPa*{erKHUILZp-%C`4c%e@h)s%~c3`6}7Vf1&Un|~+ zRevi4zetySD~Yqi{7rnygu(IX?@nZBs6HhUj#L@h7daU@7ul<{HK^-T-UZC-pktZ< zzmSZq`Rom*`iG6XMGC{Jy;oHj;#Sz@Rv05bW7g0hw<_J>N$v3l`H;bJ66fn+jG2Hj zF_fvh$fo8fpY^1LfGxXi1?%0+hSf$#kqu)y3(qnFVHk$3uo7B+Otx|}mO3MDjZ(?L zRP+XyIqyWbY-bwk6x4)YGyt*uoxRoez@qGx!+g?!TZ%}Pfj2KYYMxEy{RVk6=_Y5v zN32mci}hiibq!Ag;|3ttVB~bg3Ps5=S(0o_*YCBJwsZzjDcfc!H@amje67c-osB(u z*qEi}dXP=UT%e)!?Sa%!HpSwMm1YGZ2@<6xhQ!#IpO|mD!pATManpB7rj)|0DTuv( zaqTGz&c*^#&S{050Xet!hNu`(0CMIwHK zko&se%*)T@v_!HrCR^{r-`zCkD5YRtI6a?C)@c^v_a#iD#0#I^ zw^45$Yzl7O)a2W`d174AfX0@>-N7V#Gx6+&R+g=7Z3|NlJ#18XCSYaXsUeI$ha+N1 z@fnlNMa@wL!eQ8*zj4E!0gwy*oSWs0|G(;22mN45*$lLd=Mi-jJ%#_f%kZ2p=z-Vc z#jjJwMa$ZsC-Et>c*FdmQNPRInDVPWWicL3L@@>&n2tB<_JIT`Tg$*KgM8fD-NRsh z+(*B_SNMk~P>K0rr)g774a~Oorh)h}jj0bocY@XguM+qZRO1g-r(Q-E!){fVz8^s+ zwtlD>cB|QUUn^TA(E=%;Z{GyAv=A-MUVYgTfQo#|d^5&0+I*A40K7z?C-5TB@+C5p z`LdfW3~S*0v3slU2reLZaVYeT^}#a|)V1}%RkCnB3)VGVUDs4($!uRkzycO`!NRsy zv^Zr-u8x+)XfZz=Y-%254ac(_ZPG-Z*$7qUz=oLXuh4E3& zU51}Kq4w5wRXw$wWiw$S>Q6fnaRHYq+Z$kNwndpjC`b*0s)Zt5z-+LxE*!mAfp}M5 zMm46On#pQgR12)d%9aLX{IG|9!8Dnx|n>$)F-Rs9AUrTP&Vvl zMi3*v!I?5R`9?JR#1f9!m@=bO8q{JZEA~*HH_8ALObR@UV2z*#a?7UOYy~ z7tB{(@tT7v0zX8lh451$n^=MAI2-YO*2u%g^Xj~`BZ$lJP5ApLd};Fw(k6i<%7F*(+NtC4qU#+bj8$xJVC}ogI4BL7UOb&i6wx6RSs;?s@?}$FJSnyegmzSWSOM?4Ic5{Z@hw|SDE{&c={TsNgOR}$BpLWRh(vHC^Z%}W&Lk5+d|dnZ|31ysV|f94w8#z*3C!EWy z6`l2Q8jH4GV&*EZn24AKY7FF<#f0Su?oz>BCXSAN$E8pCMavWUtZ?I4@rcqo@Hvd) zKU9#=F&CyW7iJZEqwYS{ou-ge9$=H|hUhRj!zN>gY3>-bIcUDc5J7(HqSXsH)N)c; z0T-Uo=ejcdnLfJ+7=+KQG&hOT>Lk2i*AXEb^(xg=E`3K)4qkx4So(-4b1XoJvm2F4 zUY{fg{h>H0sX;)@&lCw)8OvQukD?r}xs%ti)OsTS_=0v1^bBsn0f)y3HhBlOv&D_5 zY@@!MHsc!3sQ(3-bilL%p<5B;84X7=*!Tybwv;hl138w7hZ32TJ_c>EdJIuQnr&Q- zwV6TFrarPZeaNmv?*`>N1$yo?OSKtLNZ&a&B|cE#2J;ce0s!j-+}HmV{8*9^KYs0W~CDWfFd zj#_kV{D;yt@samuX*(j$bhD`xa{dwOmAKV-(s=`I>EWEv(W20e%kpg4AQuaA;|--) zuql<+q`_v3waHx+e-mC!zD-j%+EvzQJgA}aDU75wABJi249q-BJ=8F0b0Y$#1tMfJ zots3wjR(L5b4pHR0che?aIFHcfotJ24uNE)>S~s6L9$YfWJbeWxEb)oLwWNk;340YFSNM z?2DbTKE~l@n@gSQ1Vq5rSg-<515|bD@4_^(+Ylpq3?(=c?Gqe3M}to%5|ft27g-r= zEWTxtdiD_6B6AqFt~smJWILxIBE!E(MGnphI|bn8TZk7b?6S??%lb#b;*57&4cE7xf4MkQdrqQVF|QgZxjrIA*_DXdOpNmHaW)9Ija zwv;cZ$Xj_@;vGZ?7}=W_p6e~w%V?;;8=bA?<$-8L{8HJU>iING_ImcxqeuL1Er#oY zVu>;-NkeOzDkKB##hy&}|CsdtQ>S!3z{8!$;tgEMv`k0rZH)SY@gJVv8a@8HIgCG@ zw@huM24U%~a+$w^S4#^Ii&rnQ;C1#=%KeQNm>pOy_fdt0rJ?JMsbVE_X@|uild;oG z=~lf{=>jls*_@JMt03VEXkW>fDCmrX3tEo8(_xRG(Xg4a{AML&rOBwT=fz{rbv5h{ zUmh$UQWCo4v0?#ym9(wOOK7ZGg27;r(`j0%B+=?|b~NdWMX8!mA!(kIu@~y|JrW>= zO)RqEk(At8)fg7~NyPfa|1Cwz2F3 z{80)OM8z`OrT3$0Iv!1RG?g!l7wt(V%kR_d!5n{iwIeiDL(0<-c7;d!%L_xpAnjN; zpEvdh@FHeUcMS^Bkv@uuv=a)ftKS-I0fAMIWB&im=fv3>DChO209{tcdXf0ERN$nr z#GBNxi;<<39E}vAtHt1OU|JkM&%p8XY+st==l^WkzB>2+pB$eD0emOREsRxznu4)W zTk(6m)gQY|@vG$E1e6liT8Jh8#cJ*8GOtCgUv=PlsdU*pECW97ka9iB^cDJd72Bw_ zWiF%sY1W&%vWr5q>&nK8VI9&9)YR9)p~aWW8mHBvZLn68$l@yxwuT3=ow9^(&Y><@ zp4q9G>qYWti5)K-O5QujOFAtkiaDRnwbLOH>P%QfLe{24P%4QcWeF;-GHrtcD%R~F zG4;MTPW$sxZ?djH_(|BRbvs+*EcGlr&OlFQYEbERkX5;d5G$yjzqF)^%- z=;36mw^VjH*TPYu1=&4Tv>=aNG3_YN0 z_>d4^;3RsQuo#%^O#ECAUvROo!nu!SsK1@Z3MhQ?10(^P@H+PbtWTmRVL8RZj^>d; zEZ^aW17>(}5EitjvFx4P87|K=5G;q#{G z0JAQnU;elmZj>`T^ba}RJ z@~49RNc<8oJLtj$TXyX&G&#anejoO+$GCscy!y_j8GS%2B8H zZXsunoxJkNsNV)NxJ-1z>IJgaDK6Hoc8P)5*-uCjvtRijg8wqvc4kphnDj zat{GfRx*D%WwU6cw23JpWYDbrH&!Kn-g0?Rd{=n|CsC&r+XAGTN)8mu1>*S+RJ$DR z#t%J>Z`74v8qP!0_&C!me?HOPva`cjmpMOX&GJTPvfy-!3y0R2aeC>H+?iKnR#YgO z$;ghg$T6B6^{<7_W-waS<+6#56-9;#ct!l(rp`t%Y>B^{1buoi+qgih2~XuB96wny z*hhnm1cn$$zC-=liLy`ekD;C(I-85lQ{wvsTh(W^; zp-%b1R%X8Ge4NaUF1m6WU8!G-_m$PV5XyApo`AMYWYlRwXnf$$=mS?%9Mmf1zkXwj zW!mV_q7!KmOHEzbgz)gXSs4?;9C4R}xlR`!5ah{?fwcEFO;$1zCt2%R;xZTZTYrk| z$+|UPjvR|5EP%mWHy-kyelR($J_%YfMwT{YjPIW-!0zgf;~*L1H1GqZ5GWF+R)(4; zRnVkOEEX&+THb<|Kvoo4Vr0aG>a{B0`S6~W+TU_7QE(z7GcJJk&>Ic5)a|=6e4Xhm zrO;-Dg(Y;sG5xt#Wgp}h`v)n2)p)SvrGe8*6O*%M0sN#u&^ixfav2ODWy%(+gYfHW&x{D2%zE8v|p>Xv;~&do3*NU zg<;WLhD?xlRRBp!nU63*cIX))n)S*hqFS$9nmCi%=1AEn!n95&R&<@bA_y%C5b!Lu zHj9v&KAPqWIThW~(r9H%{P%ioboNIe<3&p+v$>h51MuXZ{c7Q*VCC#lGO+1bna;OW zF=^hdk~Lr(Yk#XFGHI)jcB6g=Bf*4;>?jRgEt>Ny2RVWm zaLUw)KSN$%SKt7M{W^5Ddy_d>u%&=m^cQ&*5WhemrA7xU{|Eu3QCHF^EdrUyDs?e0 zb@8)zHSZ0Nfa$Yk0?&|w5hO3+rT+Qtovv3eM6_o<2Sre9kd>xWdZC0elx#zw964Rx5^k;6L$;|2nh=-%@v-A@)-3~ z;eiM-i!Rh56RP8unfl%YjO89oTa5Z1gt>;`05O}+F1D$W=1g&sn!ocBmt+2# zR!rJ2DMO&vb2iCI^=&=}bP!bSnPE=5Ysa zuvL5;pouN|eI{nB-$h815_jD~<7}-tW>`H%B7o85Ovd)RB;_@6!&xTgp1Z>%KjvgV->~7 z{aP{z2Mt?97a!zR%Qq1|P5B36)7M*7I`cG&;n7;taO4nCXKtNOD968ajO?!HK| zBT~ZvWQt)BehW9LSA~cmwJe3bMlzyhq#~nnTcS)YOCr)I)R^C5hpIcFLv~W5KdZA( z6~sc}Edpqk=FvlB);?5H2W*91&>VOVVZg=y$tFa9{pvQz9sF9SuGKAm5Ko<^7`pdI zv1xkGe3f~YQOT`CM)X^-H2GJuc*R{Z$ztwS*fJ!s%>-Xy(mX>B(RkLjs+9=(9~}o`=YzhoD7VM`oQPV&&)bna_=C*73}Pt0SLy!h=6D z3fR1pek$n?^iX+5s-|N*Yr2n`@cEdyzmcxwU&YE=&vnR^&+p(W#7!w?LN z4A7N`o_MS{rz{oo;;%j`UmkZm#!u@9yXXdg0s=1<5DQcF9-~=&v1kbQdCN`>pB#vt zclZ7rsPfGpu#wu%1m7OS))Nbfzo7(-|B*Qi&wc)otXp&I$|o2NKOn+bes<*j^R3nQ zB|js!|J3kFloonSe}QFg1_PGyB{t$yVHkTxHYO9fk^Nc5o#V(K*^iE`iU3a7yyiRR zRjxqv<}EbgO=!=W==e>Z$lIAl{b;>ryJ_JEpD{r78#M|!&)<~;WAg#qaaNH^T3p=? zCQw?wTbRIZYBsp7BNLA$8UwniW9)`$=MQT@fW(RFKGGmM$qF5%OD;ID zcjAP4RxiF90i==JRkQ3jw9A418Um4%ErjT(C`B$_9s#+iW-YgkLUIGq z0p92oJb?PmkHznBEZAFJ4rmDUS4Ti$yH+jec#+f&*9F4s%Do+xTj0;pmACS3jXLK@ z0GB_KT1`P9T$w=1-QH46eDI{o)A89)t3HA>isn)STT9)E#)VoKpSeB?K ziK?5ssbdh#;3f-N8+)|qaR_eG&EBf<&1%5!$!a=RS6U;ZeH*Y5I!C<>qm(K>MjG&Q z4dscV^#Y8+#U$LU?5!=h`iceD1?p$y(6zs$2Wq2KO%Bh=)b2N*ORVxnZxQEAoISHc z>`TuQ8o3x;wrFBXU*P_azTnG~l&_pJ-Ige)pNwt#j*2^1%v|v+mUT`OTL+{8Zfu77 z{jAO9uxr9OSq3Nk_P3N2>vM?OkEGmZV)|VeUcspsSw*DXk2jI*(AL!TX1b(~eVsTt zvujEg4JIY53s+c<0>^aq$)bK%_D*}JRHwP8)>8muU3)1dcwCL%f~0kjlLVSK6d#7r z`Mn}b7Q29=5<0B8IL+n|;_M&{z*co9i}oCF>T-s$1sF+q08C6=!gRT`}hXJL|jYx1S3r@ zUzXmb0%dV87?G=6xOU~;)F>bRSFj{@F>QQH+|TZNJ%y-x3@FmM#Vs&m3?_t!AW5qX z<4LJ06WTmL@4ll>mMW+#b_wjQRe2!!-VS|!Kan535kB3;Vna4H^i8Eh6g9Go=DT5jO8o5Sxpwt zaXbkd3+wi|!>1Grnp1*5_xx;&pdv`MZ&3|_HNgw zh|IlmVh0PLN<7#t&#H{wkl`_RBNFfK&-$}3di*^kH(Mfm{Kmo^@N`D~&v-`mlo<=_ z3513SUo;pDiNtYM_fs&%GjM}ZFUM60gpQX7cM5I@9Vw5V^2qg6Y`}619ttV(WlYK) z=lHV3|D*adBY-l5%Y|E60(!Non<1eAGq@xuUTqW%6@n9ujo35)O@`}Gf|I`@Q-oDn zV)2)4>X|cjA#L1`tm40-5c-X{ac+x<_KxA5I@?u}_2IE0d=mQD%4aq&Th&d7LoJ%# zCedmdWkI9mrAgh~Lndap$rn5RkAghV$SR+iqYX*rZqO;OaVY1)@DOj=q!z#hNK)*^ zyiwf7cFJ%&&T^rI!Mwme&lQQ6liC-Lg zT+sHn^7yqpelCw6%i}?L+$WDkAa%%0xDgYF>WMJwXTvq?!1Pq$##Ept6}U1Lz&Zqr zC8roF&9gmOUKGzHk}26a7rPCy=Hf_Wp_Y?bhZXje&6^Y|m3jD>Y~JFfA)mBpxI8YD zN4Y%CmB(4~IE|);?>CkYPexQv1OSLa?6clCYy(zVt?DO;0OIxg!54di_KaWkslc~9 zG%FI%35|}#Gt;K_aZ+m9)P|nYZYjPf@#9K!l~(6+fB@>i!Dd8SdGL^J@Q{d_bc*E8onR8_JGO+O?R>TWFiOLyaro>H7-H@7fRnp7d1o_G)4=rKmU!2%0t zQ9F=K2Y#6fyu-4kW8@-HM#HE#Q=jf25ZRk!G{}_bf<7(f7W(*%g>uF!)ISpUgieyd zJ7AeUM&gQeho|a77|W*Yc&icpIbwsa1|jY9v~?@eJc5L*^#Fj9oWtLtj;?FHRw%WpW?7FdjZb{= zCxW7WqaNk11unK}5(s%UsL-KU(FhZ)(Od{pTe#Oi$ils!m4SQb7!5Os5h3A4WQ)(D zXd3}rJ9=LJN@ve+IaYUUGMTl&e_-Pajq4!aAq=-68>gS5Kab?I)#af&VdD#2O1=eC z$S}lKAaM%ObO*%_CuFw9Z`wyTdkPlCx9my1VJq_T=ipw27I`{fzkq@;_NM$^%s?B* z)K8pr<`GJ*+gobfwTNDEn|P})vd?Km?vS@EE{+fyb`z7uy_!bdn3-6qZgAMpQ!zOSq({Mi)w9$bhBmnKN&n4g=C>hU_cE+5)O-OC? zwBjj`=E-D$CJ53jQJ)I%ghW3IldN4f>a)!13AV@CRh+x;3mMTOly+1&R&-UO9KEC*nU4_y<8CU1#cMonAUfRvW!VO}UHc$FX7dYjLq$N2%Aw zo-QsQQ3f{4dt9$pN7TNAHM-RKbMkII-gmjZ8~Kv~znjkW+6AA0qUIxm%K^jvTr z)20`4JuMIlYfWdn`jm}uC#N~OgI=_$9+XbGhF$K_mKMUH+btYK>gZ1wCo#6J3Z>*X z;4#FKRanPJft6YggL-jk9rAm92Y*LaaaZx z)_sIUlhd@`=y2PVJ}bV4cVA=$#wkTNk(K60_Kq2`pzN4n?L_M5q~a+|I3{jfHYzSD#x>inow zAh=#V1ggX@koJ&(2&=r8`Kq>nQSsySrvm|24ML^?>&MMtR#Qa$R8|dj9bnS2F z$~Pv5jN_@y8AE4tzW(N+CQ7cRK`jX%3AK?8{zy{^wQ;FEq25ApD;6ODBI?|H7H5=4 z>Q*{Oye)JV&{{r!xJQr;=ZosWz5?HWM>X$PS_u!HXRIABo~dV;SS#%lQ{EZi0T&n< z^$UPB=Dgt>tVQJ!Nmq^qV0Bw~04&L!2qUo1VMisbCv;wnceQy=o0?z90FTrN=c5g?k{2%3^%Zp<=Nt7{Rxa@HKq9oCDj| zx1-V;CFXW-ysj&gv5!xNizVuDD@yPtKAWhzvTUCMeU#BTvb1v(tbA&~I<)}UfCvP8`y0zz(fuPA1 zLU@th_Mw|aV6|6YRSR_x3v(Z;Filv6CvQ`OVPU0F9nHATZpLJZt=1gDXkYpGws5b< ziqjng93uvQ=cS}p*Gj!_>X)IVLohEWOOmIbRZ8XSvTBftNjD6L2 z^fKZ#7EY7MsB`zJLUT(a?|ZB@Y&-8-i$8+zrc?1MdSi692<*a3AI8w?c)lEcxl)n1SdWn$DDGUuEs!NT7a5z`7k04J+GXbpU^haVQcfurm2jo@S; zcE;G3a*&^&?P=U4@Ib!?#!jOWeVSn{1MV$5FT{H&pTJZCXa}I7f$|GNv(ZH_*7j9v zDj(L2Xe?L?YAn{e7PlG*=WO{gTLP)ECEzj`$U>H)YZmkF3&c5?xOG5LR^=r$R<#_L z%GRV~)dnr-=8lxcT{^FL8ljczP7ykLkYaPB{Ke~E>u`qx#>3QyoQqf<{Q$)0eWx4 z*>293Ob5fz)=fdtInF0eZh#5LCOG#8uR#$s>^?CZv1SZ;Y}oWXS!ggCDT@eKsqIBF zn0+uTOE@jnq>vZ5uE~+}dDLS$s;i;T?aHH9GxiFG*tBs|(r>6pP5@ZfFI^CSn$`>FNvE+Wk2)`- zN^(w9GhxtmNtPo6M)+fZp$A+aW|T26q&D{x8S($J3lW}aY~5{{7lp?N5Ti~frHOnd zwwP+wVEA0CfF-<20j<3RES=4x&zno^KA$LsCY>vIkBgr#N@M;+~~ zWBphlnxAhUBV~&t{=8wQ39ZyVLO6K43EC;^@hx2!x%mRRJdPL)PJE&QB51Llp9+}j_)UXet zFcF*7GIky*-7ampPo}FZ9d=s+m?X^7EbljcHZp};dMw0F#jWXR{(xf3&=9BBH^@A8 z-Vd>5{wFROw0X!yVYg)(kVz^%k<>6*e-1QhIYSn&Kd_GKu3i}}mhyndy#w&QmScYf%zww8TSw%j&qS@`t9Ze!RpDZ7o%{g=Lg6rgx;(L^S$ zYDLL>h4_s_ZOxE7l0`kp1}k@5UrbM?W%z1eQQy~H)7IXDQXL3o?<@ zr6mDl28hj-00jecG1?O0Af1$seTds6VQ5Y6bL?t&)q!u|#9l7v)n%lzJx#U%vlK5} zT-!Pt`ar8N#u~<7-D&%WuHE)FlAGGRtdR;weBPDnOvPb%BAK zJ&oDjJ;~+;8K7}xMa%RL^fj~x_FMC^ZtFhKrA?rJGa6nFmSnXG&SMN^NrXQ;&Qi1) z^(%$0YF;-^9J(~4L6`w+7yiqRj~nzy_EU1Z-=MX!pj;=}#KPD4J3jglu};V9wl%f3 zf3{!ifuL9FHNvcUjdqoxzA4?_5mvq5)*rMkZ#(+7V|>XL%DkFbeS88N`Bs_6S&9Bu zdXLlwO)r*h2CQ22|K@?d%Mcv&GVldGsdYv4k0a;$C6jW?xFbXtUX*AsF7c}g0 z-+XFMAxC-^9SdN&`nSODkHhZI;ErQa8(WZ@ejB-TLsJ;LF6Vf1WMdqb0X$isXG2X6 zuA@*Slco15^Yy%;5+9>aJ!EaYu!jj7-`h zr~XXK32^n$afP|gE4AIdAJI1!R9;uj?`lwf0{1%#k##E z;giZnWrUA6mXFF5_or2n_}QVd4&nJg#Ll7fX~N#4g;F9oWOb+;ToU2{Q?S1;TJ#q2 z>I1mH#Ce`SAYQr*DPz$FA`|O;vEf;X?sc=Xt_UwDj8&fVaX!SCNfTnh3se)kWG_dz zX(2V-&o|$|m9WGZ?S;2!-~AOdbtdtVirmmyV)8UQCCs^-SXIbS%Qm~0FIwu2Qc#y` zbx9tmtWSn}=o4DoRWD2GAab4U>V$XpCvnsp5*D&ywGi>7EkM`}0Ob$?zrpRoKXy|s z2&)n~b#vd$m{(bO4rhVqeqhv3l-;T+CkfaxegMn7+Nt_rFD5*s9?h;iWLGO9A-R$M z4%x>fHg>_of8~p~YJw-31HabkPHt++BJfiSflTLzyqqYl;f z3sq*9wvUh!SBprsv+a1~vKtwH-)^MLmZO-b9~24v9b%0E@SJVD`pgEc!;Lyu=r_HS zbS@{XNe)8O=oyRUOY}lk=IaR92VZ5bSeS)8bq0p{vs0FKp7H-b^1CX$4)_`>>7%i! zs|~F4oeVlW2#XuhJ96p@X>0y(ddZ3|KGp4WKR+PCY>(_2VJw^o1{(FNct-Y|Z!CPD z!8ht(<0(qfCVnIDBc2seNaX#D&|rBCh`gW4x#ImeNxXq&OnC2VvA&sPzZ?l##K+n% zud?@ukK(1S+>McPvY8ExrFqIfl2))F&T1AOLT_c3=q-)8NfyE->SL%}ynw8aox%pF zjTzg)F7jt7Ieu3rw+!KlCTF2eBcjTiYdozs&u?3bco5Ad$^D9aTm3fQ zCfnbhW=9eqXTRi19|F8Y_E#AT`w+l}2w+RCBZdBDght6@ggmG}3zz8PbiJqKk2zc5 z69JeUdyj7w5+L2)#fl>mVq>A$4NLuhWyDs;No<=R5$Hg#-be=_p^h|ukVHNANl_2NlG-fq(9vyC_1gh#c#vDJi~ZydG> zj|2Kt6ZRI;gzp@#2@mX`eFC&mX*Dc7d<~bT)o{Pm(ED&ToS&*8uFWH?KAb@fo+Wby zq=K36ph{2pg#)K0lZ8ISoO_q+p%vc+@y`%S2}WFsp9RL|5_t@lhgTjKiHXGEG#M2F zBcG_Q25nINKN4vM+jxZb+y&8PRl^?y(#ym~tN*%nXh5!PG71sVSv+$Fa)b|HL1?9H zuSzE3b3<+us z$)N~h%;{@E z$|H6C&Y{xML*nKcG&dbLg)OsjQ%qFW#wnByv|(qr|SW+RbQSQGt1h-zx0 zBe$5%fq{RBm!3|X?39hAj{J%*I@>3m5}$Mc1OC?b+`3H-WzqW_`IwXn2Ar5D+}u@R z*pMc;xg&VBWVFq~r=^KrEICmA&K|JM%VabMZRQMkI3NDOV{V37-@+Gh3BZ~EKMgtB z_-+<#f~Rf|dxPGY!cu!sS2-UeQ6*bhkGa+p*?XR`Z~*kOa?ooMuD?OTV$UG1l|@a~ zAl3x_m=D!X{w#6^%;viCs&G#!%nu$!^RFkC<4=)&L5@!pbK`9N^JIw)TlVYESf&u; z?zLf$Ruyns9K8Fx?ZASec zbuQ@k&r^YWQ-O#Tz+3j-{P1$?1{4nsscdw4u)&@a^v1^hozQvnhBF2)cw(cR&2PDS zted~qu>gAV0!LBuJ-b$97~U5=k-y|{luEp?=kd%o8g2q$2|2COEm09!=T4mO*|kmg z0*%CTQ9!F}{Y!iIgGP#giJLO*Hm_`VoIhHx5 z5c*h$Y6vBCsF=`Ogh1Q4usee`$At&d-r(XbI>dUVeJz5&<>6j5Y}sd&2flsiqTvF0 zzEoIW98>j|t@5Q&zTg33^X^yYuaI#|%m!jcWz6>{t9Or)%3Nmwy4eEs-ad1$Fjp*d zP-l-;kDSo%11rDBh2i3!0;Az05IK>n;hqKDJ(0I^LZ>iyGDFAl%nlXs(32Uxtlk_nsB*HmFH!W#uh1)OWY@ zlx~0@ZX8XJ>CESa9d4NYI6LVC(zK#XqI6L#u)o$#(3StGH(3wEEZ0Cs(Qi$PbDeKg&iT#yyz(V z>dhXBN?Ie<7P3EqRNo+J?c>B(K4J4@G&21}aV7gmaT(@ZwiI*7QONePEOy|q$BOlU z+wyQUe)yOdXIn+PvQUF`2cOOb+Tv2ZJm!%z#r=%s%}9kK%H!v7v9A`j7kZAOH6#xR zGa`Ayn^2@uj_m_Lpk1bFMdqZHpnS|oymeSa)AL%huJhlm69|~jNz`xv=4^h_!koPt zbApT2H6P2?6=Sr8a&zfpvtdgYtL|EDnBR~5!aVFa2ciobaIrkNI3zD5$(E>M@@h08 z%lpt6K_r43U>-Ghy9fD0!gg@8EmKAVi`R!=Cvt$b+OM)A+tk&v+dR^W{GAoquEww- zN)^A5;t>no!#8Q|yi#N{p>B_z9uLTFE7>d;Ugn3boQu`P(gL$`u{Irh_>d|c(-uO{ zUsXrH{{fZ@DSgQ{b()?{>E0bu_{{ajc(=?jhq*MO3i68SvN(v0IUjjkhUx%>y;jUE z^;8`5Hw!xO-P1Sf8A|BV48MiMswdB_+-HS!i+ib(O_{P^u zb#J!W-DKAVUD~A1(0V85Rb*=%&Bl$AgqhKe6_!_*1^*@OyFh&=5@%^XZ@T%GQ;H8k zbjvuQw|r2$0khr?RgaWzsi)Xj38qrtJNU{4C_9qfr0CQLye6;naM-bMCitrB{FWdt zcLD!iw;%46!LF3{_fNIIf4o8xzFsxHpi~*Tx&hPnOCM* z%=tDbWPx?JRd}$QvLxVWZ$vGVL@m=*AA=dC?V0nitIa>>W2fA>`bx2YoLcf!2Rb@` zmq_i+F9?|V-`U>{KE4$XxdC%0+$eeX+hT(HS;xrXCJxM#B`oQI;^GpN9Ud;TYh)gu)y1s_;?HGhih7te8S8oSE!Nb z0nE9`n#T8!KVsqLv%eAZ^tGO)M=-jc$oga>zF9-Y-~x^t(57TlW!B1Y!gwOrc*0T9 z0=FD<{*)|hD&Ooy27jdaNN5`8F;m6JWi^K_!f5zR@F?aqtzzV80>$Jr_@dR@0%mQI znSuAKeBWn4L1bFHoqmE2x5#<_N3xs8dx?PKvJB^aCK!dE6UFjM03|l}14t$kk z4ZGES?=lc99hT5xx4II4)QL;&J{DuFQf?jgA^81&kpBx6rsulbY- zakOO-SVfpByQw3gPI{pGh%M`2pLt$CK1D9f4V@{*pr@u3N+XF?YeY~W@8L~Xr4(l{|Y3cLR!mhNu zp`N=vE(a??$f=zn+s)DCTHmq{{HDt`Qf1VMC#D}s15!Sl@ClIc zL%nx9Yp7W7Vnrn|k{5(hY!;nfX;9R8p4~3DYS&b}GrMKfjSfTmo1&_V!mn^P%pGpk z#}V4PVDQ&}NyiWIEyO7EU$D|xcB88YLmYN)k3~DOlYGddVrahP$?XsgKUpNcI_C(eu z69sx1Fa~GZlx#(1R|E{2v-`u9f6#Jm>c)1B5hkr-3k$@=r>d%HI z5tdXLK5ig5yu3uV!`yy=q~WsaE2L(u9omKMn;qIwBOi^B2)r^`7H{Si3Y zh#7U>NDQ3NZTtw%-@)%{=aoDiYOCHv2sTdSU9hndX-18Nqea)rkGW37_$-=75HpgP zWYN)!1R;wCTd68KQ(++NJdW1{9QR7!{8chRKW_|DWASBvzYs4=aFQ>Hz>Q5Q+<+r{ zIfWZJaQs?y_to*zcPF;D7{?y;Yi2Bxl?!TX{mP=vJBG%0|0)N|R`keq1UQHi0Tt^~zI2Da|0s;~1%C6P-Lr=0 zIu;4@oac*tg00xY)RCAJH2<)>bvKN{WP$_#=Ye@Ko%-zl988&z0db zys_ckNCm)3e~A_A^(^Ax<5BD#bnawPMrXcreSq74XT7f07g>|-tN6@l5C>oIRF;f3 z?c(8L&jk2y7K`=%JMXfxz;}VI>#?V%dayOIHZ?e3^Yf_fq)r?_@x22hri+td`k;# zZwi{vbij5~3bwD`+yUDwl0~=hmIhnA&lbJ(b6}gpCM6BFh{u1?nGcoSYTA3Gw6_Do z&t>~7-i_ZNf(yBdXXwX|qbm<`NEA+Er4BjHPJnI=O1*)8YcKi z{C*3GsDVD{VG`rEf0SIk!_IgL48}AJ(qflQ{5?;-^k_jHa?dni$1x@g83-HXK_IoE2{Y!F#jHcBETU6VmMWE zW3uS%j(oCL65P}^%bvgjr$Z-Lndm9aNPV^-2Rk*DgIhq(Et(inM-;>Sd`;vf+o51{ zc?y9+SiCj_IIK|7nwtClKK!*k_y2z2-2biMr_BAoA2j!e0v#Jx)00J;{;Laq3arlk zDX^Lh%b$jyz{=T~Z?HZ0b+unG_W{k=4$QiS6<{SOZDpi<3(61D2*2lDIzABF{3X;($18q9$8UaBcU%M}f+Xvu?N_st z%pofSFK?eS#vL+eh(-ZLX#$j7tO<}yioW_2<}RH^8`n|n=moUMu3`pF>TG^T$ST+5 zx`6y`l$N4d&simJ`%><&aX@xJ zxj#xPciogjHCV61dewz*q|p;837Qovs+C%73OQ1WznJ2&Xn|v(<*sDWFv?EkB#UmN z+{12}HEitlp1q2$jQt6f^_I%0)tN&;NM)=jPpTDyt6s%1nZEBr>g&Ot0Q~>1Rpkda zq^e{>+wONeM&RH;2QQN1Jxu2rJGwb+KIGj2>WOvmJJdpNrc#Bv0RG4>#&>6a25CEP zp)v{(?l;31W_XMO7r*|34h%cow?nNLvX;92W*nEcnrYvu?nHJc>(ew}bnG;rIl-mE z5)&O;qy4jvEmM$n(R)v_g7pQzg*uQ!Nj#|-+mx5X?=@Y?^9GA0rRes zI+`=+HM^Iabm!=8)Hh2yYyyKWUER5yu8z=^{NuW6;j+0Z5cL%YqHbtn6|~Xkk~=*a zux*i=7PbPuHohtK)E4@OY-X&90$ptJje3_HFm}@~M?wtR-9UTV=Pgk}W4=^9mmXNp zuOeTu9)wqjJ_a=*3f?Cy`c5lJ_DqP`MOGS#_*myv^F>@_WY z|6go=C(rz_0Ys072F4~N%}>I=*$#|CXBdf~nF~MnORPGH)=h+&M4shal!7(0lCx@eN{0Y3M zu+$h3W!{gD;f(P6G#D+|(I^Zd1$ zLEy>BNpBg_%5c@Lm6@SYber=rsd4R6G~?@cTn626b+5DT5JxUwBI|aU}=S>>a1aoR$}mjb@AA+$$dD&3($l z1|(?qDq*HXdvgGAroVPXLF|$w7YfAkqQ2O13;bCVTopHE-~N}1n_Tl=_j7cc#l8w& zG+FfAwOFjw4ljVM%<|&##T=FAH9_;Wq2B&j71uvx`YTq1dZ5~jtmx&bSUdea9y5O6 zH?z57EidY?4J;_2Q!K~upV!EqPa|`UFpRQ0XVdrfb}y{OjJiLXAwb0Wwdn(RurzrY z{%9_XU^)sNxW089BV<27gGscd#6m4h~$?Umw(NjB>N zxEX{HzS^q`yk?8nR37scFD^hv#q#R>v23#<)F=D)9GS8C zbkJ*>JBn3pm3zYYD(9}IZLKuh2klZndTKw%WsO0b!APTig&rO;Zzu}>k4(prea!XV ziuO6j`kGZSfq6$XtTkW7Wt?}L6sil9g&0e%Ly+viz$WG-R3m^k34L1UlHHZGACT_2 zFPV-3LsQ?BZIxc)sd&L?@FQqRuBL;szh@GyPt8I|$SXhiawMd4uOU^rt3}}d z7DDqjMi620nzb-Y`V583frILs|7tpNlEaGk>aa1D4;{hj!UD)mLH|Ku0pIdcwo zp__`G_Z*!pT0TxTd_hAj29AKwM_ArQz2AU|z(FvKa2~HK47c6=PlDkuwHl=>05xFD z%3B1GodERp37YO=f7ZpWU=|i}wUsyUefyyR>x%}T)Z?PTN@+Ok*I@1f-)qNq!uPRf zzDf9|rbOg=sR4_I?$+!wGhiaqB7C(gv?mAQzXK?81F_?qzt5y#L%{|iZD}~#X0DF5 z7*ur>bIFk4n75)mB>N0n}7+R;kQ^VssR zy=wOwDQMQ%@OkQ837S=7h2!Y&<8Db`#Xgk(NT^Wa9F=%at(OG4;12T<_5N=^j}Z_) zRz0B0WLp^NaCoER>#X=GY4IKXQ?*t-nicF69dv#lZhe=`Y0}U5u3zb<#NW4mEnWgn zcnUI%X~oiG7@u+MgZGLenSC*Ao!TwhcP*hAU#50gFH_W8S|>lcOtjkOYH_ynyf3S& z2Jry`DOtHoWp%fh65)u|)v^Py*x0E;g+mCQ5HlTaf14VRL$tFdQuAjA?Tpm4@zWlu zd7G6b9;s1|NX@&%jB~AabBQxuP#2`P|Fl&5Pqf>wIfVeet@TEl4MmoZ#*KtOb*Tl6 zoJgLaZCXq-k=u49{WNWnVfEZ1Qs(pOR&+m_!GODfg}AAhv${~XuW?}-O<{f>j-A8 z^CaI|xhNpJY?s$~^5Q(N@x+*(fv5xV)nsqfm*-tj)swY1lW!z=;^OXno6JY=0$=x) z#*^JAM_nryncc}dEL*u$!=Itt?VdyB2#2b-+lpSH>GXY(|F#_!#Wt@j@^S-(GNVK(74ow%B@;AKsd*H~lj;qwTr<^Bm9ZnYnWEA|P-uytV_c z?E zC2yVZlDBkt8Nc15LDm)D1QoF|xE0JEyGdhqBkC#UOQy`1shRC0r~_k+@BTMW3$qO{ zyC5C2CBd!VHu`!U?1-6Z#w}wCcwAM?<9czNnalsB1w6(T^SF-9^DP&)Vw{?h=+$LCFi!Op z7^mjyqL4cjw)y7A1qj4XGfwrhFY^|%PYV>f{mHdNRuRem&0EN3E>KuZOerzN5>sFl zV4#B#i4X zuI*Lm=d#X5E`~rSA)~j102Ze*z6fv+-KND7l+aW@QY9gQIcuXyx0<&5Y zSx5riW#1_<>Mtir`D|C%RbFAlM#@XYobDv!K3_^|-<4GtI>)msr$CI1otKIv2xKZw z7F{tJ=>>4AKZ`s#4>amekwBD8Er|)7W(^(dH-iJfMfF4$D$dD8Ztvx?-Aj~TXx&PS65k)Y!liz#&3SY5J*S@X+xvtJ zf9)Q2*uVtH8!JjQM^-=qQIbN%IW2N?DDrfM+>khYf;BaKwoN>OI3*1>F4l~kOl zkUXIq#Vz7Qu&z)&s3&U+Dvv%X2+Bko>1oU<$;KyG3Yf{WM>PcXZvwyw$2QV$YK{+bXx0and5HZ15lQz+=spf2*04eW3%lJi)L0jJQgQv zhv@M4PzH2#_-`yHpVQ${_jl>=)#=%O+nKGi!#}w1^E=!JCE3@(8JlMiyCKeOq-j%Y z0_OjgGzm430sl)N=7R`h7KXNJi{IR!)PvH?yYvYjdh0X)P|_l)S&@6{BPFef;FMe% z>?74yJ|P4%%hfeM5`bKi7sO2<#~YUL0UF$RR|(P#WM(ffz-uby2RJ?ClXFCFw0mW| zl*)|=2=LGmDEDJBRUax@ELkF}YOGaV^v_>g`|`En@G)rn#c=q^L2$U7Ne&ze{x5Kt zj`{943=$^YQ7UEd5%Q2P!-(N;W|Z^U;S11-ZYAv6-S>B3v$} zfaug1#hV{M50B8Y1|jH9bs_`j6+fU!kf6B#wBl!SgPasyzg~*E*D9JruS3)V!W2@b<`J-LjD3-s zGKYGwRJ>h~H80t*oQj7H}!O?B{TM0i#Qe@`f_1;(9= ziKrZu^p?-dLuLoa&4$I&=UDYpExV2dx5~LGI#XO}u2#3uAETghtLTYaCL1%hx+WX9 zH&s-&8xe8i5a7}{ugQft(O@0g&K8cP`f95RJTTN^-M|^xKrFkFO>{P#Sin)hMf8#% zSB;B39A;Q}z8>?+#kRWLSlEw1`~CR=U(%EEPU;6z=ZjqU%dpJJGpul2EmzJ`ic<6~MVoY*>5y5Vb_db7fAz z9A4_HMF`Hh*5DrT(Gaa%pnOk@g>|?e#)_OxrJ(F&3*}90XqvamlU!9vH6gbzM&AjP@oj+w zAWd@Fqt+rY1ZoB3E`fy(r6zLq4xA z9*wZ-T{)^Ygri1GS-fG~fabhFH0N7|9L!%OD@^Aqe)ag3T){(Eri(0qkykI>D}kcH zKV}7zcQ?i&8&s|-&v$4U3ZY{4x&*Mnor1ON0QGL8d~}d8ou~Ov_{&4!09x?BB_f1} z94ydFgY&&#rN{yE^pEWt2{>T#3%$n_&p40)4ui4&2cnY}v;1o^5Hyu~f%zS|-RCg( zgnFy~kMJ^U)_$X5K7_!$-52>FGtpNS*wLY0%1O|iHA{W=oBhc(?pe&LWCV9`cU?+) zHV0U>#he3X?oWnJ_19hjD|$tmscnX>n$JkLdz8&##U3NZ+SfsOR?&WIVHOAeT^44! zsn(`EKO(5Yw8N%6Q-xeil6Rpz*XTe8<(V=--HXNF7ZaTYQc7Q|R84e_B&>-}cLM1| zr{8IvM8`AGB08rF(Gho)LUbU!5FKt8!yaAT1IbDep4&PI&$I&x&jk52w;g%O3q|XF(d(X)+?8ffhm*%*sVvd|yZIDUg?ueJ1-X zy0V~Rjj?c$;0_jCfPbOhEt(?=pl~cwy4lp>QtkzecV%(qptrpk!A+!~sUqjt1MI09 zQ@5ZG^3uX>p_OAlB&3YO;8rzTmWV@9nd?&@pfX-_2o{gY+Xt%vu|i$~W}9`az19`T zdJD+4uy(1+KWGvI$rAG7Np2$3y!Bod`-vneR?B|LzBIW?x6fNKv1Dp!TwJsujSbRD zA=4bOo&~ooRECu-jnHVS0-+Ho(={P9n!c0~Xwg=Gn#kze=G3H*$c46shFO66nN~ z3LM?uaRjpxnUXtnsXhp?QEfuHC?4HK=93sA=*8`=&kA&)8~5|HAfRz;qR@@!00wkp zi;x^3X7#_C8LFI^2Uuj|ddS8!Asat|>xOK|N^}UaQGueIVOpSm_}>yJ%KCvO8w*tK z<3bZQ*UR&F4520)za$WdGFg}D_>HmuP>e56BR(&swV&!ZkCMK(j7@2Vh%|u$^UGPa z;6-=J?!nv{`j$EdDXG_-1p7Ak28O)A5eg4ln=IO_uXf+6J`oXM`PhQc1kd~ngQJJH zg{~klX87~Z``zV}S7Wjk=wXbZQ`p9}Tf0eYR z6Or&^PH{eqeg7To`>%xWVRS5l9~i^KE=-_-jLR-`v&WqdMiW!ydEei*|y zxi$Dt@ZuwB;*%Y`_?koT;+MmVSL5eN^Wtkf6|0PevcV$X8jBZiGZxDHA!3uyyw)X= zzR1dVr6|mi8+}=?MrLO_LT3bOZ^~BhF$4Tr&xMYyY0BsA~`pdd*)f;j`C#R*#y-;j09Pd&=$fsIM*%8KU5@ z*GAzX76ymT)pSUk@lYgZu)P44?MDiKCkiVL8CLJY6hIIgGN@Bbg+M=c*RQCbKMW@| zm-Y3#-S{HdKLFB75*&SykBhQNxkw#})Br?XB#2s3FTMt>3Jzgun=BD_Fv z>gi$)q}<&>%IiEr%eM;{v^6%wT>MXpp%OLL*^OEv#C%2_-8I<+<8qSS+fp@8L|b-* zIo^u9iMU82gM+Q&m~y_Tqn@6u^6(O!elmg7Kq<_Pv|Zj43Kz!s_q~ z%oz`vtm|PKIYEe;=lNWCUX0_$m(V~1@woxy85MS-Lv(@gXFn2A1tc}*yGU$*DU+v6n z^#&hUD04(Nwch-wY#a(W;rDlSs|$7CRq4PZ^&`BJzEC|TX_0K!j%2xP7meLV>L`{l ztwpI6EuODpXJ}OUglrNw93pXCT2Wh>&B=g*Ko&D#L;+kH?AtKoiC&I@>+rywY~miq z_mG*2ljZUyne~-;g4)&1#rZc;&=JfC9ZfJ>g4vvnsm}>z*LMp!#7;ob18)ot2?b^^?SU zFxcSPgAvtns8rJj!^L3i(VA@;xz5DbNHe~|U<|beBZt;Z~S=7}n)-+KkvF}z->f!5S0f_W&~fFxLw(FFOPX~OG1I&68eW2N^+GTaU`#gZ#TrXk z52JoIagk^A;cmG7o2?YZq4DLt!+84~QS6h$((BdR-(%SqS@2Dys2Gkc_<91Ii4yBw z^A)tgY6MM=pH3`II>Bp>F2f%@88jzWF^U{o_h^nDkU+qPu_fg`uii$e6yL2|ljjHz zOSM{LaMOE5W*2h-u6haS9GsArzZIuaNWY9bo+YO_JSCA66tv(H{uVIFnm%Rzykbds z>jdasX=D}`v{$Roq&Ral+ezec9Kp=m9C8~^+*KliGB`yv9SaDd%Ms}sY7S9~EFwlM zSW3~8Lt+Q``U6Ws$b-t>fIXJ_R}d-8$WoZGJh<2NttS z_)uMg-c0S34WRi&JwhjY%d^1b*o0J2^4=Aqj{$8tAjQ6SW3#yv_>5K1sD>fRj31rgj z`O8Rl)hD-s>!%SVUG;LP)1D#aM16@;IxOhHKP8 z(_^bH{CUv2g^&o3nI2k#U}+ZZ>9M|Jda%t%7F|6&H9cCb{CYb=Zo3=`u%^d)riWBv zO%K_k3`p41L%a{x@d@+zV$9>2d~%hQJ~26ArCK}p-)({%W@g66F(N_-BJYm%!Poja z7X_9YYYhc6(1%F>DnJA#Ny6|`Ekt-a%Di%TJB zW&XeS+&hz*EF=>qO8vs~kh%BVbI(2JJ@0w<^PYkp24`hyBwX;k3VdE0>0Bce7wa%1&cb<%C?{X#ghIn#)J7MVWj& zi-=sZV{kmy;0#HZks)+4d7l?Sy6rR2{?+&%A=!5q%5S)WeT`&Q3=ZY2T}Y0e>l~3~ z{(BM7=S(*q#*cVN*hds=O%HsbAcJ~$sd{AnAdjB9Oq%^zJgMNS`euHY-)xX?c8zPa zyW?`{inMEe6l}I&WWlWad?X!VN?Rejtw3vTcr{{#8V=?Dgz{g<%h^#bNUb)=k6;@u z@R1#~3W+DT@5QB>S-Vw}?Z{)yGaym}A5F8|B)vm>)ZF=wC@oZbFICBA;-ka zz)H4eaVEvfYJ%ql_C+N{N&dI$ z+-CT-W%?)UPWs>_p`);waguSip+iqyMPFguHSzv6mYW70g}C zh1Zycy#{ln`G(jv*?z1C8i^!-VvN{ZG}` z=jg$^R3}LsN4XMbNJ(P4SZB353CF@!<|;C3bBx?bzBhCMx91lbm*yD5qlLfWjCVKkJ{>1Df)^BL+?K5D zWg*l`v;tDr7W2C>c|2SGaSi8+;^#jpu!z8z5;U|}+|2^^hY-YfB=$B;=0mKWyn^q{ z{2DNm^owR47vet=!&{k7T))Q{q;JT{WUbI&!TLD~7Ab|rg2|u!KlJ1nmR*Lm_d(#u zYO&pnpxMt##DL@-eZ8O==0W$;8TIbbGaC87l>c|}{~rF|XZpnYXt>b0Km)VRx&!x= zN@gKmn`*or-+=jIAY@_U94=-_^@YZyg=%ObbM(e{gcK+x8_h6}V>84UT* z1d9a-V6pTi!*`5@J3mC{7ff;OAB9cMniqGgg~IJ07G%~v==gsj4xqZ}Z#|>#wJh0o z)Gg-o=A%H@E2#S$G3NyrmYP4|g1+yhqx9YUCbxE^fnadMTEP{NSQ49FbLATI*EjVo z+Oq#~UecsUzTsA~5Ig%>F=aWuX`n~(%+S7&3Ke+bB}AKg_rE6sOdj75K)$&E1fOEPArMCL43<*?vEiT-Q#5*8fxA zezrrglB%|Af#M8pxe)g1%1r+iTHxlQoF|1SXe-5}=Rb;VI>p-9)vWvlP6UfmPo-9B z40XDn2@aJvO4S?w(VF3*+EX0LxS-GzxVbFDKis?t6Kimx3x&NZw$*}Qi7vNGbsBlQ ze4!a_HAbsB5l&%jC!{ae9I4t}$f8q1N~adxkTJZ*7!@ zyfgQhzo0Fmb#o_&a&{TxGnKdV8wq8B+cI&v9&Ij4DAQ+Nm6>DCmXho>3P_Nl%L$^v zN+~_L&JQW7Nq8aFNM%Bq)yN6$jcCiW>60SL8_j>t6W7$!W+swF1oP<66h{!!ThCC0 zQqK{BSt_yseJ%+P1JdSWko~~IvW!K!rsx$>UBKXT0D{FO?cG~LtO+w}Z<(!+I>;cj4kyY%WzUaT1;vU-lwFy zNI~FdB`vgtd}5X8p+;3;$rwb|5iQhSQY*1`)Af) zg?4f>V;Nhd?Vx_^mCfd_c)^&6=ZgSwd5vC{sb0GAOEUa9 z=y*4rKx&FEe;QNhmH_TprQbn8BL(gE7x0o$0aW@J15tW^CoYoM+vMwZ-lY2ap*e<+ z1{M>my4`oEc`JSsArk)6jcbWekT}&@b`b>PYA%iG3(aZ#+5{rj4b=m4-WT_4RVHWP z8p-LzQ61RVAQ~5Yg?IF5C?!d5C#@=5?1>@{|H)EkBgS?t{mt5 z`rX`^r{5^}zRhD)mw9K-80HDA&GBZxVUB7qM#UqJ^7J93QCxJ1K6AYu%BhzHJ>6{k zvaqA8LHIV$%$yQEyUqLxMG^}+UA%KMYjUW3kHoiUZ!{ag0(ky#ExJ{{LUW6sh-7Qa zGNbFO$bom)O-g@c3#Zo1gwK|BYbEI^j<1+CW^vtqL7F_dUEIatR3LCFQdW=hcO;ItZ*SRsrP)VTJ#aiyv#z;MMQ?73C zhH^8X(EFyggg-<&kbW7fIW$_2?&R8Iv`GF85`Y@5p6DBDBy8p{@`gOc#?%}PjnOd` zL)tUh2d9X&weGQJX&|%H|LG9FS?x zy(OI#vY=pN+49)+Zuw_&&5w`*<>c-vvBSm(ZA)_jW^+q>TRoy;VNdb}dYSWISxAm~}bDag*&JhHd zPeGs&d%Eo(Gjg#MSP!v&PvOB;C8V146bQWIgs9IO50i1XObi_}jF(YjSmL_DUf8PI z+yx8t%Bi^vZt}=^c*awnv6C?yuhy$J-hK*J@+{{FcS*6Q>Z08FQ$$d~49=-u=D4{s z#aJ4nYxK%VxeNXlIYl#eI12__)hlar=aV2KUOih?_fmbcUU>o4i7m<|>x2x~B`Z%C zU7(9(80~1#>8e>PQ3;xxGh0lDm8zLD6eX_0x{>lhc6kS%T)RV#R>1_Qvz8lnv&lp5 z+il+MI8AosF+3*MfOx(`un44=$ID3s{o8I$;_4^W1 zzSNJ7@eGPD^Y;8S%BO-Tidc)7?1mKru|sePn6J$T<+hnuVULlhG58>K{}63C8b*fM z%0qw}bG-DXy{}vC4U_iT-%S2~hp$|j{1xZ1F7~p#jp;JhUs0y<(jsF)-lWqf${S#Y zi=O{vT6@p!ZVyRr5V-X9AGjP2%~YUePD$B^gRtFqg5P8g5B0$DbU2B$$$5!Z7JtDF zas!RdP&9^Xtj+DulG-ZirY*rGVf|p3bzUK)ha*AJ3SdL;`n>W1xVT#nJi|%l8|ufi zdyPYHFU&L_MGLmh!SP{Z8^q3a%=8=0zt523HQM^~b8!R@;sgw6&o8b+QYAAZPUo!k z6NEh|7mP48R=i6F*t;CR)|jM&P(mN%AkUmk+X5wZ1bs53thHi`fJ}R>b*9IYV*Zh& zk)w8J75E_VdE{53E&4wl66A743)@D^(zrzIubioKT{d^%NwFlBbdp=d?*J%%$CDYZ z?_{n-hvBI>XOPsvEMH043b8uLI<1h`TqM=bjusv!tqA!PdZJ>HdQVSeX)#5Zd<1(X zjZS%sjp-nAv~Xh%mV{KL!=vCYN@52=nT#(8E%G&cs*^=N zL8-raq31PRyh1`iho97jdaf37{U`D?_nCeN)HkwPH*N$y=j8?#=8%R(HmTv*!}fXa zJ!)j$phsM}jO;1@`wbOr`D`(6E%4paP(d(Wi|@vU3WWL=-&GA2)Nk?CG*sLxzvnho zd_#Ue-%#;Q`7Lg!cr=UO5e*fO@oT)~cdeA|qmeULN>E?q^DCR=r*vhr{ES}NC_hK8 z6s;uM%TuP9kqJ{r^Y;H#I)`G~9GE^$e zd#ToQN9%f$@2ki6@mLSum>bSQ^6x8AN#Q*?yI8PE9Vui!PaqX=_l*Ft^8)AmddXmt z(dUe7iDW$jiHVbGyM5MS!`rpcacoh4`)b@44?kXj ziH1DjU~V(v4UHwIQ+X+8wZh7``Gz@{WwVVVtB%j_6e9`lr^b?Us&Fa=YlvVP)}ONM zkR?m9)T_p#g|Bg3yjU32r?D{HA%w1Bt@JHf9NaHtY&j&3@AfGKP=g&7cpeo2v5g(d zdzsDh-Sjd)a846eIEvn+NLzJSHqZ#2vWPPB=%c=lKO4S^butG6CHob2QjM^>yQxqY zJma3gU@>EA%X6R~vO!`L1JOc@{z2264dOVLwfwzEiWkMh?!8K(;mbZE{1}$)Y)GxMjgl)#B{c7?z2w5Q+Cp8*9c{R0J3?J z)4w?B^-zqD`vv>~JS4GF<{CNWhgrhBSz|owhHcNN5fjMEid@%-7DING&8G3y&iybP z>le#W-NF1->K9ZVIa`qFS!9)R^5~zZKfh6NR*BPae0-xkYvmw>6)t8X@Wy##pQ3_C z)QtE)Di~5KMe=}oAuI951q5>0x#i_tpTghK7WK*tm*2thsPZ8>qcq0Uc~=kSf1gLH zW$HIjA3v6Qr77_hb*M3<1<7NvBlq|CR;dS@OE9DOlX#|7}+?A$CocKZPRd?K4Vr2Z2&#M`C;bO zbSHG{uwX^x^b0~cZIXsZnq(t?tVQ!Jh=>;0m+2p6)VQKx_9z$K21H&N`U#-JMB5GtL)93-W8uyrX@b7Hz)(OJ*UCxJ1_;;V$GM#MtwU>woaKoQ7TI}l^Wde~dUTC*)mao1)N>(hg~f76hvz(W zHSYEuO)LIKT=n~keS`R$=l_{BlDB?hG$TSY&$!0zZXPVVtX}{j#uxi?#^=eVq7BW1 zBkxMF>}05cXbkoQkCD!KqB$i>TxYkDgL=`HW@r80t9&2S?>)|6*0|bVBwrm;aUtR- zk0W{I&r!f2)<0`T3Zfh3>x0&3U&RRMFjVAi`MmFZD*1Ey{yF3Ge3by>6g5^g(&oX= zRU6G&7qt&Fx*-t~GVthzaGe-?t=2QF*2Bk9B%Npf)aNp!=RyKp!gL{0L@|lxG#!dy zSz)e9U_w1D?le8eKgkAi#Pd05CJQN;|W`v&nh&;Pho9zxAI`y>aZ9znN`sMzdipp|MHd`w zcTkUJYYIn<^`x?-YP5y)>Unk5RaU3IWbM!=xJm$$4w`94ow|1j055*dW=7&&gOzExksr7)OrMZQKPNJ;@!YHch2)#0k^1 zufwOnr2zSAj#CdWr*B+`e~HBL72tfbD(KYRPTMp{VzhiOXAR5m*2Z;?`-?L|z zm%GpFt*>X-IDfm5k?VW5d8%6HAMMHBq*kPPEG{KPCA_6S*F=)D!b&>Yd=jy_dpXA0 zcyYTBbGUgS0ScjO4@WeuaKoEF3ZKDKGa#16(5RDcO%_e>q#uYe7o#>H#tf66-ixO9 zx2c>au4K{l2jGM)niiR>FGQjm24O1SM2A+m*oO3FAl99jI*}HYNOQPR?Se}MM}21z zB8}s2{+4fwd?`^r)d8H6WkxFb^lI9U37S*6Hugo%+pn}*rP{P5n{nKjMU0j&G*z z*c^X_>mKL$GS#L%$JcOUo|(|ZN$UDjndAH)vk)zvIGF$Q_%*ue{pZ+vs@V1o$K^Z| zEw7U6G4}Q6^h(EQuKlvte55&!d51ygnc5(^@Uw5i@gYc{2OUSr8=XvEak3(Gj>>y@6}rQRXd>1=a7ML-m_&9*zk- zQW17tHfZ;EOhQ{DthQFg+L~tdPukjd^M2bBecy@_AdAO2o2abz?q6t5pGr92V&vSI zf{ij2t-@%A8TT~NjK3rc4R|^5Bt(V-=0|y%pC*2&`#g1}+Gc(w!bKbeQ1%{#7`5)( z`=iDBGua%&LQm+5FR?4*Sd~d#8EJJT%j$}5cg2-bSGJTt7dcL=Z###`+)Ul+#&*3; z7#osA{rF7rnxOJ$Z*(_jR+Bdq&wS!OAVDr{XPWVBJb zStmzwZtL8V$Pt}&Imus)sq9^j_A}NuA08P~{~>+Fg6MSP_}XaqRjVJLk>TI%iMDvN zTeRka#^?Mm(essJ#WsI1BM#J|%-OML!;f1cbG^p<&4W;cuGLAmuSeI_k3Ut7cis4N zd}mnx5#wp|3+m-I0Ph>40#exzywQB@eBtSgW0EI$t|)2drb<4N{qM*_f({X|hA%xv zStP{8L-NoHE9ycQD#ME;$xMnRbWYhI&3iHP#Fy>?T_{|Wb81m{BvvM7BbI#7?-)xAgvdQnp`evHv!&?4r#{J+>LXANEbp!>cd`@oVEo zk{=cPJm(P~Vuj2aIbu~NR?RZ|0N8}Q{4N`9E66ar)k?~jD^lsy6 zYxsae`4gs&kHKJL9P9HCcWfA(%aD0T#w^vXagUOB3>o)m#$CZ0VQkl*kvMMuz2ODc zn7x#Tzm)QrCEg(~{Q7i32J3noGqYt&jo94Ov!@ZfEzq@>y)`LTCaPzQS7bpuV_Ii> zd0k-q1n9E;z$HAdOqX3qxMPU#7Sj;J)~)a{wH37L8Q-zE23~*d$oJ08{RI%vjrGyO zQ^gA%Sc6yMFaFnU$nQVAC53Mt|9tJG-}N>K1C|-UCbuuEOJ`lPU}4v23mQotlRHERJ*ZJh^^t@UyI4uA;-H3*RLjA??||Q zC*k_p_UjIQua17OZsFY?zY=y>%R}rWNj9GcPwRR<#a1H!E&2Qu`XXFHWbzZawq^3O zNht~`$TK}8u;#JI{aI3Vf3kB}T-(uC0pp6&uRGi<;(8 zGUKx`A^%RfIY!+W`QMeBchUHCBY%osc$jPZ8<)nu z@lN|UzGZ#mhw{_?H^RpIRt(yqG{IL1^hlNuK2-8SHXZOu%!U5)rQbUD-KJ>aq*5~(ZcsX9xR$7x$;%JksYzj% zhiakx-%~p>EU-7zkL@>qEqCVknFl5&J3zeKp~OKf+vAX$b3Slnn8%^&QnYrjDtfq$ zBBvA?6LY2d@b!*&zf53=L>RB<2XW@gHRe^P^mS(oaCj3Awnc?aveHSWtRO6NP~Ot8 zS7ObqOc%-d8f^I9{%6M66?|p=MhmauFy-8eg_Rbaos>k|rPlM5Eh5ba)Iz`7sdXustG+ofF;D zNcoO=-{-CHt)p(xjbUSENDuG*BY#`p%H6#>)8AbyYP{`oB>TEk7Wo1*T_ttNcroOM+?W=13QG3b?X(^eDBW8p9omC;7(SR1px;~3;(lYaE6d0 zRzU}7CEv0twNPzVxE?MjPl$o}@fU6Ssf7LVO%nGNo?$;137>+@@P$@E?0uL0+;Ci@ zUKjWf`*Myh-Fntr>6k*XZ0p^)+y#W74`W-KHxh#5Dc?p2#wk2i&^CW{VoW?w>Zqa~ z;g>-@vDrwUGs9cdT`a!emO&s%N0__OB{yV9*o*nv*nQFEaupe3IO-q~!Av+vr-_yR zh8i+jqS0SP&x=O=hcxWXXkoDoxikMXUc%r~X#S|Z)upjkJGT_G17Wb3!`fO{EFqS0 zmp&1`Gxs)pnBk)BGJfm%E#;R@c|=6=%a-0E`OV7k6_}^SzZkxQAq1lP{Q2fcRVX>L zA~!c}T6ja%IX5CR%)6TGDqdrcr}dwMyrD67eFvUraYKe`a;Whll^(0cAh?~22PCv+P2^DXr|~MLagwqy%Hl`$=^wAS zt;60{QXm^r|E% zIlBJ!#j0N9koKp;t-@Houft{fnOo7?wuKviO??+uK%5Ioml7L zg!07tKaZEw4@eDbt@-r$TAN!MTWbW?JHA9+p@c6v|qm)yY5C7%sg3%9Bj{Fe)7zfSf52A%*3^^ABoVmJtfMPWIf%E zZ23C~10u{sS}V{E800r3Xj+o_+*e$ zaW6A*0#phmZ`4IlLOpcGZ-f(p1jVd|Nm5j`-8WLNESIf2YRBFu|5%e7d691K z!_F=!;1Uvt(%#`j@q;Dm)^TJElB1{n53yZLS$E~*)cv$dMpXg9clC2zj7^psNc6H!h?M@i66o|g#XWVW~8`kRw&JTejctq)O6sr^56 zZlBl$$s0qwdXenEE(-6VO&bH+=UM4;R@${4I_9?HncS`CGocA{StrIPYc9p)_BU%O zGmjMlwC>znUFlAVWr^2no0}e#^plvHxG0v`iQtH2ZOrO?;(LkLv3Q)svhJ>9byN9n z{GASQK$iT;_6O;&@ti1+41f%H4b#yY(D~MDMMSGVrLCBzXwf$FwPRGwI<86#Jt9+D zX1SQZ2h;8kU0sT83IIuVq#4IDHJvr1q&nk!QKzWuI;@zA`kRZOw5@)o#8a?R#!v&H zf*{K9pu48i8jgdpRCFH73+Ht+lw=!ayUi@I9KCTJbd$A$DjHj-p@MGMyJen2cO_2oB4~(g#+ao{?4m9(!b!QZVCG0s zsjQkA6fvEGl*T0FPq%FMnp7+ouH`wvf{R)FpJR&cNfyRJz);)Wny{B&{3kX~FQbr5 zpD3&DP*DRnoA09wsU??8lo;z{5LS!VhYH82R|;3b)_rLB`Hyj7E?2KQe#JFiiA68j zYbP&!jj(VFp0Jhh5y%ShXO~Oc6rL@0`1Q#BYShqJeMN3<_{aK=mDI9@CREmh=$g&og#A zzDxU=eq#MCVIq{j2v%=4sMj2G72A*T=c}kHtq1dO0n~~=e~Am=3a_v~Ql~zmzV~IZ ze0Ag_@yYJPMKYZR2gT+l>#zoAx1`EhZLdSMF3qMR6=69^H!jZQ%n&+=liK{6Rmy?j zaNhM3i&#p+hZPI%M0v*GY1)5B)x2|vIvv;{9Wbm6nR(V%hNus8P1QCbx^!+^aH|_z zequS`&b0pb!tNf!O|j9LTBuL>-u78yJdHYZxM^4Ph8 zg}d10G;LlPu@BYI%?xu+k(4U8=TUm-QjR%A-+W43#82`B+Y~aO6&%<>YU(s)bIge39EmhsZRzzlrrZe zRb=CPJU)SsA%AYy4UF3Fnv2i|%HIJrH|U{2JwU9hEcG45`7WN^K}e$zaCfLWOSX*> zmVd2ySV93Aom3k|wa>+>S^J>vif2ki3&yi!8n{{;Y9m-INC2ih1SeJ}sCHk_aV)V| z3wCyC%b%iK_{EK|nTh>@JgJ1nRH^+&AIrD`Rj2w-^M)p7)m5_>^@NoL6zZXn48|Rr z95o*}Tu{W>6qd^F;1kF2AhKFBqT!!X;ticXk${UcaZMu+x4E2wpG&E+F?5+r9kKAV zd8OTeWJRnC>^qfLCF(nJK_HsxFOrw$`6$2E_fah=S7YSL{V^fSTOIhIwA=P zUf*}J-)nbFbyAKAG1i#>DO4z2BNd#DpTn3>eP`n+E+K~KH@r`-60J-kLf51;H8iF15Is^u{Q7@~9U1#-gWbJdxEd+*d|S!}YauJIwJ0FvTtl=;Pji%27(sq7b%3;5LwoCOn# zxo{Ob3nr87aD-0MvTpOtb*m6_@Pe<`%68xv|t z$5<=ryUn#M(=OJ3r@?hm0LKys4a)lmJ2Ka>%+yD{_D;HDTEV0;( z5holbSgUJGu_)3tX}&!<$(2{HsS8w2^q*{P*BFBt!<{YbXPe3^{5hc^P)29dkHOOF z;Hkt(M1EsFcoa=JzAZo^=1aFV5I)cPdP#sby}Egid+BW@GjO^g)OyJs7phlkOGqz~ zd-f*&NRFnE6on@oViBDxJ|SUTWN;~udZHWZCRC2Um2kU;s7%K^uiA>cwr1>F=Q7So zTBgoP!ot#GSy;f~tqO9m3u<~fPN|z}zoeQupCL51;3=tRccYLf^JVBYJmBUg5|C9> zsxs2a+>!W!_Me z6l<#(s*JTJH0(_CtPydj&Y&xv(BjPSYcfgdlOWdfWp)MMmDQmd7Wiyw30+}jPC-Vo z(6&cGGy0J$S}lEcEDuB8oy%GncyO@QF$H^9_{|?fLKw^*MHR*3_GC zkFXAl{XSi^hha{o2V&(4Qs!LNRL@VH+{>vYUZZI#KX?yY6yu!=lYKVuq2Eu~<^4-| z5}KgOCsR&lP@n%~${RbC*ZB{t3p^qA@(TYDiPm&B)^lT*o#G!Mv7YkCUHP!&7VzCr zWBgsx_LPbPWx5i9yj<1VlB%4^rkk%gt+Bqx8y;hA_&?Y$v=u;^D3D|*S`%h|nN`ti zNZxL@{wvzkt*Mpyc2}M}$InSK0F~nVf5eYBo8)IWh0F!K;%;UmIJL(5N@B=-luDzb zPV`%&=F1$d+V)Q+{+E%s;J&4iY!;u~alX%5d100y)f@xoh};lRKBLO`)Zp>N8z2Tfh!;KsZK@#7w>z{=!%9DI0}vo({{ z2mZrVVaVY<1)@!+k3r_K!>MY$btP0(4^(B~2o}xWJl$$#sM&~)EXp1teNo_M&f7c$ ztLLwTJ*g&q$c6V*9BF8R z)fGrezC~sU)>u;vp}J8G$>#h(<8HA}L+@}pPs4(iD^DmD5}@NV!xhcuYdVI)1@ zitSVFyPSn_#q#U5JN4L{>o)en?VWdiMDJNzA_48<(jB@XQ!}=NrWKekjgubi0v!GV za~e!yLx$`&3X8*78GnT0|6WxR9g9k3?Ul%=lCiQ>XgZZbs#2R&$~T9`D@9N;3fG>- zBr~7B-E3qfI9gPT&1N&`A@fjXOc@5-G50b%ygeF-xPvF?!9lw5svOQ>e5?o0XCiP| z{aZK82!@Ky=2_}UXPYsNZ$5tjw-YcEco-jp-ly7hOH=Oj(Eco|Fk*gXa$22(KS`12fFPIu)l&m{$1EM z*B~D54?|R*AikVC%~}mJ^uP@*2pl(T%m63mA7*|LJ=_+vFJztJO#Y&|>JUH(+M1tZ zE=-4rP)0S`jA}TosG2~FX~lxcfu$nE7uaDL+xXqcOFUL#8aw%I;ojsIv{d06nEa~S z%qRXK3xJ1#wKGz}_D(wBCEB!hJ#dFg<-Ot;gCI6v$Q4-v)4D?GQKAIRka>rd$kA^o zq;X+zjW;wWCs@I@+|PMKw~`fNu=d1M#^p8g|4fJv33EYjk?u-WQeMYkf_&^Vl#5Lr zRz!-I|D_@_q)Ffp$JEM6Vb?3E+1VtjWQ}oIG0l2NnMmpy=Q3oAVFm87t>P#{jN9ao zfFxeTS-!B=`kvFhfrcRW#7cy74inBWw~Ur=JN`%Fkg81QUALm} zp`%_5QLd2OT+r7;jSWJpvp4v$j!&sD>j4YatTGY%4>g|Q*^umK)Uz`4dY*ZMGcgdX z=ZEjitMCTrm4;hHK4(O3^=`LKkFg%pbjQz@nR)8j#97k3w9S9oo>>~cUNLYO_4V!C z`@PcrBlP}|Jq^zU$BGj(FE+eg0BO?=$MDZVy(|ri00@+lca$w@L$w17j@H(4rur3#7O>{P0ZeQnI>ujpw z8iINEZsrzJHv0%kaVog%Y&=ySk@szaQkJwLa~+4M^pP~bm~#pDXwEJB|Pif+ktH4gcjvq?^=)I&K(>E{gM${9GEzar3! zls7xar5P^>xt3Kc~f_;HmsHTiZ5>xQ9{z5RXVP=JRmK|TK0zSDp4w;B%o3;xRyIQKL|{E;4acJ2HNE3(s$ivt$BOmFSQjqm*Bp0z7b2@^hYh3wtNXW!PHQIg zP{}r8u2AbG?G9__x#R4$(^Smlux`9Fu|e)Nry==pBmtadjskGP42ivA2FM?u9J7_v z)T=S`$tuuPGk>w1O09pDrB+oc=CZMyoXbX>&kW^hW4Fl+wc0a;&@)`{g;|0JTHB`F zm4~6iU_|!AG&0PwS<;)G>H|9kEe$V?su$p(y4aN`8+S!Z+l8s;1Av2V0!izj%ODwlj|xDNs!I&OO*axCcRI}*cM ztfD8_BrnG*qg^_jO-tlclZI7?^jom|lrbJ*UuW!chy$)v3r$_3hnk8hF1L5gJcJBo zY^CY5?FTEPJSFYeXxP6iE3kL*TvWEg<3}^ip^&_(E#D^~y@O#kwHRB;<)H;bTj&Yj z)vP{gMw1i-CmkI*8W3dq^JMtJNrw@j6o@+fgRR@5DWROj5ToWUz)%C%uzqq zjU0ykOtkQ8+az3-orcub6|iG-WZs)8bb&(v5KLpRHgBVlGB+?*h9W^oAtKkJBnS~% zDj3_aRuDIlh~N)gQOf8lK?F`S0NpCslmQ3Ll_+5>MBb_jvsiu5TUBNr&Q-i0c~Tto zRh3Q-K59+)hMW=sx`nmD>#Hilb0GuDM4pftxlI|4Xs^BK3~{@>u<0>bdWHc^<*EZ1r@qs^u$-)jC|Y>L)zL>h+6OD|p?l z`_=S-J<-`(^S@oq>mv{utDP+Bso-a$<_KA|zXsT{Xm?7F8`jEXCNA23#o(SB7ey~{ zOF@=zunO0%SmQOwRNc@jb4c!bWs)$D{m;iDn@K!2>L7wJlBKm%8Oy-mM|DL3lpds9 zqqGk8z6>k%V}vG2O=!YCJW81hCSYMPueavnOfR;Zl`df8l@P6G%!fWwpByXYdgyK; z*E|W;PBXt@JsDw#m@7XX%F?x+15u`Q*|W|tQGJy?(nXRJ5Qvn;`y6&Q{en(e+cqmN z&h^9ehMK>%P~l9Sb7QidO=3dz8s+6t*39XP%x8htiYR4uRqrmi5jH<3urtSZ9T~G& zlG$@P=SYSWs#kAit3jJje5i(dQE1^b<0YIsnee*m2$HqMsmyU$ewcxA_PaJXutbcs z9*k^<20)%I;sg34Irln45@;#mM`NIT)hBPPC!scX6QXKkr6&ZFypC?Sagz zwl3(oEo_*u`L5$bCkc~E9=g~(#g4Y$eQ#It-aWjSyd_uQq#Z7^(?woao{j158GAr~JK|auVQf^_0I% zVp;w9&EBfbmia&*``U7)!nb~uO~kWqe55-kwaI3$Y_8mGdeujBk0AyHn=gjqt>yxZ zZIY^Fm%04kA4?`goMNF{bF}5TLL99+7su<|XVq~wKBag;;f3@LN91c58TNUM-N;3r zv71m22kWijZ2H8vpBCd)fk$!#?|onYjn^nVl9#mQE?V$#mNFZJG-EaUI>v7FNNl4~ zpb@7k+k~F;NEmBjtO=e!qnD!y1LRw1uJAXp zr|z*WVu+MYNSpO?_-*m8a$Q68P-WjM z8=MhdCi5i!tg=;7_S0CII*SHb3L5L#FmV?aIAV<^a!Tk#Q>kbe3TpX3ow&6k;?_)J z){2Q&D=_~-7wWG1}U5KS6=Dcv( zz63ECvG%LQpRfy;gw-XKgq`A-2#Pmur+J8k5C_(}x^^+ZH_w1S>Osd=*r)77vi=DZ z0zkj}JVC7QN^El|f1O0j5*L#*!8C zwW`g&Vdh=(9r9FD-c7Ss{Iiiirjl`9t-6(eBG-Cg%m{umOpjGI?Nn8kugcD_%BEUn zmHe-6tC~U|k|0uW_jupe>v5=03x$co?#^pQ}8(N&O*W&Z+wOFm1$PPRu zFewOpnCS=4$|VSVs2TW|0HQpW0|0(wiU&C5(uGpIoB-}4*!4G6K1d30 zzA(fbt-erYHQY^`df=RgK)CkvS~}*z2o;{QQ-t~aGymeq2)AO|R)7<{G^b{RJJ=XI z?9Eoso&kRnfG%Z?n|z1!z47urpTqpZVQ~z_Uhxvm^ObF{@q=g;e(GIIKunk>)$TR$ z(WG|Sz`){Jz6WS>Mo?_OpsIU^$P%Ia2jp2`A@!WqdJ$79ABZh5+K=Jy4s)8kK-5*p zF-yI3i+X1Q>-vf!nU&;dGWCt))GIFdhh&LPNbpeiN49!pn8(sk!da}?Hw$1HVp%N+ z*S`}VWBA;+)wSIh7=ONKDsuja|7iEpO!GoC%~*2!GeKqn3^|pM#ag zKE491+Rw-T*8cGwy!mZ;)B1RaueIMAjyr}9<}~ru+MaF4Kjl8Y#XYpu9dz78VSJVp ztdA1f1e}MgP}`M{AF?mH+u@;FmhYq$M=-)@;UnKu=GVb1z_E;{Pqe~;R0W+}@AaRd_o7W^QVX5j93GJE+BITjoW&ll19!PO{dVy>3w>zVTM%YM4DipH#n7ME-!Ki8)i`$ zA8V{1iN7_*$fUj$q^&PdkYK~kd<@?Wf8%egYnRitsj;px!Z~W7-&xpGN9|4@T(CRf zd1U%3WG>H6$6N}C(lDR<=~MsAsnzd;5tawsr-5~PP|&yop2z*Hi5Ow)J5GW$&OLw0UGlw@=vlCN?q`TT^nLwsVs3m3)6>eFq z2d8ZlQwSCibSV{Q+`@gEd6ET|IbGX8gx+@icYu9gM(kIb`hJ|1gyECx`$uRfY3ln{ zQb~dspIqP1OJCpDTXwTguI~Y?8fk+29iKGZHxM$GroO)^={-}znXcmg?VRqn$?=Ep z%1)sf9x-3PS0mdUC9p&MCL@FtjSyqQg7TKI?D&wQEN;}B-tpCmTslWLu05GpD#=ib zL)TOF&-o|RgwD@2C4w%{w$FEJQ_IcQuOB4W{>#@-D$Cq3>11Ve7^m{HuXmpsRnNA2 z0{f!=7wZ?7W%y1DEI#=-|5!bE?a7fb_B%rI)JeG#`eX+`Sb3elO3W01?Px#8AuJ9L zN$cK`a;1K6+Y&qaD9Xg`ywC>U95x>&Ku|pI$q>8^2tHs#5EB0mU^E&_>ZPO;5K9#h z|84`3J#07MfFg8mCn%Pit<>SsZC~9d4_{PZe8F9@xXf3kz<81ZV@VfaRJ?^rQ`xag zGvZLJ6_3$$@j_Vf3u*Eg#rAWGYcTXsNtqDshPSsVn~UR>Ha1mCR8><8o?zW*Dx;jZ ze3f>Ad<%QQO8?30UBVGnq#*|xGyNM}iWkZbuIo#R&6&89L4~lKi%NoUA4e_k_B~Z& z>~Zth1C*{Wsc|p8zT`sjQkDri5nXET`py7rnY zuU;cf-5dYXsy~SHhS8iGjXa+EA~}FJ_KO=&?oJ18O#0ZujUk^VZh#U?1wWd5#*gi< z#qq=21%6b-XYEAr<0Qe4F&2K*$fS-0KL+uo&qZ)UT8QM+xi2|Ch9N(Au>*!IeXBbR zxjWW`{|SX5v~&HUeUZlwV8Z+GY79rFS@h$P_Z0o8B_Ew`IKKBm3`bnbQrh$gKWgIz zIxFfX_{g^HEV|FtAm@V|V1OEihLoSIBqPL9)->tC=jM}ZpJa)GHZN2UVW za<#TU+A{kSr!6s5+b{lH`CdBk=dbu&1%Kph;)4W#KpUYrUxDJJhC{ct^C##}CmiaI z{zQFA^ykzL^ylO_{W<2j4p@|n{RR%z1r~Kde`bI3^rs^pbt%Ujx+{i92O`IO56|U) ziyU)_xbpi=j%jOICr-?&i2ol z@3W=fXSDa5u&-U7;H{>4qB^+a=Ipv)xhSUR_OjPXy-V2HbPvHM@lKqOO^n}}vwvVJSo!8x%W~edU&+v$P>Tz7JZ0tO)k7cY~jO*`|r)^x;-k23WKt^2V z4ic3Fv?Ag%Jw;yUDy@x!y~A5&2s2d#Mxbrxd~jXMEteg5$^wzN;N*d2oKVIv^M!wY z939sZmaG?n6?4=lLOCw~O@@cKtMKuYUGp(lYtqknEbVE|hOd>I8YS+iAyCx)5Ot*j=ql`M&O41%hM| zq@{vQQ&~v~2+`rPot_2y366IWjFo0MZhkd2IOfrXg9MJ-`izfmY(T*A-VXRUF99E& z%cih#*G9<0ErdjU*bhclLS|CI$S3h?_A?}*`$C6%v9|jT%QmbfX@{lpm(*Z6k52SI zEG>#ij&SEHy$#wC9MaAg`{UXE=g#eX+@i}*_jw(R539NRdWUt85?#I|nJ%x}oZ8H- zz+}=sbI!-pPnLUH18IQc2meSr9Lup=r$S9`q6-HJ9G~ekK0bts1T7JPAW=?8kuG<@ z$RDpw4U#9&iGGG;k90YXlYNKf3?gLG4$Jp~~1^NQdKVyYH~vjwqXUSl)=|DHW`|m`?OFR*H>D zSqwxzelm#=qbK*vv##iJVcc%vZr0k|OS8h8`z(%(!t>13-PJ)HNl84uC|NxIMN4WE z_g&QU_K9oGT>44aEYbIYaJwIwxJX48rOhh>be zI+rDh6LGqFpygfB;db8Voq3>S_|-q9oqW_SPi>;EpbPC2rO)gKGTb#CPA44iN7_v@ z8Ga!}qtGFA;UIxy-$_T!^Zh_NCj2fnjNFJq-M^6R($3HsANvkR2SZ3ZJNtHu2Ag^u zp#2QT82!~}c1?c|w0!^c*KJtzcT1o3x2w0Qc?unf{&sP){`ThYQ^WR`3EOI)B@P-) zx6@g4>;8sgA%g(l(+S5*QZxpAW9vZ!$G(R_JdNTC9PjRck14u0I$-4L-=v0-I-TfW zjO-;o_8pE*NULdwV^M2raLk|+{S3z#{WX%vZ@Vq+K+E?}H@r6e?Yn#VRdikEDFyYJ znEei6KejVZ9!To1x`$Jnr7P${`z-1GLV$a~_XCIH{RDcY8ICWkNDYpM(1n8pj(wNg zY6z|aj;WX-1n)Y8{dB;{3BO1Uk{dVlHza$Bk9~)ugCV3Hj^F-6YH+MaUhZFvjN2LX zWJ25T<^4^UtJkHSo^1VPYO}W*{kwl>FVW|8fb-Yi^YPf4w9m%}|C`!;jH3&mvH9pb zeH*j7AL!eWKT2&zeuO;QzcZ3HI@Y`O(f9edAE#;B`Az9#sm(_LojAzmqjzxcyZk;1 zB|Xh@=P!Po8q~kLs=uM$qy6N-<@Z0~J54hj5Bq$$ZZ_A}gJ{rn;dU>4W2C zxJ=Uw$8SBD8XR9(cF@4F@6v#iK>){ZfJ?m%&KJDvU_I%8kvaFL2FYfEKKdIYyQIGz z@v-l4+<@Sjb~s+~>(t;lfll;09Aoqs!r>w^PAErg!&F@NNawSz=y8JI_kiu$`H!lZ zOTnH^O0o_V*|r|a1EI*@`c`W5){I`?K5ze}_Uv^yQCR`$gk#Q6Q-k9Kx^R%dvG4Nm z?Sx)*!P)lbPZYfCK#@CO2c?E-FG;i!4T38$BjQr4UUf>Kld+2 z#%b;+DGzs^r@nK}5K3>F>BiyrrZ!7M=tBR_QaAE&I^kH26E)3nZ2W#|a9sV+K?BFW z(~XY_y+}LVcrTb5Bp1?&{>8|Cr@xOOyrvzF`VUisV;P<3XE?^>;ZKtO9uc=ksMvFO ze^$8f6nN;bQl%W76S>&(hCC1n_&y`Gd0L9@-9Arjh^R|H|#jxM@zkifC;6!=zxFH)o&0?4i<;21{EX-o~0yMNx_knBb#=n5zM4$IFojI_gY z^>q_qC}tq)J!-TD{jeRAw);`Q>sa7uVx zAUv_IX`}U&K6FtQ(jFXNyr4i|nOU$z68w@4>!+*d=GN~$$(KE@WsMv&8UL4J-MT6KlaFYzC zb4%8UIj>p{yOtb;a#{-qNm-!iww$wWg40QmHmg7n&f(;hg~i%5`@mt25j2 zGhZO~LFa&L8AM|vD95qG9AF#1nM36?>og=-R2v_ z#aMry)?DU^(rlKtqJT-~>v>vL*x4i*yh7)18=toz&*faTKG3o)a!ly_AC4axyZ=>W zcam)APz0u4b%v{&rpHFcRriZF7F3wY;Ue z>Rq?-p7VcNhHh+qJu9#&cj#UPlkCX1J<*K}z}2|hSEyB#`3lT+OXK~1_%^Zx?%t3~ zMn6*Jd4pAwGcns6tl$uaJL$5voImx|Azf1_P>ARG_S-!#5RlDX-jX3!7{2F6} zw!XS7lLX(|hH74#OBQ^MDaODXZZ1yX;`Qm0mM=z`Y!vv?BM|EF~=@*^us&S1XuGVKz3T{XNd zai=UT4s-AZ|5&n=yJ};XI%h%@nfP{4KL0&9tl9VAO^kSwucE;Z+}V?Ch@vt*5F#@n366&%7E!vQP&;v-pTp^1O0 zYg+9e;#@XT4{4kMI%q><$#%Lp2ee*Z#~)6GEqjyS6=jribNViBRu<3%Hx+e51(Rm* zG496C;m#e>>$!H-k=avQNj7MC;+`XSf2hk-clw*$QR>}g{npmytNTmlSijRH1vbyG zy2ARMvCaCu{$=ZTR(Fb`+bt#W!u)eh&9R%jAHIeQ+kSTnXY{E*yNz3dF!Cl^}PcIT2GaJAygjEEQJ z4W*hkwk0fNjmIxLmn@dYA0|Cs9lpVO{EBnQ40${U2(-VwCVam2nD1-ycvsTn*6<1P zSU$}mZ(KZ}reZ-nnG7Rqj&d zA~H&Sw{uCJRj#Y@Wp=sOx#V5W!=Rm7RsKV}{1WGq9ai~tRW8&-+PMlKTIDk+pF2;= zu6HhZ*eaVPW!FmCZ0C~iSY>mhY>JfmoJ*RlvV~H1mXzJ*Tym3?-BnW07Z`Kh*j5CG zyagk}ms2j_kmOao8Y;#C^GSD_Mr2TMy9>2~zX0Dc7NV(mvxG_A(dJIzDD32|qj6HrT zJk@#(QhMdFg_NiXWf%&uV9?|5%?c)#Pl9xJfl|LokeV=hz+#TlU+vD4ps zImQGS_9FMZaj%tE{yBfH9%{%y8jI(jf7aBqS0`xp%08>3VxqeGN{Uo=V^Ws8n%^RS zb6~H-d3P(M!&fTG=1`at8n$(gpQzebsJjoS5ZIgPY!VsAm{R&=F28!_twly_tC{m4 zX~8EJ>BgKk`_?y{(~NG;)Azg<*yIXMDGl6Omf;M&%sU$5L)@%JJ5oV?Rs&DBV9`iVtSZxuC~osaXkF%TZ)Y@7k>Q9Zs)U1T{M zFW@447Jo#C>LK&FIv&ux6dxysJxM_?-Fi^~G9 z@A2{#My!XX)S83QD&<(GoWRV|zpS6=C2Knbd$S&h=K6=|#*1b_1B%OFE>6INYD_F` zH3vVKiDBecJ%cY8Q(X0xWxz5z#U(fEGs~hA^;iye67%bln7=lqa}D}~;0b;j^F-_suJ5+m85Gq#DH^kKMpwb_u`bbDz`1c*F3u0N-K`QDu zhNyLy)W2W}S4+53cy$vqtU5SLU4U2DauL?~(`&ri_jQF=BFrU@Od(jj%Y)7LP;4W^ z%)9R5$6+=v6oasDL*NhU8~}fQ;1BA|0cX>F($17pqg6Nj#k>#Zbg}Gi&$E|YSoytgJ`g`$b{UiubO)nX4Z4-587Cd{4aI^j5*&VZOJZphL z#AUtSlQ>M#2aViFnq@|GNPKtL!fSPE4;+Y|-z138cXP`&EAM|6b7@ z4^E5!7q@N_hIZh=T1+Xql#4ha>%mO?;nam4tB}dGC+s+BETy zR6`C9CaybxU#a2O8_<`u;MX@1-S&%Lr^WQ&n-c9Ty&-7_8-9HXHs~v7_JZgBT$E$W z|BGL#XP*1YRBBoNU*W!K)q9&^rr=diJa>s@gTC%U#dBMx_b1PN_u38^+L7m8V-vtX zUNyjT8}GpCFX4gz2jft;5}=Y6nz)z+xnG*Nb%Kp@Pq7qJ67vo=nmC~6_Fm8ZDhv?( zN`wCwB`XoXI{ANpe~yh`r$CP5_%&d2b~dIE?|d?_>rvnRqA+O7|BG#*XWsjRNz_uj z_pfl9^zz=}h+^PZkN)2(kOTiOimv#7yXC#3AVDPH`7Xv96*o?o9xEzAFVCRb_IgO|Wvd%=q*2>-+X z%kaeii`drn-lKHzVi$UD5=HF5i;ua~M%0@o_X$x4c=2b=|9e@QXykfC<0Q=M$cy*! zB}F4Y^7aY!4koR5K;}zT=DQRk2(3(m{}=2@#IsKR->Y>S&zdhzz_S5cbnpDXOjD0M zSciAm{$J5_d*s25aa;5S=ck(o@4HChRZq6)_ojdp__RD_+`+_k z2k~6#FG^M-es%KyJ{*(jvdR+h zYry}Tn*SG8)}y}rMPbmE{}6kYNE zcFTLyVRPPs5g-XuJMiA0!kZQEy&emEoDlXNQ4ewsJYWk<)fPAzgh&gGyoiOFgn1qH z-j|QDQSYB6eL}s1i4zatS*m#U2Gln#c=i^deEY?-iO1V`_KNE>f@hzC9$YjUX4zBj z$ulsX+WueBhzdnXqmjAbitF-dsC2-eX@Zt$)fgJdM8J_rmkL^wmP6sb`fqzMu z+JP76o?#>ES(SZ4)B#@nS@Zvb2Wg>^>k*BUFs~yozU2fP_3r*m&`6_UdX5~W(y9kq zYu(0EZqE%+f=ys3&xoOAk(!<>)n@a~qeJRU56< zO|Mw1a;z4b7?o8R)XM6#z|O(Cp}DwdDdWUOl9p?dN=x{xIERG9q8)-TnBKVe{dkq|2X)swYIu>yW4oK6Kl4p!Lz0pV&KhgtzqGMj26xC z*sS?E-vz>&AppytX2oiI-e`R*yLolX&aBX|f~-yMlb+S;S93t#YOVPx+8tA zx&GbEme(Eit%I}R{+dgexQBK%SLEl_V>Myo)jYv12fi9p%bK1ON#{A=WuXZjiJWuU>bh1%=IXLH)w#z$tA!?) zLE<>7wsO8xYhH7DX3I`T&fu(8=PE_zoU1m~1#>+j6$z>1^N|O?e)Zt2ZK6IdEzpq;I(e!2As0TWpnd z|NB{6KXIK)`Lnz!`?G4g^JjU|>CYPIS8D#h0eJnl!b|)E%w8Y;Sv9slOID@wXUQtG zB#eIYXAShVfBb|4aQ(jx*EnB}`Lpm?r|8eB!PI++?a$JcLrcUO&z?8*?!8)krAM#U z5BqMF@507AFs_*YabUjMy{iLw*e9>?|H<{0lK)E<+10lHs}oV|(&`Q>rs4(r)`5D# z_B)3IV~uw0*BqEvo3Rhz@W6WQ&O@ID+LUbn>L9%J>@SmL+U_s&eA521f&TWdKXL%R z1Mp4sPq*VkYW^i56UqJ;S$UZ1`5))Z+ZQoTH)}YxUrC z(sIvY%j}#YJ-Dz~yHpRnUFk>ePBtSwCxpq;!S#@`N7!P!RLO@{t z-&fT=)00e+nUFwm$>)>l>gww1s#mYR_1>#jRn2~RkkZ#9n%%Lk{fFhg{>JP>Wp%z- zS6}2Y(UL|-1!qW#Y=QSsnMIOZ>r%v9I-2HS6Pc{cv=;UV%X~U7vrxkdy?4(+|4P5# zWGcz73sdqpyQ1WqHlghI-K}i^S7u4dR|ZMft^y}MV3r~Gz3y4EKzh1 zgu7az!)*_#lcdB*M3y>KwDa$EHjmDh)A+r%!rhs-@taY6hc`iCWvv`*cY_Iu==jr` zrd51{7>91k6B)zlwQwr}+L+O_030zHEnFp95K5)_J-3(vFTyI(A-TD~qMI#K)pKH> zWIyfaQzd2~tE|Yf;=GfezTH7}EKb6Ivcvrdxl7_gt7K8SM4P)f#a2~p!P8WPX)#@K z2L2^PIv6J|o=izKwgvyf#nRl8WrGzU+7YiGFW*HqGpNp4M^RZFW4-EQ)@1qV2e-YmgZt<9GK!Pn1pR%pqRYY zb;W^xy-X%2;^X7@#v@&-nI5om7={oQ43xuv%7yp!GP$9@gnT_ve%I3`j7>ClNv@}9 z9ZPT!WoaO~icoFpP%5)la!G+Si30YL6o`~DEH+$RpbV1YCXr74>fM8W$@MISu_;0b zDO#nijUw%1QKX$7McSMw(k4Zb_RCF?(_uvvX&;Ot?c^xZj*22}ViajVekXD|EQ=y- zMHFc#M3HuQ6lqOSr2WUn$my^&inL`>q%DdfttE=I%}tTlZBrC!pNb-_97S3winM1$ zk#^69HtFC{2w?|S+mpPHZa(M_fpY738c)jSr^ZOiekW{zX4g|oV@;+*<@3{^Bg3{Q z_f>8fu3r1eLBD%KO8KG;lRQ9~G)hvosM##e!YzP++eslKPw+EJZ^?gN-+8@Eh%(|Z zjRtB4FE<+*T3~kh{3H{ZB{34B0@^@;JeYZll^bQ2ln*7PxB6WpRsRBvGqI8z?wO5} zYbb8WHW{{LuFn@qp15LdY%#B;JYl<#Ey?4?i`R+Qi{mBF%a+Lp{eEfjS5Kj!k`h1R z-|;3X9j4XFhe074oRkk7$~}n=CBqJKT>CMKpcEwMr+?{C`U>M~C1q@iwR(?38Bz!m zC|P)zgBnP3msw!7_;VFv)$v3J#WN3KWvBX4!$E(c(%^9anIi1U`_}5s>O(+K z4AzQ=)gpb9y6nS)@LYM)Le;b@H=#16SVsDVI7z%koH*&`Hd-~18E}Y9|gPgHVNB5a#6W1>mL{j&_TMcYs{tw z3Jem%s~+@puDGQ_7F!ZY%vfH(u0^N%5+l;l7|Z$A5uUh#aS2R5INt94i^*~>Dcckl za5cxunXcv-XK&X^84t|zu>ADeWoDauG2ObF{O)RIh_B{`_-Zn^OYW;Nv6MS}?a11& zGSZ1}Fv%f8TG9N9YbE{02#*H{>R;S7@gr+9#5lQE=0Io6GTqKZctSdcQ;-_PMA(c> z>9x!ZMf!%;qFg_cT$$jN{Z2cn2^s!VE}PNIRK6(5Ub!;v{8! zBFXh>sssI1K|oS=LL>2?(g*KImGBHe4l>k%1g@BKvD%CSoCj5J#r}U;+vL8IzpmO`y|tp&`3-`2l;P_=Jb&qD_%J;| z{CBiXu)nF=oRcQ+6SL|hPqAMT^0zsLVF$rD>;zL^6@z5|4a?cQtYk=}$GYjxle^2| z>3`!Zai*Lb=bj`9tLr6~n&R5ENUU~>d z3{x_!uEf=R)&hPUVIxb(Nb$t)?>dLy_-^KauUD|Q^Iu0kvt4;435I>KJSSO%C~$7W zJ2bmMz!~0{qkjuFE~*OV6)xVjuVw;aoMc=>TP1y2BG30 znk%0Idl3*{`^+Q0B39JFsqPiwv9$!ls;*xqUFa*4l+bTF6s7!{M@U)kJW z7RtR-_SStXJYMfhc-`!a6|1+|$bU;zHn_Yo@;NTASsvor-&-EUk`ENicTW-b)_*Gs zkHh&@1i`bmIpda@eJ72q^$p0++6vYqR(Py#WF5g3#I^`rHjUlqsDw}O@ChFNiSV#& zNn*l+1rE)f{T*u{X)en2)y|je8K_9C6#MEV_pFS z*HegtF^hW}eHQ^j<%;b>B-g@CRsImtGr0 z!1H6)9}wgZx10?2bn_K5&T=S5i? zoaa-WBxQg)XxTwOfo+jc^FHpYcd9Xn$=VsjQ)<4)YN_oW*YFg&wA_IVcvJvX`-q04 zCwP!a2FD=}KKx2c9=s1R#}^MWy`@g=XW>?@6@I^e5$Pg8hjLscPyE0?#F5s)!tsXi z{wIU+UmL>zG=z5;!cB(o+lKIKhVY*a;olj;9zE<4x90Son;@*NbE#=-J>s8ohG=)= zaknOLcllaOCbCiod-SR_RH`I; zPtj<4UaZ|;waS{r-?&PP8L?{DsXS(c7IV6%=zO83u4Gs}hOgdp2mAW0IE@i{Luntx z539$rFy~OAW}7E>jpyn=xtfQ}>FwG-WKJBl90D+*31jMA>g6q(G1#Ep6mlpZ+ub)M z+1)de?e5YP5)d$Q+yQC)J6Lux`W&!(FeUBZV0Rbnv3tgnTBHxDPd zU!wJJMKBqpwdE2MQuD4W?=<)t98cx_8)jUOr}D-hXXPCS2Z!T{zJJCHZjULitM+h* z0P%C!D!aeHK#K@5B9b!yapmz>=G`z39&dEM>^Lm*lA7a>&YPDXr82X*49Pvyl6?Jm zww@kR1$oxOFU~!gX0JE<)4!G~o1B>q)--dYb@*V26B6c#u^_Yw+A_VGlD<8?N&OgJ zD@p^23KK|Fm`tLAc*~?))~fk09Q0$l_H!w7Mw0VVNy$s(@6v0=T=9VA%<@zpM1GLE ze6RRjY`XkSK8;@SFifTn&(9ivNeg%LlH4;SYt;-(HD-5Fn7pK_v6--PRE$R|TXlWr zj1=KPE5Z=mT2J7PhJDmp{VrxbB~L$0p5|Gk*bT0KF2eLu+%;8smYhVvH4ZN;8(__- z=nHWf)>EOv2NJNrZ+SqznT)DM^m8u#ob1|f7Ap4~hU=m7j#>oUzHcgpB#gAa8)3SZ z2S}c=AoM%x@8DkP8zZ^$l0oylWJPMOY!al+?t(PmCGHt%-aGM4dZ8Cy818%5n9yA? zys~M2Z&yKT+`bQR18X=6c`v@|9mU>Ck#ouq43#e~KQK&ADL*hmKB@dbnovm^0A5P; z4&Z?}Z#)l}y$7j21*s|C|MEbLcQ*o(dqyfqoZ&7_bI%xskb@c8C1n9t_s?)xGwx1x z;vA(d>Vt0_^jD9~1lb+J>W#MS&1EwsWenEZB<2b=arW~}fCpWPtG`}0zKu@HQz$!*mpt+8!Yd6{I( zsvyNd&q5iS7~BCOB;!*>oTlY~+X2sC{ou*gnFkmN)!@8TS#!wmug@9= z+^d8N8)CqP4!{VYN?rXjRZ^(<0RT|Gzyjp@BXSd#7g&HO6*MEpAdBYOSb!9G z0;_xJ=NI&oNt)cuODIQJ^>g@CdKKK1FUY(I5po~9@}Bz2Uw~lq)GMCg zpPz#_U2hVl%t69buEJNv%!?OZBf2m1*+CHRQpD)_#KWuHw_F|g8=gga*evE!7D_^8 ztp<5JMRx*+yjZ07PQc^pyv&>wIU{GNJS=CJd{)i~d0-9zkER?M;1Mh$5a%7n17`2J zJdolY!UHj0=5^q{gyG$cR1{Z-ynU#+-uPzc0N&;?&cWVKiI8A}ewnO+g$go*%HF~vzM)~gOVX+a?6T z3aV0gIqeUBqPC1yPWuunK{z?B8t?--?X!vyIjt3g3KiENVSe=nhJd*UiykY3Ks&qv zf)E&x)$%Oxa+5SSHwbFiYl0eO!v(dIs56tG_C0k?3OvCB@+|~$#q?tk)V|fg&iV|H ztb~y6Gzc=jiDG%PK~mfE65_B6R2WGOViA|r*c)6_+hj}`UR0Y)xRs8w;B?_M5A@qWz%G2Sl`2qUkxf+T?;>EjnM zRRGWg@e763TW#6zg`iS#Cs1jlTKTKi-~nIGfWTG&fvriNXN0=Ic3mOD+8|vD#L=hf zC1G>b#XwX*mjo;S24HF-p)J%Tw8SVRv;k1S!od?%ng0n1Ej-?EZ4k;~<_jdCJCh88 znKy@|pUgXwoM{vb6;IO^NlS!InZBJVcQ8DY%Ba4AJ_gwEzJYEV>JVK)f(wx2UyD0J zj@yt>M~(u7J3x+hw7g&7?M{KmWV}d_@z^hQ@F;||*%CZ%A!um_JZ5ne(Dl3sz(d6w z-c0^lJK)hR${qucKRq7+4+3gPG>|m5YC;XvJqloW+ng;^Cc#Uy8vHRFzCuFnmH zKIc0Nnw{jQ84RufDv7o#%sucMKi(sKuLXPv6^{_kbs}f@sE6hp4nkfAP6YM6aV^l~ z4vr>a3>}0Qkytife=RJwgte;NkF-jI?~#avgyTF>2R_m_s3{bU#Kpm(wK}UxEc*MXOz||_Q)D<%U=^gcafDROao4ub$ zq0oH{J_#c+g+;YxNDEYpg`!6|in_Ek+8pOl)+NOc!NY*g*De-b92FK`2%UzokkF}x z45nGx&zaki40avf)nzaV;SOZ5wzM}A?~NuHSO&f2w?YjrvUaUaHxgUrCHgJKwkG3kT(bFF8~{|3Tmx=tFlp0EGoCZo;mPVc>n ztT^tN5n{$7vZ1iRlRN;IVi=5m-ok4143ZP>%z$OWhXL#z)r{F2-z_*aVZXs_WLttr zyU`d#6MS1}g6~pHsCoZ^Z}3;R-RK=-((rbpRD9V>Wh=2|zbmKH+e76G=rT+`jV>eP z{&Y!m-b=!fPbQnU?=G?!`KI@tk?Na*V2tl($z6(hz0wT#f;4w2=JiS)K0D3IHRL&T z=_A|(-K<3Uw18=*rb)f!F~h#(+C1F?4C~O_!nR&zF6>@G_3F|V9sO`ny|R*6Adw$h z5iL5Iz-N@PXs*@7S%{DUc4HIL1yID5M&IAMWGp@wnS|?`p=uHO=hv)%hB3$d$oglb z=9sg-RNQjs1J+78d)dC8s0klutwg8BbfOb@+jAjh9V!XAAOA;qU%SJ-mNdv1GE}} zI`cgGnMpr}nXgZgiaK)zR2J`Vkdkh4s&P||n-bT8EI#!mVd`rJMhV{>HMNp|pA?_g z3KC5^K|d;VU+J@B-s?Qv26Dl~*L%Jd>eHCWAqDTYuo=)?yr}dtPJH#^6JH~do&ktZ zlb2N@W;e=K5D-RW{KANgUl@_`3nTJhsLnL$|7RYEV*o;s;QbY1Y`qtxvI-J1@U>>{ zi#1KjeWf-9=9?MRlKSfNUxM#?VunOM`6V*|5o!vuIsg&O@(@yEdVj%2Z2AJ zv$9FkQ5?TxI?AQqn^;8qkf8ghWI*c$B_uiupFX6By zsA9A??lX&L#N&R$A33hjLeduF{=X5WkNYd{j5E3UnD2cO@oaQ|9RV89ONO;Oy0@iL zJcrjiHMIW*FH*NpN5AAldzlhuXn!99coz@tWVPr)L%Zw2wt8k8Lwi1k_7>y$`H0fg zeCv^o=L_Jib6k$+o$qVqG_pqA*KYhh?`vn^trmT)7ozmO=7A#}iDz1W6KawIBDQ-h zKo;I}>%fOLv>KgcQ}r@#=#)#X7xFDOq7bo{;(gu^Y5gC@TcP3;J<#sN?CJ@3Lj$RA2FcbXG=lmjhmoxvd`Jv6+6}U1+>orIbDqFuoUy53`J_~O#*?I&5MX9n03Q5SWo{{TvU(d1-kYL4x;D1ek2?<}oqeas=T2 z)=IXX5mvSyXOyiap=PWmSBHX#VM^6P0CIM#Db;Y`5j3pmqV+~iw7zM+CR$I7LbUz_ zW`Gl-HG`LM*bI& z;k~fk;T@+8VtBuhdZ$ICGY4BbJ;1uD8{H&re20vU6CVP`PpJ4Lj#XaKTE;%B%f|In zF%x`Tj_cU#3j3W8Wcwfnt`vuVoa<&*>iKqAy^B-VM)S`$@X2KRX*&C4vW+w47{lI} z-Tj;@Wc=5+_B89eddB$r(IC-}@9}AJ#v-+$d;~~6`5h{%@t;=%PW1-D8VTOr&y8iF zutf#_f{Ve#b4}#BnpPV%387@1}XE1)_d`b8<`}*KF#TSR)(7isX zeNW^;R0#fc1wDisF>6%{jTG7Sqyu7{fDVXZ0y-c@3Fv?rBu+GOlZ=6rSui4id z*wRKT@$#L>_xPj(`C=q$yDrR6#GFfm=rENpN;NrgvqgPmVQ_T^zoalrW*OW@K=Am-t;Vm7xH=PF1cH=EXr;G8$n#Ml~IpBd_e z=$?lS9Q37?I2kqlZi<8 zkO=nZ$V1F$hP4wP_0UqZd*1+k+&I;1hYZMdY_==5NvOCSF_JPrF|~wXL zPM+G5Hb>l~H^WFq&D>#=jzYptHt7pfS{9o(DI9Ae+!iGAh76OkgFe_FCWG#3uvc$u zS@R=qu$M7y7*T_{kg$^t)_iNrVjrzO*bY`so2Rvth%M;zvAyMkP2sWfbrv0J>lj!* zpAH_U<-is=ghc2+-okk@8mNqi1uCLu`WQMankl!XUuHWc)~Ys;wkX!TIsNADZ=sGc zGOrazl0B?7Mm{m;cxuWl_~Jy=lmn5l>zeYYpkoKv_?>(_HPj>J5jNCxB<#9|>Q2do zpApATts~jdEY#R>cp4M=f?igk5>>!M;>WvM&ciY>5J-V@;6l$vH4dBnn;~*gUtJDL z^4&l}kajePNya9cA_+jc5sHe}VY#Msu3UNag&g-?_}KwQ;?6y4{6#CxrxRp!~!T z%3s5ZbTrDNm+WZLAUM|0=+R1Vx?xsJneD0YvH(q>M5#CZIH9HR6JBPEWJemVHtmN> z&`C+`u2zNV9?`i2dVA4hLuKTyqqj1?tLg2AMBhnzAHKe2VU7vC=L4m>i{7WVs^XFI z_Yh3{b&}o>jq4Hg?me@mob#vfcv8ipyF<5#98O-G+m+Hw*Nd4QV96iuJdS96B{Y?; zlN66StuMXfIHL7-C>uSQ)<-0F-VGbrNLwi*G?_l5D``SDDDriQ^y;#w`Dq7WF||s}aEqg=L~#KEb7FT#jXLDId_D!o_LKAnYA-(?P%b z(rD(zdzS9?+*{kG)Y-?iAkDN87UVR4+fr+=Ec+%#QkG!)*)RhgLD?U$qwJ@^BHi#BFTsp&RhE$Vt zjZ4fkCbqH&VH|d2@~-Fc2^3z5 zAACBgJYyy{#-?pk#iSLOJTUp{TVI-hw|gTAgM^GA$S^eTo}YHx`BJo0=iB*O=mRI(`FLpOjZm;U z-_ExK4NkQ4@zBntIY-jYi=d;NXy@ahowr_lB<=j0TTZm|@i9LC4HMd($L&|4RGjF~ zJ*Yp^x&*9g&_(VCjUsoIbkL7yy3kFV6+;}4T4gxC^!*}s86T@jcEyOc1obT2t zCY87#hYNfqU28%78U6+n#D9%23GR4fy5S8bivOL9;+v2=6UBdl029S=v`;bC;>Vz1 z=}xQ;xi@B{vj{SG91;Y?@vHFkGX8XwbENh(Ad#O_;!-CdMURlmxvWpJd3!uDwfM+* z;xB*?0Kf^JU>x();EC8H>W;F^Gs}ab_lSky(gooaw z@EGBt7wI}yzDdk#kT1x&Q9dK*R-uBd?>SS1N)q_fx2qpsg*}MKVMcx6V(dAxNUYwW zK4V45nREMnGjr~cZ_2q#F3P!E9-cExPR=Qn`{y|20&7;Ib3*!d-#^qHm(orpjba+k zpC|Q$1bg2q#h$9v)v57f#d-?5vpttGOhV-c2q}2Ew#1#kD}8TO{^yi&9A!L=LcJ)|t08~a2w$>T z@h%Gv^YvHiwyEsnc#>jQe!$tB)%D^<4NE_B3W1Wv=U1=y#paK!rALiRKNB9S#fh5E zILuz1-eCLLt~4?0Jvm;?dfyolKVPKibL5VdB*LsDGhdIv-&lr z^*}(XbSzQihB|KyO6DwfC{q&C_foM(Ba>j3SmD95luxlMgA0{)E7Pc`OH+AK2P*=V zG=U1*UyS`h%-&bF#uw`naP*=BD~joqMArhzBs{bjA$-J2`)FegwrAXz`9e)Ui{vTX z<(jt3ROp#%i4j+j9!t|yDe8}x9rRb$IwhNuzYE*F$X8K80;{fxnu1<5XS~gv;2UJ9 z?w3?oGwO;WWtU3M2Yn)na>BLm6ugRv3 z1;y6O#S%62M;%ejp*QZF3&K+D6EXWUjbdW;dPynVBc*Rrf6Rc_g=eCr$gbR!VOL76 zc4dKNSH2MGD9@Y4i8mjWX{qj+?COSGnO{%4_<3*cQNhnwFVXSy6Nvj9KSx}NP=xq- zCA}2|ehwXq^h4C=&%;H>&s@Umc=crfxQ3qxftva@#rBSh7dbE81jKc}BS)u_?8V{AR^ilc(9)+=;u zeV(L7CY$z;0$Y2Dcq@D9U+Q-ct#W`IthZs3E4Da9PJoCKfSyy{Io*1Uml{{H?*(Y zTiem?*Pp55=O^eO96$d-`g(-2seBsJMuDGqp_2eVmz<7^j-Q_n#!bBXF~npIKNkh0 z(AfwDb^Gm|)a`fBNnm1it+lmw|1N3wO?bv+RHoiH>FWI{yV7i+U3`94gEQ93)caGQ z-q*({rNf7PKde+D-F_0bl&ai&-vp@V4!&W9U9l$GGp$KZ98o!AEL`Ds5M z3s>O_&C`SgM~|SVt(wqw(QMiFLA|qL5fYOXF9OM^CqeJ(BSP{ ziC4depl=j3uh-P~YjCtMN;XD;9($^!pfqU+ zI8YKnE692}y75iY-Eklc^!EEoNN3NFRB0a#B^To5a9wF1s_Xh>g&?&a6;Vf^68W(| z*hn#7>N|%N^D`(N(vV_Kb%k!utpH}KFwQ!eH$JF&J9uUDqpT{v9j2-VrTc!EUrqp9 zOJM65zs^cOD)_Y%vKO~aPCN%F!sNf(2wWn>uk|D~MuA^_0aC!P87JeS<5w=l#jBSE z@rzENZLM3Eoj|oHQ0)w~XHQ18Sx_=NM78lLk)zr$q&-@ww#;$@)mmbje%~>+cQc7Zb}R*$vK{FtNN=y&yRZz`YQhSYFp+V)-sUF*1;5 zv2}oZfM%KF)$Kn6i>H6BVcbNlL$hVf$Pg;8MTqI2&{Ia)l|v=CW{7O-b8V7&ot&;s zGOv^Sik{s5lw_3ebg^QSoUmdTs^nNXtbXbkJ@-u9dqMaQkR@ON& zC7oZrj?Iy*bH-xk*^|4b1P??uy=s_xJ`?#k%0|%vT)lAImgtNXYJMnj%Vn2Iu0}Tb zEUub(7^p#63IGZRNoo~55(t88>A>(wU# z5jZ}xK|V{XcZ+%G|D);MSHjOjmj>pc@eRzgI*>o6p|A9TH`z4wX2}DB*px<^P<;;b z$3d`MC*Q&p*-g&tdD#z9*{?<}`V8$Rxwn?5d>ZDV8I`ESy8*g^4Pgc=14zN`rA;;mu5-e)VyjXZ}1s>?S?>eF41>8!?0<`ZZppo#< z@A${tqEiYUJCsJX9#|cq(=-E}CW^5i(-icZzMqqK0WXMe3F+Zd9|tXjpw7A=hEqi1N>t3I!SS0qjOAYr^0+>(5`1-O1soJr9J7yly(r< zqX=~{1}q+WOvZpu`s!mq`2fQhu$cyg&W-_Nz{9PC+;+x*+Xf>25cLpA)cP3U@59D` zvq@PCi~+NO{01HVSw260!-l z5C>WD#7GboyhoI{gE8RdQ$xpqHM*T>F6>0NM_?!V2wEmAHZAN#4Q<(pUPf}*iOxIp zqc#S-3z;u428@A-9`zW|=)95HiKP9}jRE7xAz_H>hF%gF19sCm60iQI_d$O^Met!l z&&te1pXzQ3Wcz__fSZZf5wqdVMEM<=iDr_S=pWd_H7`qCMRp>76m0|SLG|2Fv`IG< z*{a{gndoc8HROa(&kbG-XTwrdcHJl(=-MDB(AllbR&=-ok+2nodNNG5DeuBx;D#`s z3@3>h)00CS8P3-o873PX8St?Sb+-l_(;9ST*hH=jFSd4NU@I1wD+4zKsb{14je`CJ z%>-0rQ`VzwcJgJw!5_LWgEiw$L$L(k8JaJ{ZSZA)ts)Tx%A^n#M)zh|N8Su8(QYvQ z>;%O$R3?O-2+dXkl!# z82eTB49WR$`qv`oA#!$D7%=$AvpF?p7-{h{MvGMVnq0v0$Jwq1?}^Pp?}@j51Sh{j z{wQJTbzxX~J#Mtx%uYOk$Pqzot3(}Ou6N)u!Q3)vQ+tv4Ak*BsU?qn<$GLUY$5@#Fh?4iXn*)QuR4b0Cc$A4oiM z?~x+08gl}PTY+p85gp+14gHP@9$)a4E(6~~7IPhspX+x7cwBfAfVHKgTRV307ZVsB zfBQXHRLA30N-C3U9@Fn`)LOoa=sd624VKr)*A9sj8*E35N(dUlHi&a<-7_*YE+HU z;{83)MxuJZ?RsAFEgI8vpeq`)bv>)0)J0X!6|}!K{4LtN(tdvQyp5~mi7$RXmQrAk za!-7|A)ILlk1&M)xg(faw+kSklUNNeG;qP^`_YHL5O}Ng51&s0(d3%LB~&S$U_ahRD*c&y;##qz6(g674ar_0cz0x@xHC<)9rNrJvg-!bnff$BG~&sQ0G9_!bfjyg#m?=R#`iLFg9%)E?Pd@yYuu~*RK7p z+Wu}a&3A_LG-waE%Zcf=xQ=o5!^UYOz%VI>osj97Ule~cq9m+|ow8LeL-U9$Ot65% zd)*?r-kbox43jfnRBC;FFdJ8dTWOo>se1OXA8U})e6dOaVBmp7im$Ad1Y4uz&O`Ug zqXU)lk{!ygCPL7m}>a!s;2B-wOk6mdS;c+nxO!o?p`EpuYJm4&|37q_!&u z;5AO4!Xjw8*tdBLV>e3McH6h94sgBHi1h|k4??;O-EDd@$dk%^g(c;E^-BycY?3Q} zsaY@K#TdJ?xS0yzDUOkZ{B4*XtTtE0NdEfj7_oYTjRkGhwG~ay zZy>P@AA^nHF4T+TJUg@?Yha_Hf=Hh6$?9yvG~861b4ED(L&3D77=*vo=Hd37^X4W? ztIolP>7N}Yljxd~y00NGvs7|z^yB;GIRj13eUdWMG7C}-0D7K#tVE|mP6y@{bqLh0 zB%SV$XlXY!@U~j=B^ME|0E_6uLy~s7mYlH6>^&b3lsw)8Kj02n{D4iKj_82LY*v438G^C8hrCiYj}VLbq1?qu+0o>g5G zPl~5du@H=fV-9&=psCc8ZOTn))D@)4ra&iOQD3|Kv)BP@pw8|Vmk5TbUjBWyrN zKwmYZBe?Sm}^o=gX{R&uYej2#{6@;$#*}Vv6uO7kf zjhLDVu=~9qcbeUQdbr=EyuI|Bp9*g$0TSEiZ5bw&9>Lo_uYtG!_`wO@4#?~30cNBX zDvq8^^SrMsWtxXzz&yq>O#;BO{f;mL;(w3m2%rDk&=DSguhSjjgiI5yF1rkqNIwmk zCK>qIKD(De$nO#C{@*VQ?Ed`UJI(ILy-agG_DV2lvXE%Rx5)Jxwwg2eX-}$HA`V?w zvMP@On!|d>0=;)E zV7;RQd(Mlnr*+1jGb_}dGmG1E?*5e5=7F~CIax<$&zaS+J*O`~wf#;)h3q+<%{@P~0>BjNmx6mTHUoJWt1O!(;`+C>{Q3mglJ3X9#joc=sHFRg zw(#p(E&W@o`TZUYzVtjfsJP1#l*W9}n*-l4op@uTQ{j2i`gkON!(vkg)lH)T~xv?1xkG#SM8GW?!o0 z$t!Xw<>WgAS7nD_tJQKZNUkn!7ORpP^CalmaIz^VB43tAxR=p(_*iU{+}Ob1wJzurApH83o0$OiZ z_nDFChaL5q>tFw0?K6YwdkX)s^D~+IH!Uc^h!a??VDLm2YGyU7m%YJStH4?%lb3mE zVwKHuX~yVOa@^dk{t}YCq>N4`*F8!3C4)Esa~e#q4rMd#paQttqLxFT#%#;!3`$Qi zCaxqr+*0DcRC}8{N?P&04xV^Sa7kbpnS*<%S&!XupLclePR9ntvr<^a)4yg__Y`5b z-|48#2kJ0%Z<f8fGG6L${hCu|>NnzAEO{hUe;YfsL(w%#Qv|&EJd?>*}o|!Zn%4|@H z*rz@Wxj4<>zR1t1j)+eN@Lt^ppWMzY4IT2y1jxR}lux3o^J%ZO*EdQbKSa>_Qz2m= z(>k*?0v+{@2VRM$ZL*f+*Oeu#iNqhVJ*?)%2~e`$|T3YdYR!@iLNrQ%rf2|uyj z`xe-h;e&Qxi=J(~UrV|X{b|p4E)Bi^3hi!u{#%SM#{12r6Vadceir(e@&1E1L+>wa z@jM-@XH5Tzo*(HNiA>jMxfDx{0dwQD42(f}iP-1>M~*_g9VDRC$GE~w5+sY>vr&?41A z^jILZt`CLI#3EJaL(-JI6v>@H$j?EXX;PEcDtRe*U1b%C;)lz_R7eS`+I1KRFswZf z?NU1cfsSuzJ+l1@vFhQM7!59om*W7o=1r`p#>M7WcD6(v$)aBvB&>bfcTF;Tc}Wo^!}3YJwPO*IxVcx<}Fen|fyZ zw^PTnUW}5*V|r*E!}9o|zeU31r@as*j~|AL^b_Invw*`z|9Vj#*GcdSV^J z@_2e}Bs~7}XQSlt%OG_AM0ouAXQFL?s24r4{gvWWr5<}7V@+^^uxfXLyEqk7Bj@Pi z{HE~F&-$Y#-na3*c18Qo*LRSA%*yuP|JSPapMOqMIqWZd`By;VwZH5)diVk(xm-=uAu#YPNV&QPGOtpj1bGc*gU6> zHqU`^{w(rg?JIfu_xdH@y1+hVD{Y{ou3G~{OV*z@KNNVXjztf_Qd_8#*jOXNIk~`i zg9*YLU_!)t=fA5Ty-ipwR8*7FxQ3fUd%M;!bEtEUGCqyh>Dp1Q1Abfem`uU8m9*Qd zNC`a6h3$Y&aV^4jK$nQ+f$e}$qZCQ$OU3SkN?po|-B+5jyD_u0<1gBe#V}bR zdF}y<0fgUEC-M>oJOcu=^HZ^wgCQ7A>bMU1wVjLvn<^<+s#pDvRV;atyAZ}>%`2AR>yFANp;*t@^3@i z=*=psN=O^c!LS)@qZe6%0-TPZwNW|j*L+AhvNq~m`QP|WX!(D9pjG*oL+T5be>Y2D zDE~8P%&sVZTRavE`=N0rJwhJ)=+~h5Oli2ehk1d42W~|mRiQmzrR%*okVpB;J|2>z|cn9V7E6`CerQ9f;gbq0Xy5hV*w}>DQWk4E$-7>+z)MW ze{zfaSpA;n4-7b|+>oez4^gRn0pG>w9d!w0d+cC@ezP5Cnp`TDXPV?;*sEwDd1ql; zA~+bu727>_v$%MdsT_ML3AQHDU++MSE&IK)Elji#m3jh-$fmkm;zH{(eFKwcPb<@n zJ+Mp-Fpu^$I*sgsW%?sbtVfqlFbYV2Lzl+&I^Zl_C!r8@Eqjn(e+!19dk023x>iHv zpzGns`1Q|!;@3mky`Wv|v~(}SZb<3x2Epn2ENO$dJ_B1ST~#gp|7p*^h7E?|zanKG z*Ckr|`Pz5hgD(WdZ+sb7csHg>w1XME{><3Ibx=lRssy&RCO0e_lDJ7Zo+Lqr3UaM*S+9t)kmi_PBeoisv*Iie_9k#8d)wPo8gAlfy zgEif^IN7G;Hrw3daPQC9+DtKt<|5g7+C?;rnkK;&HA8$2x?Dk`xS|h;K+#3&EYMAx zo}{Csi#$bs>W|-g(yp_& z3D?wNYSQhZIB80~&8!)GZjpd~ZaW`e~$wVQw%L&(ja`YQ;NMa5YjA`6lKNwI+Zq ztX<+98W<&82fC>(pF{0>Qd_P^-;Aa$V_%J?Eq6ddK91TlBf5Th+0)_LGKTj{I%|#h z%ReGi;-ZfE7(%RLDhLERCfotCI_jB2c+bQ^Z0&c=zbMf)=O{pQq z-K_rl5iDZ5e<_Y^TN(oo*$pvncGEB>HHMpKBUNA`8++2Cl_OFim$l~aV<$)aDoU_= z0CHyJ%zXn=x53?k$2BCFbN%bdwv7O zzeluZ3ppaK4LPE-@zrA7TKbn9n{GCmFu2`= zrymkbZ*DI=rbv3z-0+38b$lv3v88jMk7F95As4RLxy%(CXNgaTI)Y84UF$MXz;zkk zj~;-TrPUwG3nMDZ8_bP4Z)@45Hw801m1XGTmB`R&sb?5PK3gEff<2Bnp9k8@hx<*r zvP`hKz%zQX^CX))hFLOlajF^!0+(r6Q&QA3IkfpAut#vO_9XtLBs^`rBqcwoJj3D~p`o}Fr!pz!$SQrixMDI64pSQd@pwC_ z(M4at{%|JW89Yn|G%j9FCNtH|Yh4FooZo0)#xlD?ED9WlNn)7zUNh@fK73n2g#&{| zVKQud?q7XLRyxhn=X|kp`@Az@-*e(vtf>o6=H>&k8*Fp`ip+UFcf=fhCA6QBwchb? zzG=L`EJlRh zZG_5l++mZ+G(77)cTz{)=lq9QGhI&Ir^MB6|G6Ji2VL7vFL>H)Cnia={&N=D;o9s# zRS|cfL$DB_p|0hLV4q257rPaZM(YERq-DSLyQCn?3rc6U)? zp|Vv}lE^>xWcnFEKfPTCuoQkC;DDPfc^32ry>55aCOfjXI_sDm+ES2?V7%>Yn_mwf z4YbYwL|yO1i1NQu*ZUw%A8&OvVk3oVeB(_D9WA z=A=b{qHMeM(~tI(X?#M@O42(0aR>Hg6mGW?85C<~)=Xw2^hbp{ZGe zf5c$UIH9w!Ejee{UC~kJH8`wv8Fe5ZgzZ;dM4xz+^+@US0=K_J+_N5mR?&s@X@x`Z zLsG;+b!xw*7{W>YQGWw?bxhgd@SO6QCk}$ZnTapPnF^IU5yxx0n$2@gw<~paWt&uY zpqFdcRd71UP4XXu==&Dl5n5{J#m%b z$*RdXRhp%vI~YJpvNz0rZ`B?>wkQ}|yQ&0s4wg1682h59Xby`zKN$CGJ?^An+!8(R zFbc-MBP_WS;*lQzZ$tdg5x=UWpZ2v)h9?<@H{LMBrx@a&G{h%TPDKN>oX8fWfBPF8 z2FkxZ`z}51Ll!q0^_hL69@l`lRaPwjqF6E!fkMKPWfZ&XR33Y=9{U7)|9lX-WLQ1Z zkWcpBkGK`5F`DDOdAM_J&?cJOX~V91gtNncxFLAPyw?!^#1P(Q2(LGUR~o{v7{X5* z!jBumZbNvXA$*S>X7<4pc=_3toi<@LJb1U+l%hdm-R^!k%iS!)00+zLyhM|HvZS0O zDjU$r)Z*Kr7&iOmIDf1!*43AM0NYxx6`Fs|hizm&L{bJ)_Z4d1QQw~bqkpBJHBen7 zpV;J3nrzkE$pQ}zPRbOMoP*2fC!6GW(Qop_iLOLH&S9;#Ca=XkorKX_@{37yQ3l$o zPGa}yp{@TYU!kUR8DjuqIlIg;;j-3!D;*%Wuo_g6Kyq)tWoBE&2BP^u$#pMijss*t z^LNx;(-^@qp#f5d%vDgSp?i>@CY80Vj7~+CAnrzW^1L8%+sKa3xdrxF!!}{@pD&Ix zN$EI!8%O4r&v!ul`ar1oH9D_rzGM;}dJrK=xyPCggApBudYuKU1#1S-*`jGM(5Jyd zIwwZdPNF9R|N2rgYdDK-mlEULBW>5Y!Y$=(i?~*pbK>oky`inC1qVhk6%Esp{;Tvp-17&=;(1K(i`aE z2a9(bJ!UWH8hTKhM@o+?W<*Di{zz}2$G2d`uB8Xgcc4KbWxRO3$aa6rr}6azTgH3` zH@sj>tE?3sdX|m8^Al|ui&C+a6^GLQ6#z;st<12B%08s2sAp-$U}6)C6C5 zQidDsbgDi9Om|G#gPDf0lH#I%;6Oj3U8Rd43_=zpQLw-MD05z-JQzDuQ#w@u9|WYe zcz<4sFOE8wJ@y-aLw2d;bo=bAvypMO!$Elfjs3`;5A-2p@{k3bz7vS%GjUQn#$q~+ zK24k?-qQ6e4YWSm`8K!&pc+*h48|bX$u>~X?TH*2gO~1!vJDvS6= z0BVj#8w`X1e@xl{XU$v>O(QKoeJ?|ydw@c;->`;4&jnCuu7*M*fDC~iu$NHi>F_8d zYbZ2`y7-i>K%wg-g$>`(BCxtDpwAsOk7G^zNwWxQV*yF{R_~n|dG}|9~DE z6&)+6s~uB1K67KY(Gm6nqn&4fZs&2vLC0R}odM`HT13dc&|dm`G29u`L#Y=ke#iPd z%mx#%{Cqlw^I4E+=A|$k!TOBv>{FUywXxH77nNX&i3__viHgHFiZJj%;^M`X(TYf zLz6bKP|Elo<6;!Ypt8Eq(oO2bs7YWm1x+wRRrcGb>|s^G{zEORa;fiXRuvmn#i0N_ zQI!S6g&-geTo|t~VRm5dAPFM)lsXKh zx!CkUJkL~aGObPLj?@|nU0005q)WiP8t<-gH4mB7*CYOkuCYkH0$G`K!zYjTh`Z** zD0Nz-r}$5<149rejA2pMabw3zo|%?9Y4KNVa?mwxjj17j3;zFu|8McX4+s1-$-P7& z$?QvVU9s&!l);%KB*lO1jH6`c{|bxp--l=0BFUXU*Wu2;TXK&hkGR|EY@v(cRk{Wl z!HpEVVUvfp?o*w)F$r)JDLVYm49Kz*$1_yLbifkMkox!Qm;yinIJRxKF_S zsSZ!Rfcx7KJ{#_$2?*nR`4>o@!bJ$rMfei6;m$*TrMZ0Je_}{6D_rAxnwFj&Dqr}m zNfwlweMr1Uop&4d51EiszHlFl{4a}~!Xhn7qqKM((PPq0H|yjKGV&3GqNn$*icasD zaH#DfdXI-yr3>kO{`3gwop@^)djEGaMfN0mf9KZeeQy?;9? z482_}vM14dF>PVM@Z`aJx{Tg)VHN5^dOtcX0(z(35{BLX1EX*k();jj5zt$La@lIUOlOhZ zM{j-(6NLX+P-EsLJKU2~#xe1qt!|kGsYA+7|I*=}R$HiiXRDgF)voNpMU|8faiL%{ zjJ0ySkYw^D*)q=?R1wF)=ImckW2j7c+38RUtq^jAicc`)7gp}Y&NP)DIZu-+_X?F8 z5hW@Iz2D%9SfOGi3+xptn7pLqLmAkD#qJBgViFEykXkm8Vb9(>XLzA!v{_A=aR}4) zhn;p?#DmnBWcAnwL-se1>-jL^_md4b+ z5}fKX(pEK;(%ncOY{=gekgu>>&EcMENg?s-t8w1dGPpmYMpT2^qRI6s(!1w`?%_LO)AB!ByA}w^N`7EW;uH1yV-O^OM zvLLNcnUY~wz96lsYelMvrLnH&r45*!X9L&Y?+nLFpMmx*c!@lCh?n-@%6N&KI*H3F zUZ+3=ytD^ALd||P=OsP|5yBnbUm`1Y1Jc1JH?{O|3ucSG$u0z)ica55rA6SY*%SrcIk5%hN&N430c6TlQcc3tCiCJhf!}1(>B_t^}1P;J>6) zk}Exfs;QPDa{8&7N|Pzy({&znULaLD{;NXJss!`n&Xb^O-7_5=X0yyAxUyNM1FM`P zB@b-04f*BadcMt4rgi3Dz+{8I?7ae-Ay`h12fNAZ3YC3e4vU>w#8OCQxR&O;(nv+m zAo#F~u7Afk`_K~!Z#d)eb;-;=X>(6o2GIH~`uoEak%nTwA-OB}K*bWq*P^QPsK)O6 zrGVuXNL`DsOxu8eRC?OSCBmZ0T}bM1FMQbHE_}-7{&O>K)eE5sNH9!MZ>RtZi+dZ* z@+E}BrvSjQBcey8WO3FX{oY~F$mx(DtCYRgd3~jS-t|)Uk8_HBAELj>XHzv{JDMMF zt2*D86G(S4DwFQ_4Wq}e1!9x6jM+o=`Kx~PuYqftAA>~|8L;?Ae~IYwGRwReXFqze zD2RvU@<3RI%Gms#dj54f4_C=a%FPu#Hi^a35UF?=FTk}W69yY-n8Ygth~mUaw{)?h z88Iq$oKUmdlv$FrMWyh?nN|y)&QEK|-%6t>{`cU&862jMwXQ3cVsf41<6oy4@DZHW(9>*kIFl(%}DxIKuls0Pn5)hz19A?C3)6;a|nEFeYE5eP`)(qz!8k9Nd9x7&} zL!@D(p3fpfNmmNeEx?E!HTl|PqINMd_NFet$lQB1j4YheS&X#9GC>%be+)4a(71tc za$`q0nNQH6;Uw+3)CNv|oCTb`z=)GK04HxGoE*n-5?k+nB-_Dyz3|=hVe!`iHH}7v zTMqk1P=Z$j(eM>zXvm+c3-AFBl>-rD8LeaG6vRh>l?Sc~hm~Kl*ifwOkGP*YR+i1x zvGM`P4FSC*3}B3fDWXHH{6k?FtgK>@p&kC1VCBPeG_3snBtu<0#>)SjL|Q6gWr@2J zSUClg%pGIpZH_QlS;!(oN!RsQX;(}(VR@4_1z;~3TF*_-m>EEPU}~VmwJR=Qlg2al zN_i5nt2!>=PrbJ;&N+mfc!%z-i;+)~RsbpJuUyLBI!D0D2#I#Gr@uwMuSSMUGr$jd zpu;UD(vTHvcPB~u8vOm0vnfQnT^{D?853 zgfcO*@@sjt=&?dsId{$#4Pu%Z69tVT+rEYAvt^c4edYk$x%`ezbHka6RQA6TXe+Uj z+w5J6Aa>6lWwApnMHU#iW8k`w>O5IZz80T>@D?j9Pm}!6&|?cdW0F@Tf+X0U?kNnT z@K@USFD;Jd<5lxu;Yk~O4`yNFEW@=)s6?^4VtQl$8bNHsb zK)Lf!ZtLF0L|9bd+2(K$B?&Rs;Z8}f^*(?qh{TxX`5uW<#W|DlYnHFaZ;YIfpS=e% zeLTKBr%-7W8^)xWUH^#@8^;VMv&K@h6Dx-{`{}IEv5A#_ISJEEaxXdz#@$C$YDv&H z+}HU|XSv3T`#zA9_{3-a&IH zPnyc(9ko{Ls3ed&FiD@H?jMg4Te+6^&+%A7C1J`M{nLRURzsY@`X{zBh!K^qZ5el@ zVuPr81^5g+9TS9_WUNcY!vxkjX<xnOrb ztB<++IlVEfFFZgSA|o(2)>XI5BhnC3CMklr@-vW2sG*T0#^FxDNKztJ*2xljs^k{f zV1fax!KUn?&EPLA$s8zK)cPv|{rbgAfAn+4=S`nha#8j>w~oBMv^I zWzGg2ao=9?E$Uw48d_9|5eWSDv9RP-YII^r@Y*}#uub0IQG}TNncyN`<4jqN&0!^q4cH{`ej5NQ(S7V@0sug}C!bSg!a1QTm-> z8@#j}lVJm6&EB}9wjk7){VA=CV$t8@mRfPt?2U*6CnBp)wYZ$w%Sl;caT~Qb+w5l$ z2M$EKd0rw%kT8jtw-NNI+eLH7kF)8D|t9cx_Z|CgW zC=T3r8IJ?^?VNoL#ew_I<#FJ?owKtj4%|0@;vTb<;|q-Y_)^R>hzJ{fNdf-jt+U0o z-|rk6!hrF_cl~wd3(5%zV)o|J9O4jVy(qle07*eq-p$75AL}74h}m9cw=OEgKvdxT z!vuzezTbIw9r8ogc+0XC#R7*Nb|~8D<4!1n!ijSWk|9H!njK(O|HULjG%y)r3}lE4 z3^D|DAfpV?z+{L9vpf!OK!y;r)j37Jc$8^QfzrTbh<_VphQ9k@rfAXbP+<( zM2HJD5rW^>`G&AeWA=SQ=?%}6^^)?WWf#fZ&ce(;Rh0ihcDkAFnIkpDwK|Iywe{YMi#nEo?H*MAzh z{xc?^{~&_&pD_Xb2N7-RKNzxf{ii|M6V!j8JZQUy{&*280R1O})DLJI#?c5f2Kji+ zF=cc5b_qI=ecyKuWvl1ffD*KYD?!1+A%c`3UN};M5D`>@HkV#TA5!WhXhF(0D4wxf zp*Ax`$ez7h3Zh$35wi9D&gTheLVnVOGJs;mmj!B&i5iH6Vp!1KLKE^Wz_K6_dgw(M zpRp}gF~ccc(ZNelbtJ+mky;)1G4iQsd(vM>?+q&VzL6o(fPea1>|b)PqB^9$T@-DhP_(tR4a?&Itt-3M}H7~N;BuKPf_ z38VYe>ADYu)G)eF{R!RY$aNp`{no`#uKUbsNB7A^Pc`U1jW(s3bf2N5`<$gVqy_r* zUn~LLhcS7?T8|%E4`o|8WeXo_xY~mOM_f&s4~8AC`H&?tMDux+BE;-Z1=lW) zsFmh(2Y(EfoJx;FHJ^99S5qW)MacP_??P3Zi|Bbk^*IN3{P}F?j!-G^PJhG&)E!c7 zxVp0!q$agt6jN=uy7Rdfm%~&WD|>yj7H4Cs4Oe$oX>m}vHPxn-%A=_^tyG@T7@tsv z$)vXED$htB7ozf<#p6O$o<2M-MCI8_Oc$xjvpFi2XG^Kblww^jfXc%K1FrUjN(N!{ zp3j-y^F{}H&)HCRG?^#i|Ficl@KIG)+ju6)KnMvFkU$WSQ36JS8VzV-KxQC;Gctjo za?z^LVpFPC5oQDnYSKwG!|_;KwbfRwt+m>luUan&cu9y50s;Y4q9~$x+2e>tR0vR+ z|MTo~&RmiSgiF8o{oeoQPcrB1voC9{z4qE`uf6u#XBg`qXbc_JJ;9$tV}QbN0F#xj zFig&~IGZL*%P1BpQ3}KK6uD?I6$TpO;wTJyG6>55pfJcXy222%(vb?o|6A&Gy%_jk z{G|&&kd8he+{g=`7J2+ib7S-ANl}}9I2{5XqM5Z^Lqmm4Wteeo<}(WY3P+uf4dkPF zgRFuy@8k{g7nvBlO?O;7oJOoTx`M>|yc`kNm##2zT|KdzxSo4vH*np2ZX8@!%EbRR zTsO=yaedp_Oc}e6t@L>Pd^kLhhmUv6Hu3$`(M^2o zhIa?wy=TY4_kEdo((px`Dz~~C`^0itA)dqTD~^eF3Tnl8R(g(pSa^5N5!o^}_NBRZ z$NwtKeQIng>qj*^jvL?j-^~I6I}RV|G4;TNXoC8FTnm>chyq9mDHTfV^{W6xUVeAz z`6t*@I`NMt6Hf*`yTGp_Vw7v}IZxz)xyNRjtn>GayNBsyLjoRoq}1ld!Sr#Ncrq~U z_Be^g_4&(9TwfdCJzU43YmO@IH^O$(sZ(oZqK@hb$%NzR(>E?N@!USHdw5=sjyWox zpPUs3&lZ{Z--GAJmzsEfRn$E^S72T`x|IJnEGwNl^fQ@wQh7IQlZ9-vEAtQJ?@&M2 zmRR800;A{~{SSpI56jcHr(#!nX|SL1mIhB8c;O)J*5R<2;SjspNHZC>33!$rXTOi= z6kzaEoVNFBH_5gKiZZtSy=)utNQW#PzEf=so{4siL>ybio=x)7;cJ6^aoF2(doRQn z`f4N$MTzp9OiK5+(mxTE-za{2qh?)CWfr*(s~dqdIb)ZzPp4-S7u z4vQS$tlq`=^^G4{))j82cN4eo26u;>&yjfGByqHB@}MZ>PE2R%0>6%(7A=QIPdCTy zg$3Q~#opb*w0K0EZah~ep44&MQGYlRu8wIYu2V1U9EM6Hge+BlO|ZQ@iTJzmDl1cDD`ej@)_i^f>7KQ6`>@(RdvF`1~biKfadVJxuQ# z&>c+Qu*bplC7F0KFg-$Fe&p(^FW*1Edl+7c4mqmk7aSG`!MA1N33F-}{pcItqf6W@ z-Nfy7biq+^v&F;hAhd@6>8jsGoY%d6tB0&Vx+Z(R#G}L9KQs!t6Px=xn-j~+ zZNsYMvRldBLLcqx_BZszyJx8FMaxCWsotxVP=hP9&T}aY!_yS~qj$G!RfX}NYh~!L z{-2hdIwAxY#PRL;vjl3TMJYlBFDbr;6qiq=++r)$(h`;ZEw14WuIfh5W<;1#1|t^s zy0D*lXZRv1)UvZsgg2-G&Qr>Z61{y;H-bv9PDK3{?W7oH&~Fj!SJIyZ!sDSsjJ8FmEx}Id%usY z&xUOswU>ArzKQpuww>VIu50V6u3zbO;r4SC&hs|JZ)crX8g;HXVx6QwSM?U^_3AkL zrNb^vt*61`q0QD{!SxH?eh72lVcQ zXESf?FONXzcCD_;b(L<`W5(b|n6+NQZ3Qd&h9_|K_=AW`dGvj`YOlboG_XC1%CSh+ z4tMj=sBZ3yZXTAcce7ROO=it8J)`$0>g&P!@S8bQ|4rwwS+_ZCOlSb6WdFc_L7tEg z8B&em`oYEc+b{52J)O0q&W0g+oqy`B|2}KH|C;X%>yD$8^gTB&B3+4nN8A`vn&Y35 zgCI@yZW-*Ct!Sy0@Ss(@fj*kVncoC|30pJ1^WxQA$k#5R@t3stOWs5e z--g*4sk=ZgP-oa4&`D)|q}AzXNLsaqX@&GCTA}5cIT3ob;?bZNjyt0cgI?m%gK)*v zN?Sk*05KD-mSzd8=EzTF$Av!!9et2ay^P`-0ZRpUta)wJ)I`aqQOqCB9x$z72Pm`f z3t(Ba+5=a$bz%@psHNaO*FupNd6^?ZmhhK(VsGSSf%qiyqKMYWOPSaZd08r64Zrv+ z&>iCG$a_6FNj%DTooB!&rFPkA299*n#!5NhN_ z5w}NP%EZl)m!;y`@QY5_%OmfSvc-5OMNJ|}mP-YBkhlwp?cl?YW#WwX6BvilG$ZD| z)Ag`;cy83?vYP(JX~_xj0Ptjqd8dOOP*GA8UayjgTdvao3m+BV`jF^@@c>08Iln%5 z^~!Z%jyei5@dc9AbU$;cttjiwz`?YSpfciA_Po%+P;j$?8!fgV0pI$m>2r}2IjB@( zGz52WNNmPPL-zBKU4ex$c4mmip!2iT5u{3_rYB1v4ic4-;sHAwAVj!1hGzUkB;j?WLGzYGKT{`!#0ax4<5umjjx0r8EyGBS}%yvBa+cpJUxQ@ zZjww2<7d7L&4GUC6vd;(6|#SRDHDp)M_?l!{-c_8IVTZlioJceW+Zs6!U_Ak;{StQ zZU+VfSX4WO=+g9kWK^iLsOdi+tdFQv(FZFa5|!5KXx+pddu2w>QQ~8$BnHC{RnrTQ z4k|yy0g2|*ITzu#&%cRvjOG*}VkbVi@9*T3J*P(V$!)Tk&V15@TymU`M3Vrx6Q3lZ z!`1Z1m@UF52QbROCrb{Qd?JvbkBM8@>{hW|jzfb_KHV?Jgo5nklS8;PO@UV_{Cec3 zLNv38za&F_ICZ7o zL<02IvGrqU2QQ!mIEX=~V_Soqz&0R9p&{1V_epH8ME0;)6PuHc39U|j`r2RFr-RsB zcTq`I({q6k#3=(sai%?#sWBZLbv`5F7T}vZdyb+agBu`V<%F~IO-!68kK5uD0;>&WUL&jH ztysR-9Y@@U)a5}1ggfBy4i055V^QDylmvC%+DRFfQ05{eK(9%bE4{elRqFHMxrI!4 zpx}xOZ&oPt9F!%Xb5qt%VO=Bf&YG^kykYE?cEJxs1nV^8-YvVLo+mF@VVJ3+Q0CiD zBq#XcmFg&1mf=lR{L4}ZD{Eecnzxf8c_PSBhX+M%!(ot6=3h~Wqpv_wahAIqo3s)J zIbTYgl)^#Y38Bm@jkXKs%BFSH*z{a9jcY8~^uln{SabCR9c0su!6d4g5`-?$4l@ed zPKoF>1mK{eeqC^-r0d&%j-~4+yc2{gvF=O8(RE`R`Utv(*=IV9XY&3CgeS}3R9g8( z8NOL2#}321)=^N;90bEyylD zqE>(y3kw;@N#O^55rngjq0E0ij+;T%7gFQ`{qk&wOWh>-{Sl;--!JIE?+%mSOVM{> zewUTf?w8*j%Dj$6)#?<&?yuHs*57>fDPSbPQT-Ihmzk%e0hN=C@H{sW280*P`?Xn>H^gf+0DmP&R+zDfRy3DxBr zKNxky-{v0xePyi~2ov2{uLtKs;441Z#po>E49?J8;Yg4bw?&8MItQ?H+GZOh6SH|R zvVvXXdwt;Wh5EO2KpfDstep*R&xO(IM&iGb%K*UE*XW{**Zz5F(_ z&QsL4DL`S&gqpRnm~*wSp6t{ypg-=Vruba|^U6he$qC|4XlrhD=rtM4j03KX?)-Of zQ|*d%u5BAiaZuG3X~+fVjbAfR(md49hDbR!tZo!P?RQLyPZU?6pE1g>&9)rnW8%!pA9;E}vkhbRLHq0F-%;W67_? zOkD5O6pJ_yd=ScPMJCv0WHMO}^XFSgimeoHm@`M%CiW|Bb(lrn{`6*~MPZ~@7hd-WFO?3p#q4GO?+lKQGA0?gR5vfR`wk@Dp6)x48jO(Uw`_Id^<&~!rIjEv44E;LEb|fHF_eb=g`cp;_n-5cIWcC)#Q|N7^^i` zB6mgxE56Sy-T;$~JX0ezxN(83?W^o&Q$GowK469pm= z0w9wl#hiXiX$;APPBM1JXILTXkh}_#b>gKk5O^?YMKC%L>W{3&=+c_D2%)-wVwa?c zgyJpI`A1^e_yGJ2*g_%)Dt1sOOwK~WDy zeft-`;f$#-Xz}g>D=FF(T34FLB8b3sKDq0cvRYgDM89XoVZ?_i3(SF`2aSu_ke;$X z0^^Uv^bUDE9HU_R4vMNSmS?lnpFmBss^B-vz= zY%NKajF$Q#%~s8=G=pxF{g+>HxI`-}3-GFMDOFA*793K6u_sD6P%+LtYKOLmGt6>r zGU#`d`3~CyYaxbCW4u3U^_h;vx)^{_h)qRL&swMs3BgI?ORlHd6TRn)nfQd=<+H>x zWUQ+94zR8KDibRdb(>pVQw+mc8Zrd?ia&FHR@VhTb=Y1+ge<7YQhPlX$Hgd4I0`PM z4@KcJjJROa3bXyyz)`p`m}8JRJ&X*;xkTn^Y%#<`=4@mIGTX7`eDaV1UL|U;QaYM) zdpPheM!11%O!_k*VZ8Leb&2H~dBTZLl8iq=#&~3G$B+aW@5L_m$s^-Yc%tyPQMg3$gbO%|u>dFrne;F+9( z{4OCrGJ}v6$TY%0dGe4!KP#GZ3@5L(&SZd6h& zyOLUb?Po9At2y`h+WRi)QJaoY+F03845?AeDa?1EkJC1}zR{@`H$(yk8ob0GeICRX zofEQ}BB~dR!mnB7a?@9zt!{u`)5g_qs~E-{TKc2-h>RX=uPS!`AZSgo8kkk@*Fy&ntf;8la(zE>m$LsG zS5f_1P|GHk@li3T9QnbT*N@ty?nam{kbB5(wE?iH={Mq2DDyEi0O}10Wj=i$m&aoI ze#xK$`nMlCcPw}5bt^^d7bio>$8}nGL}VgEJM1zYel78?&f^uFPBkERR}PTBvWp8A z8@W(GCc}`CK{<%Cj@Upz{D)2Xzwk~;)2Bz{;3(_ zA0O%PD_YtG;-~T80Ux{_3y?RTzz__0dk_koh~~;yLJ`7nQ62=V+p2gdTnWKeI0<1N zJ1)F&GvFNb8}9owx+TI8C;2IS|3il>5gkYB*ZV<=PW@^}zhaelp7-)j9eb^jU*9FR z@9JL1ZZSHxxCZ^ozAPYB`9LeM?Bx8d>PFei;=eE_>HRw>l=zw3iIfW_(IBD04jPzIyrsTq`*J$*yRo`$vi z2AZ{T!y)g0lt%0Sd{66)Q=+bO!$@fl%z(;)r11L(x>6){hv?9l@=lpDT=(sk>M<9W z1I0ZUIZo~B0hkPL!5C2+1KZL2xah#`zX&E@UVgU=cNw%vPJe`?*Jdi^O(n{x3D69R zYi_$lT#U|PTvCk4addN#wj5CiZz>g|)Prhn+oh-0ZzBd4lSGd&eycW|x zv&@~lpKhuRhm&vtq*8R)bB0@mwt?M|hLVDDDc=1`Xf>j8rYK2UaD}G#BbIT>`2ogV zQM8ZfVGUL9Js(>%KVqxI<}hz<=q)Y{L$TBQl~ete8|N1zOyAU?!Loeb^RnusS~S?Je?KI)7n3>9dwnf{GuLH4W`(84ka0ue|8{lB%!Mw_M9-I zZS`h}KLp9{S7npm?*t2i-{-)*EcyKmo!_xJW9<7ahj`*;A(Hodv3~7=XHaWXHUExE zn1BWu)&7a+@v5w{q<{nMnD2IDK$NQ3bX-TK$#rvMMGgwGQ!g1b300HDZPh#6#K-vh^2YJ{7Ljf*fA0*S7oP2LX?6|>xT@FH(7mo_;O4i4Vw z<-X66`{3D25bAI>b3bEQl;m9Tx+`}RFF?srwj7|OmwxP8@$9!`ek_HrLt*r|%h!~GTTufgWDJhf<=F+cs@Em( zy~Us2HHQZF)4Y2E|B&e@JsPDc#L@d^897!k#&3)*6I=$t0_sq%fV&h*777?$xQuYa zvlY`Ds9j!CnC-&Aju9`rWEp2IRU^`O2h^4*`I5-CqU6iocT9LOlo1e`qj@LNAYUFu z4Pp7BktYoiGs~?8-ML>G5+=VMVx@diVe(SS7{Ut;Fc(hrP0E&b%9`93ikg>OAtD&V z&V!vIRyN(AeGUc9bS-;1h0Qbaav0b_Fm|pYR8dg6qoE{-MM$8)(Krmb=QLsuOFW#N z!QGt7*Ew9HMG)9g?qlea$0=BXoS3Bezq@qDbw93Q3dfvhs5}_&@?lrS%!1pLKU6|% z90g;}^6r;jxGr@qE?LI01_i-E?b<|aY#kv4Ua7X!;!gVBg)VD{jT(%|ONIuOs+&qx zjMnWCVq*5^oP=!E3?W;Zdl)R2FDKWH5E9}d)U+LoM#yi>K& z7a%SWf~AXJV}(Z9dIl!sEpM}?4Wb#pugdjUvv>v17$Awz*Em4XpsZg@6Zp+Qp@(H5 zHaW;`xg#aGLGm9K8RkaRudwj?&-2hR_j7sSn4fz0vx`G(j4nPyF13%^$tx*ujGmVM zX7PHu_RWqxy*Sd-zc)U1tEc}ClZxKc=e>0zJ^d7vS+l1<0|4yl5AbXD^fo-Br@x1+ zkKfbJ$wEiy=_kMYKhe{X`_wRy>9A0bcv(Um&((@xb|EXOCYzcK@x#oA%i!=^i+@-cd9kPKZ7Htt zwu&7zC8#A2hOr(1*q`#ync&_iq%RPkK%)lIgF1aSaPHsfLl|W}a#Wh=`7L+sz1S$P zu7~2F*hx~w0fW(6_bozhpU2-QfV>m9;7dEq;vmqDmCHkuMwJ#01P?cRF z1w)&w)?8=6sfvOD>jm5x5w%`$*&eUwdf{`d4<^A+_9hKuQI!7o=36%M#6wo5at- z6Y}!ca$f*a;bUZ#>xc%{Vyq+3+r~QLpgssG9Inl_?`uU3rGrCqDRGb^t_?Rj8tVwp zLoW4p45N#chEP(uZ+Z4r=WwsFIQtqd4$hQ|gA`bquFak&)eVZ6t1!1i-xr_YY=q>~ zQVwN^}T$G7>ASJO4 z%6uirM+UoF5|kXKQgk7(IYpy!TjAAFXV^}pPmfksQTsBaGh$X(j7v=L?l*0Ok@Rxk zxQVb07#~Wb_tffP@G=^RN&n`J`04j{k$-6y>3{E{p8F!{+=H8d1q;F8a{y)r`D~m| z#0mg@AUJA>e;N3fg@5)MCv0?)GqJ~>CsH`JY$V;#tIV?%Yn@qO%L9sba|-v;&Cpe! zq+;vWn~n=e+rCLkfT^oTaGDU*7oaa<*{RmZ1)#qVo_JD^x+C>rt5hCsiZ(k#Tm)i3 zH&rWns_&^pZ@OSI4HVeHTN3Q_+%G{g4_W!5am`119pLr=^; zlb*NY)*PTI^SUxb-G+mqwUdz2jl5bHc_kfb@0W@? z41-JG|3-6j1LN@7;7#+V>$+@5uB&Z*r@AU`&5~1w#h7Em<3_XY`7{)guh?)p5PpUa z8U5GP^)TsT69W!&v_MNs{#Z^%u`XwCxQbfLJrz7g_Efq`4_jbPQR>3t+4lIB#Ywn} zEb9KTiqFrjfSu+jxiFS|UnsgCsk)xOdGJ@K9u)(XJlV@SAmbrc z?P82vt^@UzQadY4L-6*?_DPMzs+Cy~b!jW6;erIJYshchP>SudPPOZ8#N#(tbNBge zXcu`SJfib59EVMI{(PNLJyqEzj?qcD&!Qej?oXeTRWm6^-*8L?$6F{BmSsh_F_u1^ z`LR=5x0`KgX%j@z$!H9X8snKRp6kV@Yl#6O(3;y}9Y<+=KL&1Rs(W#+5oYma8A{P+ zTlJF^Otii?dvmoJDcU9f7U#mI&$U;Qc!99XkLD_SDn#+5jG#x!JrG%CbBb1q+Of*k zMo-YEOf0m;XegW{@mW|fUoUIgB`>@(9U)+;r)WtzVNam&uwoiK+NKR=Nz7WltJi zaQ0J?|D0Lmc$|8Wzwzb~$1U;a5&9v7GS9$QsQ(=zXrjIhqh9$Nn6pO8W$BO4bI~|Y zZ+zE(^>Y9n`srrOpzkP!H>Y@d;*LDt4usPYg@xeV*(uueWU)AC_R)dY*+)qrG}fVh z-0R@0hm{Dt+oa^47tOmczTzr9!{Y!udT=$6h9X1vEB{*WEvvRPEqDr-EuA@3LtC7s zPsD%A%jh&OqUeNKJBArF1LW6nR%V|7hK zK#o%`l#6K}$kbU1Uj}1686Xkip&l)e&N}SL(A~1kYfqYUEtO#7qi{MZ5IUdiQ+b2 z?g*YBZh_BWlp|i+#KXid-h6&*gE^ni#}O;ve5laA`Swogq@-57@`cAxUh&VcOFEms zjLng2Q5xElm`qs~^B!2gQNkZs3gY8?!1kd$fF0PeTmHrwgAUvWi3Kyy4omNr!H$CK zay-e7n(J~D|8-cLT!+QUb@o6bL{fR-S>7>9;dNQw5s_SC{^o$3t6$oY3-hNC7Y_^Lu%7&S{i(6<3Ua3p}S1`l@eCO5t3w}1uUy7Ir}FE0owAR*X>~ma$^`D0rTX@kA+$ z@=rKM_Lu$I)t|7h!6AL^sQ7*e&cM|H`rW$dPIw79v(`FuBIh2cWqFb#N!`x$(+*@$=^EE4W6$-nVdL*Ol*H@Yh}vl(v2oI}mIZ#5#vaK6j0FL35~lDLwM zTG&cfg-^1<%c|4hX?Y%SIX13o_noJ2S3d@81ME8=yl2{d?}g=2x-P%#thI8_Oq*GO zb6qz|t4Dv>KYk|J<#}k%m^lATuEWA$0rG(lxWt5bqP`D)DC3`bOqjD4iw3xY0y~P? zybj{mk-)P>5M2@RJ6>+*Nb&2?#jp7>O8lZ+T68%>{Mu=);d!|Vv6~(c#c+sGH6lhc zOE!io51kQn96HN#smts*bao7~>p5f~~K`mZ4!;ipX0x&IS_hGifEb;fe(ymY;yglp4Iy@)93T<3?8V?v0?6RKq7}9s zaXr@G27s3VK!_s{5&!qa$UF!wn7VC?R$wat5^VZ#~f@F`-N^w zfo&wJI~d-~CQ7$4_i@bC5e_)etEU#f?Kqz2|m;Pish^S_0H-QUuf{|a*+1IkOFIBf6Z+CAbPbx`kBwO-a zmd=y1%Oy{K0yhA$6boRZ%jdmp^dS0EA317zUqYudF}63u^e2uu*mM+2B` zlARp5*ya9vsgOMyHCAmz3(3<$8VAk0e4Aj@@9{Qz*MC_u zoU#@FeRhl(?UEkl-~1icz9f8754v;fu@P)jLQN~2SHBp+btP9GpdrpyH3cnl*2KZ`_sZp}yJ`%QV8Oz)zHk)*s9gK|Y8wgul)rzCS}v`|_R zaekLGi1ZUtwCaUGn~P4WkY7QxBaZ`am}nWLiW%qNx1?}>Gjd>quw)_7%#(8v9_+$} z&Ci%3m^Dbq*izLCfkbS<3>3t^?Lv2MlUvjH-JOel-3JH{_O1u*OSE`WD^fC?E8Gd6 z1^ezxOysK_ua?h(iRU-N8jmu>k+*&F1mDKs1aisrL6T&}+QdKLxSpMttEE)*%Frg- zgHWOMH@L*?LM8Pzm8=A=S)lEXkUj=K4D9Cq9$y#wKttG27-U`xRq3$z5sfZ z_i~IyMJdVt4B=Gt@j=}=D8!O}DQ7Ys}TR+mX@h?ZTeT$v>s(tiQ)=NNV^QZTD zCkf+OJp3$hSxY7-=YYxWhyjuFACCcXG(PXncSF`j;;Xm|7k_=B#3QkWH;=DC=MDbLWA*(55n129oMx*6Sty%6MJpWW~b zIiZK*ze_KQ-hj#~X9~UMUqfcF9&i!FrVP~*j?*HZtwXcj!7VzEIgfLFS~31bI07Vi z-8iN8@m4_QPuJ)fpjr2A;!pZ7$z6VH1rz=0KgExD0Cq%7m_Ng_TdjZ2QU}#FB%Xsr zSZiH?L`$crLD8+h@rJ&oS#8|~ead!!y>5r$T6ryqh?tE1*%n-!p$!KXKnj_qG2?x` zCrQ^z@ce%GIch)Z&vG3BBI5Fo1dmm9B=h2rIQj%?@36fUIoEeF-~fVmqX8fYE6WDt zw*MdiTS^!h07ZVmQV;f*S+n6sN%snApR~^32n0AUb8=JniVX~TwL@*M#+jbWF)G~J zh+5FPSp5bLv)c8RLU<8R!_X^E`VOndJg4ulby2V~B;-VXHa^&1+8oOK{u+H6AA*Eh zPVz!1-NP0@F1y^N{^o%aJ!s0p8_M#ICLf@j6CH-?( zYd^PW{c|eZ7iJ|VeXr!c<^7gX90~?`5gB#zsda||N<|7zL99`7H+sKQrzIOI={ZzM z?Nmwo6>an&+*o4}zVg=ja3%|4SJ-+fAF#l)I{DBO4|#Y{{C5)HV4@oI-@6PXT+y>QX^k_b`24Kmq_>Pbx9p+yyZctg5#zw7MkW@4dit=(0cQcn-ae55RNi6?_1m zLlr!@b9WkDt7x;*WQR`G#tnz7%fNQy@I2}HRUnH~HTv1cP-FEJE(NrUq}7v+5v~PN z82_$^d-iVA52b@@Zw|5lvA6~I^ow8qckHf5$5v@#OPAmM4uM2*35 zh>zvzrxYDplup$iPCy4BBZ3S!gHUZ{FhMZG8e~|UCf*#t+tgw9`G{TJPwGtz%JSP-Sa!ES| z{62X6?`RtjXj-~H<~KWQdxCufKfq`)dKvo=`bT7vA0c!DMUn5(WvNvJhDE-`l;ua3 zrB|O(x9>nNZ?fjRu+b?`YVtPt63uyW;Jru|#JbtqDVs}OFY`Sgm5*>>j)HdKtQ|-= zejE8H;owK&z>kDuN#uJ32RNn$t_gpLf*&7PXkz$V{?>qRlW9khGM#<+uHJ!@%B9I1+ungXgs6&+?Ffs7DG~7-67!qG9f+lnVGJcxmBFNawBC#0P1yg0Ds|#U z;cUQuXZRb-KsJI_EOTQxU6$bob&FBv((pHyp(xbLTog{1W%wan=Cts)2yD*U+3b^~ z@Fy&Iz*lCU@FU5)8_~fH-iTp|K7nTQOB9SK0XFCp_^0`e?WKfa{EeBcx5W=(7=IrA zR(W77=C>uow8}TZ)xP##OVXURPl5iH zz`ywWN#y}fz@GQ@6}30X_fZNq?hG6{{upi9quW|(w6$7q>)iaU!Q3ty``Bpgy{N_z zcVg7+I3c2B)6wlja2f@iJR^)YhH90wPM3J!(od_*!jT22pttn2t=!uac*I0tj9??> z*K9p|2_oCITVUsQ+J3V-KV+adB!1KRXgWC3Xd1tgmRSZZ2N>w}(b4ntAP|_pF;O7s`Fp+hN<+cdp9N}z~g>}1RZX$H>fiZl^qqMmfS zX=AjnOfOnJQ$v~W1=;2LK9Dq_n&qD8x*UBS?!@O@KvOc{w+JvB8ifq(| z{BV)qEUsgLR5bBJJRmNRtX@I&GA1Q$_V5M5Zpwe;D6}zO$M}+jGFM*)a_-T|>6x#n z-;@{Tcuoz|ar9*N-I&RWZ!M^J4*D+l8$K&r4l7CMg-v4KA5EHg`nqwZhTa3~M8%6t z{R*hwB54LP&O=KIy@pS~L4-JD;kaN%^!Zia7kLQy`>s5n+U(5`A*?fXb3@=8h`^QO z!5}U*B;ErgZWW=pur_JJ2Uk&(t?E@gxYe=CKEMK~XzauIajaNian#(9z0li_ef}K` zSZ>A;wa&&z=gScC2{_(mt6q->ELLYKg=0(b#p4z#y-v{Ar-|iZ5cHE~o5f8ale#8Q zt~ZyaH+MFEyvy0jFT<^Ty)!8xxWG}h$5xevwq(={9xZ$nrf2e$wFMc39n}Hs*YV7= zW)A^~dOUm24d=hn%>NYgw><{X3dcT-XIs?*C^sm4mtNRb#eiIJ2`^PYDb4-NrS7Ca z8dHh`jw%i{0(6+NfE6^iBxl9A;lHg@)j4g_l84B!Bpcx*}ntJ_@%R5 zg%@}(b*X7P#m#6QDB&=Tf85T%?`4M+?@V#|5w0}U=qenu)BC0AGq+7r9g7%Xi?}iu z5OUD@2E{-0t@lBj`KZX-Q~fgV1k@NdrCkP>{B5>h{EF|jz=i(}gO|R|cRP~wdRggX zvQl)W`0x)nU5rkwx*8b>lgsbfnd0`3U5pkG2ENdfz0_9q8^Fo_bF1IsTWcWJW{sTj@v2gzouR#}VM=+a6puG}UiY2Ci75RG*3 zR%Q4WN6pO`B^$(bFnoZ*r;B1J@g zloI2%a63&%3oa-xss7kjHHiA=lp4Q7Ch_^hXs&SVJ$Uv!2nnF! z0mHyMMoJClFEH~jV*ZuLk8I_7He1yXF|g#YF(pRsSFSBM_bMgEMe>A{lo(HfY5-yY zBt{*jZ~4T+v<03F{ES%;ksIr~kQ;L-H!hQMqYwZPF+*@XjJjOv5e3J~7)rX}`2P2# z?GDe+AUOUE!)EYW)+8mzBON4%zq91HB}Q_T%UUTpo(F9Y>C#6^&8m7_>q!Q1-Mul=xpfZzI=fV%lpjBZG%&8`+{weL-93&ou zql!bS^1{&zK`O{cSbIULR0`hbu)my*SNi_qck{k{zHw*_d zl=5bnK;94+K-oGGN^yPlMGibtGT(xXC`!KoKi)JU{b2mo1SVnwAhIF~=ikF!@1pd5 z_(6V^Qp#^_Wn#zt(2KD%6{FiL>i8#^m1i9Sj5DFrFkdR^Eug;m4MYG4VuP5j7}o=O z9sY8^$I$DxD7hc#dY$n=WlKM-Ah%~Q7{c2#-5^g_{9*^7$V43KiR|kO6%|)^jjYLXEydeHLwd z#uB8`?Z?NY zccpt#OqorNEb%Pf=x{(%|8H^(i5+`BySMza9W%gEyp`&=8L`-n(vKBYs2p zr!SH0AwwrON*o&{ij5M($ZTNp=%2wLV8X)FVLy?}iWr0>IWx%%dBO=`3z5rfUB$^! z-Edd>Pf)lkf8?Q@?bk2Fm;D^lDgYY{*F#nlbdmGDQi9ti+1j*z;Pll3xvR_D!B~kZzUjCpPn+JS;wS0tFzWd) zY?^|tht$-yQ_@l$HRnlhI$yhW5sZON@K&FK;3;dowJ;w-C|BJ>g$j%lzG+7)4H#I* zP^_~|JGG|uKfKQAI&w$it;Jz^j z+G7V>yIq+NDj&pk8P^vLwE?chFb_AnwXqkXYTR;y&Q=<}MAf6~QT0B>w_N0eyc0x! z*tY2bl!LYRfZSG3@1j=kkUBV0g@S2y*tQP^t#z3B!6Ms3nLj|!$M%vT1SBeo-=`8A)i}&RpGU_So8=#%s?O|g6qfw@D=ak)el7oV2Y#jO0X-a4D!RYmFz7@5$#>u|Ts`{e^@@?< zrh?Oe?fFINOCeYmk5cC2Kk%QBo zAa+1;HlS`K({YS-SX0L9rZDZZq@+ajoE59HQ|fmm!iT7(SY7X2u{x~+&-KpA4-*{l z@w64McEY)OMMGMK?ZwuLk1A}%5Gsh4d0nA2UfDyLDFyOS)-VW9W28&@DlIB=8+mhp zwPJ%KnBr?s@+MVmND&u-9LoH5Ft*|gg-9QXOcq9o*bROJe!&;u-E9Xs-iFERS6H`I zY`|HWCSDHLaIgo6wYXVl4X`<=)KYWRx&r=!-3!^lEfv?U8-JK}SWv;Ef2R}<(E1sV zD94yabVPm zd-a_MLq+2=AlGcu$M?byE+w7kRKHYwkU$tj2*&H&*Tdo&x35PEqX_j5W&ZL)cCBZW zqOJj@djSucdKwN;uE2h^4y;*^WjuTax8$toQB%C7fPwfB_>*=AA5O14PM=zW4sWgu zcyr;H+hRM8y6L{P5v-4q@W>vYPLLn@`)GBTze&-?&uNN`BhH*dVA2~0)+zoV2QG_= zi0^8-CAGr+K|w`;TRUruKPaeFH(?WQ0DCDFN_`yR5z4fTfk4LYBQDBPkmr`Ou}vDv zoR4k+t?U>wFyDNTLw4`U${oS;$nc~2oDv)%lawaF03#5lL+e(~Untod+}fkbLBBXS zr83m0?{Jc>`aGFS>R>le2+>e;B9mquQtLXYJ`FTLhUD*n?l-GSnrYI+b#Rgq8ld`@ zMbGjARH+qREU$E1D@BT(c7XA3tzj3W6-l=R;gkX@y9o0c7^L!00(A97kRrfNUyyfJ zE2)ov?=$pqJb!II8@hR19sLbtild{)=-yAo&jTNZXx%;h98>m&_+?}ADDm@fE)c&a z9pKgqz1j$>gryQU+w1Pe2e_BysgAVHQe2ju)m7QsB4zt`QTEiX$~w)miZzG(PMs$Z z+4j3Dx`5kamRD&fkF|hetX4PMsy1^sQ?($29QJPYJ(nLc0f)w2xIKZs$a+lI$}b+n zSmd~P46H+k4iE|W;8z2SqimVckK zi^J%gV3C64JCRWEu>A3iqSN#UI84)T8cx&wpjaloJ#lTa9a4@dw`1~e2b`92!#}4Pk9GvBwusDs$eyVBBUbCELeaE%RpchqLC<3MAA#!oTE+1(0iO0+$pX$*3HZ@| zaWO=-(o0V2)M zY))HWxKgRkg?K2%`6TCK`1lM{?M%T5C1*WSTA1Qs3eG4wcOj*XDf3*uJr$^sAKF+e z6BCd_7DjchJf_%@A`7EBR~b_rNSVh{@@<~WU$RhjE_M1#mfBu&E(dK&mOIrumjW%P zE#pq2hu?cL}U(!jW0Cl>vetrZSYZ^Yr z(chwVvlw0Ly<6kwr`|zklXpu=`>hKBWzrX5y1^;7zp#`#)sB>F^pyMclpLg7uBZG$ zPrQXG29HF}BzDHrG|ZaoE7%=FQE%0+t00;F7|r{w4<3z3qirwq_j zmLg@Oo{}t6R5=)n(g*2@Uo9orY7GZZQF@x5_^zHPSBXXGA*fD3a19fEUG1nHTZe}2 z1-cK#%&@*D@6mDK9v#JB+U7p}wsx2j+=X=xklmYw2Zawd#L|Vmar+;V5&{dMnK)lT zYQjqDbxz2VyP=R#y=oKv05biUa0T<4z{AKX&H0cwIE`9vb@B@2YS=`8RxULdD}YZO(M!ObCAGLR6o5@%f|>8h2s zIT7;jB3Lq9+BBs0XDT%ZX4JpJqw!SzJK}ip4!#cGd$)>%_Z{z~@M3_HNZFhxtyY+#Yd_ z%pm(UinI&O3}1@zGK1{cs0>TZ3}1*LG6VZGs&kBaRBt6H+OezXtn1K$cgnGAK=Pb; z6M1^KVhZNyb=Jwwo(;iOJRa=}qhwjvar`)MSK?!m|1?xK*3ZDY?tM4=@Kn|#0eJ4ZxQOcN7#v4s|W?;qy}<2Hc|b*GWQBt zeYXT{1|O%@$bcmb>9MB~+`G3k_Xa{o*$~>g}P*0i76yMQi+YWZih}{FHuwgOtE9>av<)71{6h0)U z&MZ90$<$V?9#XWi_dSR?^mHuioKk-_=Fm+-`7P1l&2*eR*9K-I3t}CRPvxQ%BUk%* zmAcs&z2@LG$F4ba&5>&kTyxxphi!P&LJ$tf5V<$$Q+K-G8HAW|tT)%Y3Yt8Nf1c0A8nm2m(7ulh`XP>8$I+(FSoycXuaF z!~T)>CT&`ZvkrbmQ4=r9;4^0C3S@9=H)c5NGW4QyX2myIFQ(?X$e`D2q)2Hyd5$UG zzZK(U4p~28kyD7GO`d1w_(lvy4hUr|j5dkU5X$_W0eWx|mPmtQ<%R8o*t1;lOYMMztbNf z1+CllM@T^HoBAW9--T{0HakSj~zj@(x!ZHTyni)US*EP~|82AOK_r@D5=>ZV9MSo7?^L6?&hG;_I z8vR-3p^k(6GS6iB9M``6#SQ2u-*DP#qkY(-{Y;|QN>X>1HhD!Gw}tDVqRsksjgQNU zV2dyMfHxy@mjP9F>_gOr@KQ!BTRXyulwnX}Bp>kd9^=(N!twu0SMn%@Jhd%el|w=L z#P^1wZ35cB{wnO-@|5v(6ouG^l-MA?lrn2W5c>^HzN=6v>lJ+nl+Jm>stqOT z=G@h#>e?+LX|?p@ZV-vr*Z0g_=hDW((XX^kKNr})24bMCM4OH)6{Zv*zwYx*6^@z2 zw|DWo%&*-w50Ic<QW}8i?DVj77tzx?- zcsK$`49=IC;$wh?*(v&GUsFmLzJ-9#rB%TfPgbTa8!165RyS*xL2{$co!E}--KNd8 zFk1n#AsSb)cGEjDp8+J-U@sycim?o`FMEgC?*)wNb`wZ(pR9^G`0+t@r@F!Xikp5G z%kRb7vVHu{$uz15(1wI(nhwvh{mjEz2aTF_n0ZFUG(@Iam4x{Pt(j00;$)+_sXbWL z9OObhh{qLXh~3qCcSw}bi;@J70c_k0XErHbMW)^op{FE5=sol)Kcg5jibrGy6YFPU zv1W$l$RJhJ-fLkclS(Qa8~=Zxr$)=c7(3DPKZ!3lX(ys()et0bzL%~juTUmKT%u3w z5JgAPrWWAwX*_CPD^-c93k6(G@ImGHgI)s3$2W4lHuI3c79b>BmK5HuF0xF-OS3ntnw@F6je0y7rH7Z9>f0fVSZDmOPlXE3^L>B9tzyRuNrBKcooGpgle-&nn8Bw#vy>}B>c{t=$ zY^-q?bTn|m6oJj_5bo zX)@t_!adqAF_FjJqs@e7C--RKL(qA%Qm7$qpS;?`iM_&v;I(CJ2yLOtY0y=M?krCj(=94%BE>ECo!CY%(I<;`Ha zsKpYtDS=7_NQ0h^?_sY~A~MhOW^5eA-oj`#eb7GtZ1oPtR6eQ{*9P?~g_l)2K6*xC z@6~&HxxY|MM?ozLNgUyC$_ooUS==&Y@HsfG!Nn6rdtmeBq99@r9SC`c zxN{q@CzG5~j+>G+S0Zo6(qyQ*K=3>^mW{8lmN^ocfnf-^^~qz<%;f1K!ymqf!-C!< z00e+-)l)eYvF<+Qll;rCJgiMD3;Y;qY*jq6$cUX2a3LukGaN%&gmxtm_axpsB;IHe z4}Z3L`iryKo|V31hh%F9S|_&O=h!_f>)Xpv|;b@@*f;7)-Ejzl#qmI zS6qp8@2WG<>4BURC!wS^sE36Rk%fnq=d4m(D_v5U;TeFg&nU;kK!mGG#7p0DFeJ91 z>l2YTBls4s@x>j!op*jz>opY|80+0|s%y8}?*1i55~8#0tG9Synr=q%RL^2=n+Cu2 zeK@Sv&hMyf|2w6Fx4MV7xVC&=TC~2@HW6`Xnx|^XW$vPSk4=`s87suyENbz7?aFOY zwj6X7ZS|h(()yRJ34FD6%^q*+n(wzauoIEb9{h4m`x04{#>y?B}m!wmOf1Fm(r@>(fcPq@+)+wA6V zY&TiTZQh1*+xB`Lw1$k}=YXr12XL`HqYV7pTxz{epcHs-0bE}%UH%!IenT!@%myWC0jF7)1zHD7<#yyiPkFTH=zFPNTu4R#ku_AyA=H<(gU zD64BA6~94UboZ0pbT^=i?U9ZUO+`fABZ2gM7$kHDplUOq8l-oP$Ltz{gu8>+c|VgN zr2!;c)y*8NIA@9EuL9TdC274&ZRp&dD>rhl+!08A%%4T&3+d(1>W!Jvm;PpoLEkuSLAHBOde1oaw zPF71f;szPNcB#z~mY028YoaumC=rsK5*^QW6P3NeH)5IK`0&txgG42_5xf9Y5FcNn z63qO@89Pu3Zw8V0R3g!bNZ6_z-~bbmJ%RJd4_ev`j9Yh6gC~PPXOMvKcf_y&0soVu zw`*3y;3>xeYEy{Bh-x>68@_|jBV!n26k|BTz{oSh$YYZgNtBrD>zKL-0oZb1g9Z1p zstr2&y5#!Kz&)1xN(VQ)hpz*&bm-3dslV>r6Zs=y)EPO&1|v3q*)1 zM-34V=F%l8+LY24qN8itM1MId?9mg!3BV3sE4SSQIpf7t5C)&qzzM+~mekN4L2k(L zh`ct0wU(UPLAJ7AbJ6{)y~VCvgggHTqj?J^EC}fXU)8Vq-eXWWETlP^eT*?Ms6$1D zkdCHjSI@fiBAbke8ZQ0Jxh_0lFn!7a6U8(xwMA+Mu_8;?45ZBJN;BBzN#;}!)+vh? zT&tljzFew8Fm;<(YP8$ z;x&hF!l>}b=xh43S3VmGMAWmMuIJfa&+_B~J>PbD%9W#xiMHAGIL~mtH==*thgpzZ zV&`mlocfoo`deAc@#tW>!t*T3hZP>~X3H76nh!C0@v&-QbB|98lZv6;0O*?_;$tWG zg%*LiD~`e#JK|2xn`*shG5e?iYZ$2}{{p0t`d449WeQVmRR>5ht}woil3P+}HN(#a z)7_Q;MkJ;!2Ej`3NUHDpDAgBJ zh^a9`_1zK(0v9=^*2W+OAi*KFDxzv2)quwcQvYJP$PheUq`V$o2aY3VyV8NzN9n-5 zY*iP==)h-59XJ^}FyV&|%t6tK$2k?BLC#Sc=0S$_v&yL2B*`hJRtR zGPqtDZqk8;d%)(yN!wH@91%}H-xu=`hm%hHSI@%+8hoj4TZkR!Q8)3N#u~+6VlP%d zFJai>Ev4!%Y)mAG^>bkae1+~#Feu^ZVo8d+G;RMQ_aZ@V!Mv_+9=sKortn_wYqRYM zzK>EutHrakuyG;7cJ|B<1>Qwwm%5KZDz(XgxlI||tPICkdlDZM9Poyh;F9wYiPVM# z&XQE6whi5n|6t16)h4b(T}m#Xp{W~YwP8(3Z-AeJr-+-U(T*z(rbq!vyk0r5s= zD?_{*+VD1r-7wh#Rv8Oao+7}ZV7Yk)i*yPqFIMYOrUZ7%A#PQxAWZ5uI5mbcuK;8S zF$!1cUI;?O=y2#7O=$~v&4}qZ&Ujl^f(Ow_OA?Gg%kXkgOYKVjMq!yx06}XNv{pfD z?Z@HxfB(nai)hd8%v9Htb}>xV7Q&VGYUM8C4@BW*1v*r=#lA-QBJgVhC8U{Ia~3#j zdoaJ2>4OTQ6qdD-Fc~zQqB_`&mkN2)URir2sow75eJL9h)lZ9m;Ca|oyEPIcTRn6t zk%wUI0EzAm+#m;3w<46wNCJX&;LjA*x68oghl~Su74}+murR^fSIjPDcd62O z!g;-X*6|JJ7#o%2-*Oj0Wu;@!I-g^f)_wJD^P>HqJRwPzsdwF*L&yIH)W zr)4o4Uf1idtVX=5Ka)OU4}5GC?O!=~enlttGF)Y3?dKuEr?eqnERGgI4D=&T>B1+A z_7ThY>$?N=$BiD-L4O1xW)7?Pq5QHI8zD`01zXeJXEA7ujhFCwMeI4u4P1zv-Rhd- z&P1?qm4r2KBF+v#A0&CJg((JZok|LH-aBC(r=rc5SsZ2i=>CLyi|abJsP8SIj2@Dd_n5X7TW~ffGIElU z0Qa8o&@tc5v17iQ9HPHRkDd}JDsuFs8KZ|;QuW~jw+nsv7-`1%fo)TcA7Q;#q8Ssy z?5O<_+4m5&m!iB@O98Ln+@o5b1~}F0cmd)t?#qmpVcW$O*y+4iQ8TOV1+WmMRacSD zt@_8yeuNiDVfcR<@yW30`&2fr%AD*y3 zJSPz=F@DmE3{|)R=sjIg@6KkuJQlM>lJMbdT~xeI0OsmJVsZS@jDy$o(_n2&<92_N+5Op;X1_azv_F6eECc7oA-02fP#2;KzW_5-df;*imE(d7#Pwg+G zilzS;M1*5>l6VR;kvcVFUqesZ1FLN-KkQ}ub^RGFcu2uRRf{*tzYL?R3&*CIp6mLh z6Adt#<8Cn>&xziBaLNa!#M7B|5^)>>#YW=zI_89ZlQNQz7a1rr*n#BTiJ-IGHH}N? zip4?c)zb?T7) z@L}9Ecx&ZHR;Xr`s}nQ8^Fyx2M*SX&SpW69oDN(J7FX1%I4Fjb(PB3zNL)S!pP*Sh ztov8iH7ToDo9^7-syColnkXx^u+k=s0LK%WQbec?4O#U z53bSEy!(O$`x+9xWrf%Gw^g+e^7)hc8@v9!#f?xV*z`;I;G3F}h{BPQ#+Y=eZ$VW= zvRF~9=l%m&6L(bCC7`+C4Mh#Msw-tmmIQi#t4<<=B2mDnO5kl(U%*>5jKKTQJ_!PE z2|=Z{m7_-5(%6U>kUg{S5OSom0O7 zNZc>K8t*{J5`$1+6jDJ5&mD@2S$?w|;G;3Xi>CJXUeDss%i`WiZnbx@x(0hD+)p0P zjaV*Kw2AuIO)d9*{=;(LL0mS7FV0YX@Iy#lY|CN0Vzkq{50?{prrK6spJ77J`^7H` zgB={w2{G@G@K?7s9ZZW_Y19=eH8qnnHXA-j!peLefB%_2-J)oiw zRqRnvq`dGvTh#-2!1BWZA0_d^OgZwZD)qD>NTW93hGq{DGacE^GLj1Qq;W_ZX(TO` zg}oQA?46K+(_;{9Cdq%viCmmEN7iz#iU}Q4$8A=5HyY=uf~ZieY;Ujw+Q+9W5xc-1 zd=b7kJC1_}(wE2qp15PK!4o)>@2u-(KxGFVFwc~U8VniWcAB%6pQxbV(>AdSdJ_1c zr_`o-GhO(yuDO>}Mj!Ep+sNGMQrp#c1sy}--+}tvQ1Ea|ime1D_G1twR6!t1N_ZIw zWl7Y%Q{A2Cl{j(I%vfLuTT%)@55ikm;;VjBy>+P*RGHvXZCdih59O}j(yq+MajEZI z4WA}YRr`+=1<o9{T+w~jHA}f<4ck+?ohl~SkdpX=kPl4qk|6_`BeJX~BZv{HG*gqfF$*m$IDt-ig zSeybso-=X20Gms8&p?P*CuU%nwbOqx6$4?DJ|E#Dw9O5kQe6BfGxij_5WpyC74IX0 zQE}n?46hTuXDH>IoS3lEfri9=C<@XI<6V*J2BXy9SSn3CiBc&120|gRu&wGcN-0gA ze@D(U;jV=iy(yv023)Ne#PVUAxDeMQsjZyBMk4cg{jR~mc(lEQYe{~EeEgP*1e_uD zBsu-3$tW6o0gIx&K#@a{1;3_|6kAgYvvskBc)`X9HA46z!D?{22NUDxg-wOp}aERrtDcE^}h3@i@IL!6FC_a1P(^)89RV!sSsE zW3Wji%i9w;#qgb25Aan%R;0@4xeFL?4xhfwl1Seg8Z9q^Pb_+hVoUQ060F7$JLm`iCI~ zZ*YR5YLAiByp&Q*fafWC)s7|OxLJt_uVRgYFh=w zEeVhXWLE)E0hfBmals7|Q0Di2&b>34Y>3O--~0dl`7oI~_nv!}=RD^*&vu?C@7mpA zEh{oNH!?TN=#$Q&sNS*l9gF%;wmyZIYU{hYh|@H1Dr|pW2gV&VSAcLle3BksjW?$# zA&qL){X`?eTO}ER!uy;o**~yQ!C}BA$xS_xY5`87a4GpI_c*gcnUD$grY|~;Vfm~s z>T655iNc@qeq>T^WKvc))k)_*E}Fa??_|MvIz-Euh?eb2v_#}#1M)^D!uID2 z2~t2v6h8e9@nZY+DpnpMM0%gaF5`z$lJN(O4Khb+{9WZs#YL#uxlwrBATb=*AClbc zi7fsrFQ|br$g^1j`hJ!`8M!PgewE0OR~Zf7adQR* zU4g2zln7a*8w1P|7(G?|xNvJ`*axz?lzQ{-nNEv3s0qW1&>7* zUpLkuy&hs^AG$vzm@Cp(q))t34F*1fuC9`y4bQxGWLel4LRO>`r7cCAeLR;MNHZ z|5yC5aod)??5$|<`P~rvf$@UOyUn}RcM7Tdf}zH(vYvay>kfG=QFz$DWe!7qkF^=` zD>?I^=%kv=$1erZR7Fw-beJ zpWE}E^<(soo%bw>=lC`EtK>vNR01RvL_F{rtK+9fCq95OFneyFW!s376(3+J7_#T) zE^FuaOy>qq!>%k(xM72~bhWsKd!4OfKNY9&m7b*iGFf->JAJ-7%YnhE$bi9fME*NR zB+UHal+Gx;C2~8j}N)8$sg%MHj8av*jM+osj1}aR`?ub z^Eb}5X@+k%l5#*K&=1Y4#wn@+JR-iG5ua&JmmATFog&vo?|%?z>5)2NYV8PKM5a(Q zA>tGh<}e615}i?a>6u_~H2?1LnHdRAL98&h!SHz_SL`G(hAL0t`Ks`2iRa3%f$A4( z)QX*ErHE=A-r~|nR(9{WD|TwN&(O9}IF=d%QB_A`H7)qcSvm`-Tmp~WF5T;1okOad ztE$^0m)F>3&QncJF@xnY=nV=zlI&^&&x+v##f;!Ve2?aT{4pke_`Ms2RkfM6KD%IQ zd^@v3LuG97!<)GVqY{Px-U%b>Gb6q?Rp)EA^9~Tp;Guu-YkG9rPRpsle06_P!dylX zC02ficZCfQcLSs1O}nXE?7P3ZqCcDFHJZ$8IJU=en&9Q? z>D{tJ@Km0BmnYnO)=d>&VhIWZju4qB9I5IKjx#FEfGx5c>y&_*DC}=NBg4tv(tCq5 zv*)b#M$g({?nHl_wthIBjEwONjJ0TJk}1?L{*O5heBmnSy#TA>#ei}`#LQHdecl`* zJQE9hbBllZtl1Zh?)QKxiK5GhgWpOB{Qv&U$(i}|f4qMu?<;OW(E>@tTcpk-svPWX zMxMECjIuxW2^gSg;Y^AXLVo9&%6!2A@69cNvc^Cp`$Zf8)Qp31a%e13_%M8^cy;8D z<{dqf|1U}y{mch_OeU@yUo0hAJrx}et`!j-vw%J%q8EuTVzd%bQqMIf(-5CAr%sRUrouybtW`xlg6sQC7LP zta7hQxgU2a_ct_q=zXHu4{|}H_wg0e(+bhIKXFe*bfDOsRZu%k=~`}4mvaA*afq`E{gZJr+&{=TF6ybA9Qp22 zj`+Hr#-ZxV?Ov{LPvtBnd-g+Cy9$16Ql091Qu-(QJKFudRqpT7zbAVthe4rhxnFcC z*C6%vx5~*pGu|aq-&I}8wMw~stK1V-xo4%Er%SnwQcgwSiDo}zm77pNxuIRksc}fW zoG#<|5Zp+|gKbjZK&#v;tG;!7#Uv|hdbwXnIW|P8Z=qH0CMow&mvU-84ztRo&+q)6 z${pUl9HMroc2#|Yx|chtOF4!25-yPbrLPZ1mvYi46(EpuQEMEx$~d;Mf2WUEo>?IR zQ{%l}%Kf8Dxp4u?9c{IHJlD+cxA}@ix|H)sxnWkhQC7Lrq}&hE%k{=9>&83S5aiTB z%|BHYUB+@H{Dn|L0p=1+z3_}*D3=W_0k5Gw?2W{o5Y zr@kcQQ`{`I+AxI@g}YvaZns?+@_M6_`baRAXyIA;u#NN1Qf&9Aj@ut#Nict4-9EzJ z^2s=nk*YE@Mrf}8<{GO{;pQye^|@9%js4S-A>2K(>&6=Y&9~UYXvHyDa>M_YUWu<} zYidfq)%v!2M&_2N)n zwh^{uaf@uBt}R;4JAhE!ny`m7#&+<-?|RqDKVyV2px(PDIXMG#*AA_AA0=Wp^M|?F z(`{~+zR)o@qJu~j`nV%=>HXiv}bN^Ld?#ZU7f{-X&xpg2QG-?jW?g~{D3vVVoI_X-%Fd46CA2c6kf?MncONSmqOM|uIbCDVX9rDD^u=YgW4V}9eWpCm!KHVI0DZR@O=!*D_C9jV3OFsmgGr(6>uw2*vfT$`By>8Uf!|nJY}0K&|qUq6#ketK+Dj1 ziNZ`SZLqjOGg5FC{#PFvKk9q|i)WeeSlk_`JZ{&R)z$;?>{BlHGPa8m?1oYis3X5@ zL8q7g=*{&+jIm^sRNNF8)9GF|z#%lo#;bEpn?AlwwA5ma4Hh9!)^8m1^5FVsurBM( z4N^<8^(k1BmmQy(@dX`7Z%^7tGV|qDdt;@&-R&LiJ$Av6i~n#X{x)6P+y35{ZtoG+ zX;LV-N7ih#@J_zW>a_OSUYIlai0QX?Z|~|a-=4IQ6fWwl_G+cQg0%LwzfgMM#D6UA z-roLq4{3Z#mW<}-qp(u)Nruu~6@HF$p!rCf1;;|>t@OK>PChYvGqWWrSnrq0VQbhp zJ4wwQ2-9^xrkzR;PMjzNKLS;rp?>s&Aj)6lDq8qBUsgD~(X<+{&WT(`!@1Lb{>k9F zzv#vt#ShY;#Qwr~AxbofAZgSTS97UH&M$To%m}>$6z>+50!e<9a$U!BE=LM!kdR(} zV@0Cy)i`T(w4nc5bLuDvR0|bTnG~j8%8jJDRPDT$DEx4ZkdLle-YdVp?buSAN`G@j zX;Nt`O%$AzzAyXld?|Y*koqUrWWG`ia#`#Y<>L09`VspqCPb``=-N zU|lJEBC)4#juh#99lZJft5C<`ABm#b*u(K2ELybSX=be1yIGZ^YS7ksbn#LuA~ zcNABvnOei3=LsT!0HwxD);tI3Jy%7F=zomiHGZ-+(^r+qOamjV0PqLT`ZY3R4u2)?s>$A87%} z`z?Dp*oc&8qrJNmYhQYZAW5g!1=1f|K+mwc__+&Uxb5BzrFRcqcK*84hJeg#fQQSlrs2UGJ zFbfCEKx|FL{_g;9MzC6}Ibv<0O& zmrj{^$M%HtoyIQaB@TNa(s_*CH2g=JkRD{;mFmHugu_yvnD2aO!Qe=metFaA$_WqN zh!wyF!>exrhJN-Bv&mZYr9$}11@8_%G3huxMn-HaVTz;|_^I+`USqc|INfsb_u7uR zg!A|*oW7Li74K!fbb{cHrSi5B{vnVhIqYuVJ>WPrAm(Aig!7K(zdH_)d&u)yE>~qbQ!t)97Q`-v9cAl|LN*&>P?I-oFcLYI5(t@OYcpeZk)U-irUByWzc9 z=O($1{03(`^83(+bRm1s>C%M{>B47RJt@jN^S^~HfR>B|lYjgD1=kG@{0obwG{4Sj zF12V_$+fSulHJ1&wvtovgH!fm7PP&O>54ggQ1wDKvRmaUT6ni~Ml^(Gq1~BN>CC?K zW<7aV&EwvtSw^QGWQ++$k>f2G$H_=L(^WU=o zC4C#Y?TF%=Yo6}hw=2;^_uRJuhtxNV?ikycu_sTXRf%f|kp9FqK>9OZ=BMvkeHbEr zxZt$akDl?j4yt2f%T&8+56EHjEAypZl{O`seU(-3kEGuF?0O5RSAY3}yC!^Cn<%`; zsxRGarhuqm*s)KYq(COy!-)bbTSMB9Yx69-T9FK&Jb%K5n`^dp-yKe+8S~vEd!M~@ zdVGrvz*g4Ivj(t82JlMU0*ugO{{=(B&raK$MvvF+=p8aPzN+z*Z8yIUU5sAma5aZ? z=Hb&ZVvo=MH(!kJ1HPhD2AMy#8#{p#A6q5fv`W0EN)(zERtas%cFnhgVE|1T$9-k;95@w&rhg%~$T1IrD z^|($R+lHc`^?0E?&b1!LW&6Ov! z3ZvtHaXty2kD=Ee>(t7l#~d95D@9w7(6Wci3v$?3$+!7+(q-FF7__>)P`bSHZH8-^ zL~5!PH1hKWA#IyoyHzw(5b_CClmqwm!HXDM+tkw2AANNXLroO^c{`19e|#BPOGRcz z*Fcet=b!)6K989Cu?U>rsJ}mMfSealns{8z5{0vQjko&jLBw{1vPRd(Gs(S+RN)qX zk!X>%Y0m&9zKpot4Nt5&Cymf41bu$=yL6Q^nW%};Tel~IxVx1+&AsplKBOOrW*1N8 zr)z6ytCa}2M~$D*4D*6P^blnM%yH-3xeKvRS#g<->NcR-o#@1_!n25;_OPd-g)tEx zgxA2hf&;4_ow!rq`!N9qXKUtMh<2kIp|h%Z+TheEckyAfq|qseAdQrhq@Wbo6V3znS+s1yPUJn$Q2MbVxf z$u8$XS8A(=k1yhOMiOUve_-l;O9ztVy=_Z;(o06C(GG2;h>sVN6WA5oPweE`4w27rs60uBDOQlQG)ybyGa`B1+es9^P z!3`t(qLE4X8rcODD527@9Jht z|DVpQ&?i5w^@anZ)Uz+ZfpmYW^lR#V?|22fvh2U&{+aI7g>Thq1E5xX`-bz~F&D-* zwS}64d3-xn{8?2|yPX{+RLG9{UFAqRYzkk`35ydyoSQ!D<^;JZ!hvdv4RU|xwP0eV zRpTq7b0I`We$rs42or@IN-sEjOQrv&h9=RKu>F)^FSk%|b5HBDr+eX8X7H47EGu|i zIMz2<7>?xxbHnX~y}}cXE#M(iH_G>)?C)RO-;3nCYkghUQMf%*Dk}_1m;==>>lKC) zJ^OPu9fx*Ty?1@&}ADucx*aH%g=bD3Y zHS7GU8m7>L3UDrxf2;L%oAq@&Ur9iyz3}XOCM;afo|@vX)&0@d{q*bvfzFj_ z6mlEed}Z%>kG-aNo@a@}TZe{SKzMApJu4Upx90>0hud?56T|KOg5$&OS}-^2i4&t_ z?m{L}t9evVD3+zw80vxuY z_FU=_JN~5roE4T|@PSOqE+(agNtvES_$L{hge_(odH*o;J#76J*v%JnaIpWo9-Wu# z8@)#jAbuR&T2%lA#8582D;I1x<1dm6a*K~I=RyzvuDF_RW%z3L1p8Tdzcx>;q|@cr zVIar!<781PQn_2-yiN}va99Im=htc^6ocpK0`$h={r%>S_h=8lG8?xTA0FpP;}49M zKYT?l1#&}E&ENGyr{gYQ*5~mlGVkDbv%BCHIw1u{)8c9GTj=O_`UDWCtDg!G!b^^n z5LCnT@Qhr#UtbW9^Ty-H3WD?@Yoh9kbUn`+%@M+w(B)8{vijJq_*_aOBg|uHm7Sz) zbLqLm?=_6d0{CO2iEZqMSfM?M4RI0ClS^D4;TAiYM~O``%*WL*|DLo!k-j@us=d!_ z26kfei0B3J+oTt{(Q};UFWK#^-puFf_O6Tff8lRMUlrpYkTU}w5wA-*NG)pQiO>(i z^WU_PnGd%gq22r>Q@6}pJws@L7XAyrMsFtrF3F>uW_2zD4kt2$*zYh?H8;&x41k*{;>Dpo@N^Ikru3F40fB zS$w*d2@Y!yw`t+u@yi^k_-Ey)RU>g<$-oIA3n2fz(7o3s%JUROD*R{dpQTO23F<@pk)vm~`H6TQCqiWWm~f(l2)99mcd!Mf5n)TswxC!Kz)w~} zU^wEOq?i9`lvDWBiGM-0$%$0+(LRdUOa-`30WmVs_YD6aqoKjfFLngaF&c`UXJm%5 z_cYXp@`z*9@7kH2SJ3Wj&H?MfZ3%G;o0OXna!0J3 za4wUfnQa*|DTiiCNr9=O|LV*pu^-7l;x~3Pg8Q@82!;)v3<;{r&f_Z(9iuYDmHS<< zX*FWBmTn5Q(~To^nAl?tJvGF_^dSyVL(G-%ek*e0PwB=51-c=bUUS4OToj-Vw^XEy zj9V#Y)#)PS6&eh~s|pL_qp=C;pXKp>kxvIwKH>cwpH51=fm7e@7;4q)u=wN>jFT zK{ck1wtB1|Cb;ZCyV6bp-qtgxtoh=y7M_hc^5lkp zPyo+jDbJF9mk2x|f)i42OlN_bN42-(CdMJlNrM{9e)Nf0RBOzB$}VPpkSRW7>g1%; zV!OLbzE)4_a9){aA%Hu41@UF0zLDW8il9^#J7toXJd=CYL`A1@aLWfx@wG9DLzaoo zj)~>CnE45NaP`8148vEX`FtbksJquG6IyiFs4+?6c#Swr;5 zydow47NJL-fO=~CbId&oal%_=pe>1KyPCB?vtHG*ToHlnlPP4r3r{Xu_Usen*H5IS zal?+}I&_LvYU^jTO}&DX#aY@k;R4+Xn`6@D!um1xjD@_ zunL@}UgZxrO;`Jj`u@NXy1)C9`R2T@J7$%gJ(}NqG(En$emWV9l2dQZkvSAG(3}ow zC&#&wzvB!US^s{fhdT^-z4hD4c(73HdYGrORfhKu38C}Me~iaw+s87$$3M)qaB;oS zeT7dbUIeWNo6kZ|Y<0mOz^7%RuR%+IiXVLdir7eI1&i0|kK{@yL%CPrk2ru>heD-e zh^(20QhW+drGM(K{rjZUZ$-cNHq>J}Oj1^hrq`}c|LtaH>s#DqA5`W@^9Y=dB=YPD zmhWjF>t{&qfqhWVK~LII2ZFCj%S|t!Q1ni*sE|1Gfqm@>Ig$MkvDRfBGTiifL;z@;ittBmLc zsq|>pM#1Iecar90uQ^?C_+@=uX7C7O(Ia4GZT5mV=uDc$>UruBa27r!6PzRY^RTOalhQR8^FfA4+Jje$=luz{m0 z)f>z)`UvvTH7Mn){v?!$f0}wWq9K%Hsbg7n^9yxRo$wEkqt?q&{=X~qhIh*LZVJEd z2(QlUtayRbEo3tAk7(34n}iL?oqOJFCk&EmTi?7> zPqg?)H27;9L*pc@aA|O;zaf^TOGI$~VUZrOIzV2O&9V4EeVNtA-8TekTRhsG4IVf! z4=h-Bj;%}oy7&}(I?jAm;?MO6)%wb|*VcRMj`SG&D~yerA0hE&0zE`0_X||DRFJ=* zOx(p=DCvn_e4K31Bk_u4g9wQJwro?Ar_>R-=w!H%MW|Yg6|rN492$L>TXWH1%|)Z` zYSe0Ls6`ZZQd@W0d?+$J|KEacI$QSw4<>-^k0 zr=B3AM*Z?wE}5sy_Y>)T(U> z4e{1F{YDPcs!LADH$98qJU~rxXOolkY#|3JC$c?@SBUQ9UIhei`NbncL#69`5YU;5 zj{1DjNu{DP!Kkck$A)8ZhNsR)XomsXO?OMLw51#T%emm6Mqr55u&^hq*1@?3!8wn! z9=sbj$2rrvsxBu%{M;sg!#i0s!;PQKUmrim%e>a}G9kMffW6t1JKcoJ5Aws=8c`}4>uKp8%J8emyjTh&Da{aP%PXy8Beuj;>G|q9 zza%>J1Usy0maU+y-d|<!9j?fpriM=+3VBjNwYS2|N4Cit49}tEq;e28-tfzg4y=JYke}N2BiC zLi^Vr=||FF0ZpvtNP~oBu1AUPFvkK}%IU_AP@kqgqx9%yj@tLGKXvgW;%Psw`lhI} zr~3Ml@Gx?=ccViNot~9W6LahOX-jTVts|g(GC*9%K6L2LS9Rw$y<|V6)gLCvM|9Ac zkee;$F~~o1?px&u<9NHT=Di@)*{2(4kLf6M8^2D+=UMKq!GK0K;Gxa9-WGhXUS=Nm*dwtjy4$ z>T#v$%W;76C^M`%8Vd(DvHO))_448(fNuqoVLN>k1$uIx|8IPE!7bt3)0SkLJw?KB z8hy#rC+iW^ktJ!oB#TlT$Qm&<93;HR=3YjYwiMMO5)bLWs=V=W?BVYP_F5qO>X zK7_By39s;4+^IXaLe6fzS%%;H8&4}z$qM#V-(W4R_2wM3*?wbkm!;)lHPqJ6|IXg6 zsz;$L*Q$k?Sk4p8)n`n|AXsbF+CX$N%MC~Om(0th-l|p0W!IOUeFvSb5DvEp{KT3T z>L5liJ4V_65K?!-+v|o@L}nK$dYFd1CMe5c5YEWe(bdk#+kv|0!?buIbf9j%jk+zV zU4$G9)?NeZ)|1~)?KOh8p2T`DOmdMP{v5J%G#i9s9`b87!6DS*k5*tdPiR^;up_w62!f znx`oA)T05S#n zpSGkzB-jxz`?TkF`$yn5*zPgbVdU30$BB(XyP^Iwae>f&RUdm8@R{%LQg(}L14bVT z(lvd=D*uR;wlq4YkFx*A&z+4(vL&voU$CzTrX>gv_5RwGp)ybSfRaniPIBq00FO7D zo#oPcpac3^LKmM!n5*yCCbvw5f8u9Ax;R{)8s0!_P z8sGnhIN{iIAkHM(G~D(rt*qc&kHP8YcI1kXl5s^Ej(+b5CF0urPdB8v4~rf$?oSzC z1G2Svi_Ug$ivf5j;|E`-Od2dt9dR;z0Eeq6>j$g^P`@p!flyzvfZQi z#GURX7|iZfJK>%cxmKum-56|ZGL$r=j~AIpt6f87o%9(VYptNw$SP}%k4jT#pxww5 zokq6bXo;hCY7~{o-mMZ>FudzCRE4>yIZ)qD%nG=+&d!mQ75^{6+%C(l0_`8mZH-%7 z@)8T|cUhSkEI8*TDsA6I4vB*02huOX+_Tv-@V!5 z+%-Nq6A(F}Z}L-^43rdZxO~K{O>SJut>-8jN`L(Lm(d-S2wtN(4~s^@2A z1f7Osg{^Q)@mxblkHCg%dwsZ3l1PA}k1WslP@ya>QZkY?r5J>Y42=yFypn7S;lAu@ zmSmzYVtY*7FemR>S*Wp-C{lje$j|_0!MqNc038S}W7x@u7<&Ij?JC8=STrmf#iVp4 zS&5`KSBeaBv#67)Ju{LMZp+ec701K!%S!3_WhZmq<8*!8J>}FMx_B8nyo{M%SIeB! zB=^H%Bz_3y2aHuJ7L|F-ew6>;5(J%ma?@n?WBX$c9x2;tyd*rn2CXuQGBK;( z=5VGxlaer95@5F8{JxlZ42-SOiXzYiN5n0GDmT6rzIp+Fk@@~Rc+@N`f=@xR^tFG1 zO||;{_U<;-tJTe7Q4C>IMKx65H?AY|&>LUbs%p(fFK`k+kgnEc^rpdVpcF3%kH2QH zz(vf>b2HM-&8Z>pkF_h?vC$^hyEUSaWV7Z@sA!s zSD5{-161SrV$wzB#IRcItgam)DZ8MbD25W_t5nf=4NJ&gAk>gLxSZ*pz* zGVbvB<%JBo#}PkqAZ^4QNIT9vgc*E+O}o4OU)}tABf=L8^?CztgA=u-S)L~|sv(sl zQYKpEQ`VIq79Vj8(|eSI8_SywKzKK;W&}i$MXuEx$%VIkbO=(*Zg4oi*f~y(N%kFI z`Oij%az*rt!td+G)FEEuyZt?j_9;q#BB%NCac33q;=D#W1R~q4Hytp0)~ePUViHp@ zFz%m~i1a9*xO zJ=wHef_n&~Y^;WMV9!_p0h#)WV$?CIqVBKK@yLo@t9i@kI3$GGq#=eoH$J6lQmF&h zta;MOvT4L!)M!zAt6u7(R;iLaJc=?FnV)S}w11USm&W@BB4ba&He(sz-Dv{3&2^W4 z1Nz7$p7!?L4S#1Sy4@9Vg>}w>WIKcy?Kmt+jNaLwhRV22)tg(}4gre?u!_53aXa`Q znf`UWSb7;tc>K4e!(E4@sLx5=1~B+g22i2;+Qkj0{Ob-t`~ciT@RhWE6AI1aUT;tO zCgi=;o)GsCr-6@TxRbPs`$Ox8oO7;6GI!|X^4~nlnSl-@C9UD5|0nzTYMvLaw4RgE zPqL(A^vnMzcT&YW*1Gt@RI1=57)IJqENV;T>|^M3kH}P>X7|a$y9FZd-TJYWrY)(r znt6Z_qp8q*71Y3Xw1z`wwQqj8J#jmVGvo|y={j@z+wBQ$DRr+ggD=Qs^A|_g3{NaL zFrUPct+A(f3hBt48R1uh9?r~64Wd_EIIf^KTo~5g37LKM=2QQ+keLo1WLI@lsv9GsKCycXcO(U>tK4Q79Q7lsN{w7Mf8tqLNg z0*;svU?H3zz;)tH^qoC&^nZL6>p@&M$I7D@coc3s5F9B#n)#tuZRJvL*q>uAlV>T1 zq8)m4P)i(p>Pw3!jyuqD2FD$K%lylGx2Z}JLB#g;=8blZC&-Ub=Ne~rt`Vp3ma^@h z@=MDXPGzHCC;DTKBu~l~pD`=Wmsww*rnZz5EcU79rEdr-rOq9p zWfPYFYjS(NQQgk>Eq@Pf={C#l=CseHCuA(K4yVV0Y(}XUVl_a6U%le@#Qfgydpwh$ za#X~(wcb1&!>cgI2gmOjK&BghPf<6&I)2CQ->$|H3n9J9c!+hc_=^sjgQMW(9FkIm zN1eG2jqOTzc0zZyrs&QukqaP^LUmX#RwP*BRS9jm1nPOaa=q+dOtRZ03T@Y@-3nII z6V*{bZU{sR{TeHy-7)7lQO-5AVdz$8yrTV4Rc18?qWxQNVf*AG^fGx|#JLCO=+-Jq}gbp zQn!MerDoBKbp3Y56&ry}7rwf{F@K;%Kf&nJUxgoT6P$Ls>+lG0q7phF13q!R94d(I z#*UT3op1W0R~&pcuQwcg^5Zld4F8C+LI1q7u#sxNTH_ReChRnFH!STjsR`6iN4QFNpi$L?b@O9OH&fIlI> zdxg_oeS3q`FTkwMYjwN5Ru3xRJ+Y$)pggEraxj_dl%W;TOUMzaITG5B>*`~eY`gSASRB^Ux15#;=Id~h5Om>uQx0+$~ z`8FUq(Zu}t4Z1OHgVEg3mg`Xpd~HdK?8oDd))yAkRn+^iv%BjSHq>3x7|-LPo-|f< zmozW}bfTr!p@aIF5udnwZ!jkI_ZXX$SRzLelx|}_`yEb|gUT=2$=O%K*JAsLqe41D zTk11MG}%uoT5KHv>HwAJZDS+62lzU~S{Tl9B2T$f}*Wq;XsPP7;c@P{*JYQt-INr3vA-}ofp zdVB84+Hfzwm(Pm4cIll`Ajugp6X* zEeXOc5b6ieyHP3Y4tYmSlRgCH)6_>aqsbvEO~y>Ves50i`uz`7)Bbu`)}z!t60` z*~_P#G{?_}Am5IU&@37}@ zhu=xb#GGvvl52j8U*^xx)OEB6`~ctKbyO082pM824+BzIJwWOi4OAz2rC6s_wM>O1g9XDHW0&swv=lKUka^ zFOvsOZqQ3MYfJL#GVyl9F65`h&|4jKN!RVV7FczaS_7(ZeGojp!dP2TvR)frE%@CV zK6I)KHv`qNQ>@C$lF->392qdyQCTPW^oU=~g5OBYyj^#FJg3C(e2w#Pvqy9^qI5xP zR3oc@sYbs&ev&raok3A%VXg#>O|3iBMpn@W?4r8yfxqN{?m951YdLFv=c;lyY$YITG(Uy+78(X{w#z z_W1D>^Sj>b)*Y*u`3o6g5DN<-HCE{*YrtPjhzfZYlmuMw%`OZ?KpGZ?LK^Jr3ZDRk z7QP=7OTdW7oP2X*b|It;{EArkl`KjnT6nf9`gv@t_+nzBkwvBBP@xtXK0#{HAs)#h z1VPne6Nfcf*b)?K9t^g=Xk{foEw{L*tEs5{^M_tiZVf zhbLlYg$g~3AvT%puQ)1gR{O(R;LW7&+oA(UAs zr(Ht#sM-dcRp%W@!~%C^?7u+jCXV(00HMJy zU$n9^b}9F0-@F=j#e&jA?tDckS+BuSO=l~Oy=rfzc<|vlW2`3HL{Y$Km_4`2n^lxS zs$jXXVE5w8_;78>2F&+PZApE2XCG}zU{I0vmj=>g*Ky@p?7)onYJ50^w?XlzT(pLF z^}#3Gx%u^)^RtRV!`UT#i*tPhX4@t_xUC?$3swuXoDL-G<1uqfx>n-QhL|?*;^+|_ zyZx{22~YTS&cpBXm*5Y}F^2~2!tMU(#KgziPvQRB2F#sp)ZBFR1vweIvnjE2rZ#(< zBR)gEGUFG?moxrd`O1njh`Z4ed8nLD=&VmeD#YTDPR5L zhs#%fyuW-6h-b@}hX0vI#aEoE1si5+Tk6G@QHE5bJ-vbD7|QWQFZw7>GK%d+qYAX> zFCp^|=SzOMf~2w~jUHEncJq1=*SO`T>8kJR61%9m-67RGVv>$herC$g%-HYkpHBJd zjNN7b%#xp3Dl?B1R$a@EUnkc&@+c?%Q@QRV*L~tua-A#Jx$z6-y02XKRd8v~lk2?r znR36MT=$EY$+a4F|M-b=oiF$E<44K$0J$Cz*W_CMY}4XS?ZQ@HEpb9#r+duKg#|OU zpEd%Z6&8R(C=)lME|C>lAj@;eWwA5aR0LidyyX`X9!K1A(jOP`SbMs~z|mAPSQjwg z1#_SDmb7B0(dN#dXxwt^J!#O}=ZIfHU-o6jFO@H+8s@&Nc%}Txj{D^+Cq7ZW`ovxG zl^Y);Uwz}FSg1uu~>cICoXB>6|} z+4`Bj^rJf^h7-?>;+4BwE>}MItFAGlfY#KyybVN=44#NX9l1D z;`0+eAwCQEg!wGy^9w%r@OgmGANc%@&*OXsoS&01jL*q@Tzt;va{-?p^7#p$pYyqi z&oBAh&*#s4mhfrhvyM+-T297PKHuZ>13p*s`6-_{d=~Pl;bZXmC7)mOd63T^`TU*F z6MPPBwg10W3LQgi+-9Zruyh8pr@NJ}H8#)I&>(Y8OG=cv^l6Sd*2iZ^0<^a!#N$Uw za{!xfzCtM>sVF|CCc^V`GmziNitE}pHxKr5k2iN{R_J|rRvn6BY!2^oa1Me3IQy1o z5P(c%hLl*(E-0E#yi*RYA4#7HJv=UT?$kXk?ey6Uk=rYg+ueF3r0bD|h`8C;Zb`}S zdR1r!5}Y2HM*3zG59``J*W<#5Aku0cg-+Vl6rJT*kZJ7p8lic<+C3po`Z&GDtp0oN zt7hGkytcw1<@UOxHia)QCe{Lfi!#Em=O!A>x1JS)f1425A0qc4r0Gt$5?#W2=||xt z*`U>o;(@+Ar56~V0i!vW6AG5fz{yeZq^{szYE!y`1q_Fzy2my5dH#6}w5VlU%mXk13o;lLDfT*Wn1)SB%+#4wmip5i7uWyN>omR#qBRRg4dev`2M-GYMQo)xSp*O3$fw+x4s_j;amG6L$=N|} zl(W{k@feuFuhNv$q|5~OAGGclnSUgR4bM0gw6B1d;`P%nr?vCF@xO>WHHDz{=y zh+g7GC)a;xarZcTHtbU8OlY%GnWS)biHWEr5%eTd8mc?m|5-=-7bV+|sYq!kwRSzF zy5rhE=P*<6C|F9t_$(aY1@@)pa-K-+3;{Qwi9s|jJ|Y<;mMXwFDG1*e=?dj!HE-VBdlwVS!n zYVNOBkd4(YOF=bd-?L(D$nHto0z@@%eJemUpQG0hVqm&GCI}_!&}>{JiPA76H6SyC zHLM^Rzab5vduh|wB<^?|fL5vaBf4?B1;b6D!D4jKI{>)=Aq_yf2zVoa7m`W{=Cxv! z;5=gitqTd`Cpc|sne)wGrW#3tb-E2!w+&Xo^BH8@Qx1byqhFt0q^6ZxFtF%o>8?yXyRCf{%K`GC(} zK5`$$!a~iQ$k^Ch);}c-mH7@NQuHK(WUy|*{$0~7?Mu&8(`ze-4 zMh|Uzj2(1WH5;Aww)hEOOtVn=y;MU?vWgSY>?I28XGlcFxKoOkFC>Pk_$)m3D9VQN zg=dPlSH+3uL;MuOi2zznEmJz1&F#8!rdIZg|KMKHiD#Q7JRAJlB{SgJUIkNzTb$N;JaP&I&R^a}f2t>^py zfw^{16~`azw9%q>H>kfqmP@Q)eN9c-53y^1V`Q?e(Y{B zv)#<{6h5<1TC9(~OQngz@!z-I)ull&N=T*E6nvjKRTRn=Q!gPAm{7$@n=3_)WFf%u z0a6%terp(S(LoHG$jm$FS=`BqOzG><^w4OI2cKex$#88BxhxzuUX-Q%5qqX;EO;Ib z(cw!wT6s>Wk5O+GY^7lQepC`CY0KXmCbS-ool(M!VkTH;{)y+({$g&`<-`iuu$4!N z6_-I2-M0y)TC`GTMX`#6Ccfn26~afzNR&H1M}=#iPwjlY)Aav|C#ikH+GjgrS>a_R zduhKVaB4+jgY@N1EU2+ezH|NI`b>et8x|Z`W!HRT$8isW1Dz2-OGf}*VF19g zkN~qgSfKCy6tTHCJP_4;5)m*RClTSAr5$jX`j`JOBCx0qf(xnfrx0PFAOd4gV#4>p z1SC=m3WN{o848{8fiTA%fM`l0#COapIQt|*oc-tjYY1VT>-8dFK=_85YlVNd%_@)o zNqWVq<6JM&Oz?H=1;sO1&8P|-0ayLp{^tEs{5YsUe7z^?IiN0GE9Ne%qaaT1>fKl^ zQeUs+%xWJOmt+s7r1fBQk3C>EI(l&Qq4Z$?!FpiFLB+Ig!=M!rAqj)W9{EBT{6>oR z0t3!d+AzR$`h_q^^$PcSX<{STl1G|>+wTqE2sOg z-a_#2aad_%vR_j}YL%{q(}vV_JUz5AU!B?SVK}|C@zz&pW7wA*hvO@>@sBUr#;~5- z0IO605J4-jz?|75cmy`8nEAa<)mZTES_jcmdzi+KI_^4zI$oCC%-t}&qmFgbMr!JN z?#Hc?%K9L6Z)d9c7viE6AGb>;;-~Es?m5x&pZKiQ1AZ$BGVrRawF* zhs@*cH>aiElmk-so4&p; zH(eXU9~nCqss&4|t}lVeb*;76y&8T9-4J$sY3S&VhO&|k#Wu1d$?4f$Dbva#is__4 z9;t_y%b~E05dNR&%+{E{`4<$vEf(RP=UMSigu<(Np<2s!Sr?#|a8*xa#jQ52Vw1P5HqOUKEmM^KWKaDtLvZE`EWz{(U#_LEo| zIm&BdWe1Taj9ArE8JtqmP|&rx15Kq-IeE-M1X{*&37d zHJ;}z^f|uZVL=~I;|4*W^-1&z^ol-@DV+j{1k48zfmh+rtB3Y(F!`>ww7z6(XaH)_ zJU#qAvi^Jo)SfU&S)6C2DR&XB=CKSFI(fdSKptJD2?B?kwZmJ2auECFO!&!xBh=alhG)4A#k^nRlVWTT@U=+tq>@1=1xu5_Tb-yE*lh%MEnZja z_3L|*NJ}qUQCmOnE&ZP50uoUS8rQ61cx%mtN^`rFAd^S9b}R(%wungrRmvQe6l5kl zI>|u_CS?h=R5oRsP>@uy;=7>Fm-^WiK1q3>c@$yn?6U1l=XG`MiRY}z9NzO}eyS$( zjx7&P%O#N};u;fr5)-;mCiD`AYsd8~djf~;WUV`iBviBa5ncv5FO7c_*vwuJbUa2) zb3u7-MttR$8C1-JEW`^!LuKb1Y97a)X;ZSid!bOmO0ln!IjjN2xsm^)T}W!&Ama4f zq*&?Fn1Ye=J?!vPU~gM({^oA9V8hY464ia>JzTR)_wSrD%KYaar9E)UK9p?xA)4nx zQGv`3*-V!s-E)mAUVeP1oPSz_O{Hv8qVN*Q^}>^lUo>jfudaD-NRKjxuG}suH>$ua zf_f9Fwv7}o*^h4{zKtBF8pOiOs^8m46@sFwc;@8x+&YSKkY-dxS zT?zis?PKY-BtOFwlR4seo1BkhW?GmTyfRQ5b4;U>kDUtu4r;n`S`cMxk+Qd$pCYZs z4>u>I8ZuA#wRM0m#W{Dtw707ij-yFz4^)959Jb59QT$fum=C{LV=FF(X9l9@X8C05 zvl^xVS{!LMjAUgWE4{(3G}0$BIX6+bPXRc@)eNp8xUeYtjd#aNC}3}Wko(|>rL<34 z=Kh3bZYPMRH~aP?vtpYd!+?=p^f)~$Lg@Fsuj#PXQh@R1k?Y%K$YTt~r4R6~>YTDxCWQB8QAaccRiNfYd zblmpEbhZ#=+g)BB9FS<_ zEG|x|WbMjc@E&ZJR`a5iFsA)+iczy!-a=3bv`simd-iuji(GxlE{Ai_%96&2?`{rI z-KLkk#JS7>A*yft8LT8+7@n(j-h7S@i7Tt$wQj-tFtOJkiCHV*w}Kt+gLp{`boj;_ zg*0rLV%(zI(w(a()-7nCfM2xV_0j?pOWAV--e69A%|^2){8<*q7AR@b ztLSCDcH2&h(B9ox=++y}q)xP(!cVFmQ{1EWs;Ib|=GLp`u1Gc4hvxjwPkqL}L61jc zciJF4*B;iS#ew$mdm6HW$4*-8ZJ$u*>$5ng&X-%gYyYG=o_Ln=I*Pn$ed2xuKhCoH zhHy%4=EQMlcov=-h|WR57rIRgFQA8<^RSD<^2(SCpz>qR6JlhA!aoGF~c~w$wQ_H!?NLJ1%sycH;-!gzI(Zh1|>Xxt@su z(A`m0)JfoK!Co_$^wwlfEaNmi|Kr)(=Jq|3C1oCs|Tr*%V0>JX3eRLjtM@nLi{% z^ETb};%pxVuzYRl=@PKQcWZlMrmHD*Qg~8U=FIScybw8))|uay+aB%@1h2p@+zK;w z*XOhI;+*+A{7h>Km8r{SKkx*0OH_z2Y4Wo9Ui-YNou`JQsc?8mstz1a;lQd?D)+Gq zHn2$(y`dq&4n3xx9U4cV-Q^hzCski3QD%jkD}ck4kT!aFnWZ!7XBQin5j@&&^gp0h z65Hj6BNK&HB%PspJ0z~fMyZ1sUw#~dCiYmaDIOwmE|yge;zadpchDbP5smCUf3YJEMu7Z5*nJS>Q9<3=plQu|pa_tsNR8c%k32EGL$?~%HEPApoQMko|!C`o4 zl{zM8xmH|@6U3+2{#KT13D1OSK#y~a>a;A^OCPelM`U=o1r_;?s|jlG#@EU)*s;iZ zg5hs|m4x9x|MEpJoWAZ*V5o&}6bhMydqVN>1v(bkns(9o4PoB46T;beJVpdF$9jJP_ zg{sa9R}&1G7MAFm0;Nih_|6_B3MS~tOtHB1Uv7bzQxf$O@J7D$=q<%-MVgOH^NQ%P6qXKenIDUB(ggPYvOWAQ zOHS7v>IIx~sMU>c2dNm?RJ|oliNf{YQIj>q2^|Cf*TP4YG_z&V@z@ynUGmpb!rr)U zDHhPkYN)*5nlb?*tAUkpwOdw$BwLUy&mEZk&0nF+MK-wUUzr)Gy6u+i`R#~XI77w1 z3Xk8{4ENMy%&1SvaFQ0AfuL7Uv*09L#X(~;3}xiq0#;Er zR%c%?TZobHH+;a}Q8;?FwUfZp2|MaFvj8=VC%i5}UiQ8eTa&TrIX%ROzX^3AeQ@u@cw^;7!2vYHDveIeG<`P5(dl^O{LR@YvdQcz#5p ziN`SJP|FI}XIgkI4aWbGDEu`&A+>7k8Gg%g4LOY2%BmAiO%;>+9%=CRHm0tQbe54KZ!5XP4d_bHu z41PA4MX0_m;S$Pya=0x!G`P!(i%c35dl+SlQNhcb%{=7f*su7lCUK9~EO!&zuX@6f z!Qrwt?U#=R9I{+vSIL{cH%pr1nJ5mzE3fPjHZJ}~m)18=@DH&@6?cz(d--<0J;4$y z>Yd_Rp3DUl=JShDPCkXML;_eByM~?4rXKvUUbP=qwTx?4CC7?dLz(gO$?mEu3zA1F zf3Wqe-F%cyLIRa#C6vx7`@kCeB{Bvk3Jc04c1eEBy4h}yLghlu+vIn+xGf{GB7U>g zk?;MMy;@cAeI-16fnur$7$nD=(<#3oy++)j<4}?l)ev&H8m1fmT=N0+DUuNHIW$?K zJwm<_4HCRaPe~RQce>+;nIlrKoBe9#NL?32YnQP>Z*$1MhKgvhkRhhS#SQT( zgjru)P`$4-xTj_l$MsyV22Wc&DREpw{8TH@eqpt%G}u3!7!~ZJ0!77Fk8X`O*%9~U z*>0YN;_*}-!wxSN)(+#^%w^MNg)yd_{dMhp0!zsQP=qaTW2G zFT$(%b25{~3m5m{@N70&N#dE0m0C%I5-n74!@o%pr`5@R0QBbp{Zj$@nF{D*&2`l_ z(9axu!}$v?qr@z@*2#|GKEr$w+qNyL#HEJ2hUtQIZ@1U_PAzeH>f_dH2AIX zfl>8U>R)KHEmaaLCR7;#eJf_l;Ur&r?<%Qd3Yd0_EO`mJ4&p6=G?r!!v zF&wme!im{)gP!Qm2nKOs!s~h|cs7wLJS7bnsa=h;`;c_0CKz|pRoCj-ImY?7@Pi{5 zo)Iq?>o>pS9f8;B8qemPo_-r9M$W$@=t-=WIw)8?E4~CBllWc?Fd7mK45KFKakYj% z67Tt0@m#tgLz`tO?3-)73?0yMmi6~;F3F%LKHLwi{YF7>TW=tk|DOkeLi4V0h&&;1 zNW#Di7KIb1X*F`n_F(8#!t)-`X^`Bu(Mfv-j13l#OreJ0fx;$m1cW0H1XhJL3GhOY zVoqLig5uxB+n8ijD}r7U;CZ8Ng&1cUfjbmptn&(=-aE3ZOIkwct20 zF+xEfZ(B(5w3_~BPh+a}sKWY^y=d7FG<-n#)T4#v#p1HU^!*0LVSFH3m?92p2vX*Q}q0H85B#i7+&+~_h1&RUJ3hm~dRH#Sql()?&`p#I4 z8+*4aP;gE=yfceslNIa{Dn8fB-l1|%5-R8z4h1U1@eJwP6GZAQh>ZOLh?I$)u^U8U zF}NG+^w41xFn^C&+njM6V>F`+L_$@IY1vw6x{sV*b@$PVXYX5q=%~Z5WVf&BfLeY6@4HruPao$Ccv6~Zfzps6ulCvnxf}~v@_6lRE|@Si&(SOb+oEn% z(;2Cic`<9Siz6A;JTprbRFCwAe`o4WOz+4tgKBU8SuTd67tOu5NI&nCw>+E$np1iAJ4`5nO0}9(x$xD#snv{>3!}*=$FC5KHhK~bpqp{aoig{tA6reT zBzz7c_6S1OR>K&ILv1Vbz%uK?vvsYjtHdk8LxXIcS?I8RM5Sw6EfA$9gsvM zFI|ow$pIZXw1r=S`E5j28|+71mjb&G`f+HL!uuV;h4eW%FWKMChu&Wpkl?ug!`|D# zM^#>l|C7uFLSDE*3C35V37Q(wXw(J*B{$6I9htOPp<;cb#YWq@Eh{sCwQ6t@Ww=h4 z?n2w$ZGY|Vw!607ZtJ#Hz^XF|kno};Pz9uFK&y8ct%z+1P?`VtJonCI@&cmP-T!Al z6!^ zb@Dyy*JgINl8B9%PxJkjk_F9Lh45g2XI{Px?(k z!X|E@A_qwmP26*0k{&Hya5!~n_o2OXq$W+Is?6>*k@^p4#aczAddzn1YV3-Hh`oOz z^)lPrlOs}}hOTB4sT(sysyMw)CPXl$peW}NF>BLW^WR6Lzn`UK{@V{Axl4l3Z*f|L)WZtvmtaa=KjUf0XQ!q zN`8kZ-9amZ3(_sjB1*?^p^&4CWRtUKQ5nd!5Vl;HP7?G~r_I`(qG%AT9gs=FLGsR~ zKRtj$wj#0N@63>(Ih8@5`PK;u&}>n{kSmM))Iol*DLFPG`Pr5x zKX+%5pC?b2{B(YJ@}ue+M1JZ9k)PMn*kPSqWI>1KZ6>M5&dRGN8 z0BeC^2t@I*9N{@V311WxZ?sW-LZ)m4U<;EMDP&Im5IF?sDjbWmFe*%5XR`~;N^9Tc zit7|2FUqZjmW7H~|8)(zN3CroGdtC}aTJHqZ^=>AR&7hNo7bw=*Fi0`lk7%r4M{}g z;EidvV8UQ3n^H74IckJHrTIJhlOYFl!Qp1VO>wS1I#qL{}ZHbm+$ z&>gpoZ97g##(1X$E4`syH;z5olN*rS!$y6lp*8j!gl}Kb$2mf+^{^1Jr$u+-rG$m- z0kzisJgE_Q9`De4s$Gr17rR`W|A`zwG1ij3GJ2+*4v|?4IYI_BlHVulLh_- zwL`%FMW~@y48UUE>K(e0Nh+RLKh%rY!4;chdvl|nak(+?g|V5@B3vo8`|5j^6zEf* z2^JDoF*yomW_eK=0vE3vgX69c7R{YTb%(#c)31FB*H5@!eOYTO21u&Q-sQD&5T+0r zJklDDB`P_z8C6maG>XT7rDPXy8TZm-F)oVdpy--nXfd@SL6n;Vl?B`I#{sH~VWy22jH~{woDy+w)h@7CCoKi|GSdsRxDUu9< z2m-KEJdINV1)k6gQfw^r`w`0|T-J8OEhk&}WdPv(2T9^t483@}(0<;HsXhBx!dbh! zvCQ#C#tq9WP1K$gTNyk*xd?ljiqX75#qqu;n7?KsudCZTl(=v3d)c~|4D#Jl13&IH z3D<&&_uFbuF8ea`45Z%WvU!*xyR_71ysfZxY=CY-HNI_AdVb*zT>4 z5e8VZPI+K9IUMzvWrvM$`bB*)|zKy7o<p!|%H9I*rezftmIt^8&Dlgsa6}t^d&5uy1(jfj3)xx}m}r3dZ=| zc*WR;pa^khz)ghd&Lx+ds}u;8Q7EIS{XD+XZ^~)2a)03#4Ad5n#s7;@-5zjvkbm(j z?8gZ-0XO?RFb$Z`dCeCQA$>Jq{;+Z>z4GE?UI6b8ulJdZcuwGE(4L zFo)*F_m@it2o@~?>FZ+wZRU1RK~Hr=yx;J6>-XG+z}_yxU}_$%c?d}JRNaC02x4>bNz%xCjJUd*yVjAYIvvn+MG!96F5uAx{XFxU)O!*I=~L zyli3B4!=H8&6@`8F*bS}TG-Ls81dG6qE}J0oI?`>YCXc~jE%x3oXGi+V|!*q|Fg1$ zy*jGj1JF)XzgzB4tA4vd1h07>tBoy|7wTy?df1Z6!oUvO1C{Yc#@KY4274n>7fIIF zC%Ig|$Vps4fymv0fApHCi%9nkSx%xiaC9o}lOuWk+5WIayUBDIABHN2W#_5=d?)f^ zG|7>1_U3vA>jNwNznetnUbJW|vVjLN9#4%*JS`I}-5S*b)go^MhXh-!w<=vkj!yg& znP52}g%XWIEUzAVPWp2T%VHxfKi`Oc(gV+>J{6|RdW;V_)tJ>+r&v{m${rbOtt1zH zt)+NTC(u`p65D;X`{~3xvHM5o6jwqA%{iBP=;RKklRTxn`CIAcPlt808_*u7n>5`T zZTIshGA8wV1Cd`dyqrT1w?o9pfT*3Mb_NCiQ66Ob0oDd+&fZ0N zUh{C0^KO6kntOF~lRc_thtItH0ddBBPW^7J?e_pLIt#Jg!wL=TJPGkr&)AYz#H`}V z)I56VWf^DD8hqAk?t-ryhY`$Gk%zx0=wp8uEgH?bYI>IArd=fyc4s4m5SKvw^0vwB zzADnHUI~5Xki4lzAvjtVm~t%RplDY~9rtqhXP}O(wl$io)RX86P(k%HM(k(1AepJ~ zcTmE0Qp(3wu>ny>q&oEa-)U{{LR~o&?hHU=Yz9vR5v&#G2^L_4ASke{U77Gvs#U2)COrY0xbd;#fHZf|x=WpS-m#vrCsAI(Zf5a^AeN%r3QokU)8D~tY z3F{%?#L#4%5D`UdaPDk_w)k8DJ}{FHIwZQ2OJE7wA0PqMW$-rhbmrtOlwvS1@_7qy zh;=Q7TG6{<3B14>rZ&}Kj(>+UY>L+2Rc1x^h8^Was;a&hQU7stO}Bu!k7Y#z#EK zVB?dg2>rgh(}eyP9wGGY!sgi;>DpHh?PDF1{GegV@uq_l+&*=9H}V9UwXj0;VbNH)mNh0d1!->nl{NJ%adPdIfe*~0f6^K z&S%<+>eI%T7tc{7yUJdkv{picgAWsA?=u=wF5=^+=q)T$>p5+Rdr1dB;!2S{KJ3pd zP-)ujEKr+6F9_xSp>C6I&1bJrI!n}VXc#RK-KumWs#;3BY%0Pk<)=-FRlL*9E1RPC zdBS4c{5v|On-iVvu+Flyr{w`+Pj)I_u|!QiLDAc+Kb$S2i)M$uT}}r_4V2CHSvw7-wv z2HwE!qw6)26Jrb1>^vYopt@RvkljCI?{YXCXnt!lgn+Iz55Cg-U_D?u_ zK3kS1(a^CpMSk-=8FM>V;(pn=FYp+jE zWeO_?Dw8!zs?T1dE8V2%23Y4!|JBh|?A^kVk%B>DBM^-1s~d8X8>P{51bVWqG3 z)#OF|2uboP@4aTh5 ze2=O>aVdF*Q|iB_d=wB+Hre79l9QdtPP>?Tm-x(GnfQe;`*L)Z8kgy7ec4E~Q7o)tbSmd3;TwYw`ij4mZZGFNBXST0H6arR_aUN=tl`Mhb%@ zdwp;8M&h!44I|T+gV$!@MHhr6s&01-PLXr9c*NjzD+Z^db#u;go;a^%?zo*$n1AE!%b_3N$;LC?y|9I?+!R zYepPfdX8R2Je9Vh`chmTBCprirKDNdRr}XMUHGTrwY)uap1*B(aO@$J;nbL;wZ^#U zoH+5oY~+mxDUfn}#I4#x z-Fii5xGUEO#rJS7Gw79{E9Iw3ukQ@ul_l?4yn7htYJ;{Rr?tLyv)JBiZO7y;M8INCPlmva~Sbq&8Fm@fhg z7)>PLZL1omw6@7xt*wu|K6j^>l>c5GvGqm2TPcR+2v{K(wkf%lC$3Rm)~nw!pH;@> zFJl$kwkpe*9GP8pKV*bx@tBe?lR|6zn0c6zZ}hqk`rHTf@UcZpzN|-=VoLrQX8F#b zA;O62SjLn*(6)-1UAxIPC6BH`5V&0|$tw_7la2L67duFS&^%0O!mK4hbSvgDRw z(5rD^5*3^?kJWA;V$QwzPRDq;Gi}Z-83&tl3mU`I%Rnk~?whztn{&&!Ds%4hxq+FN zudS!%W6pgE2|8y=u}{}pzY3iiY>mCz#<;YNItZ9syJ-Xy_0_8|QP)~8rU1dXb%*wd zarkYVNVhG-^HvRlhhC4};2?l3hQIB5N{qPQ6Bu9o@<_l){6TEM?4AT4JE>j_GAVa@ zaJSQgr);C}cVTUn*8Y3nCD>g`VQjvM2l8s7Oh&)HlTd5iC{rp2 z!7&Mk(8vZ#P{-b8ItJm55j#@p`mG;xrbPGtut=OKs~o919c(P5@1z_3%W;a!WT0g1LltR(^?^hbzw#F zlu5WWPE5k3P0rx@+z>@I%*j#!by+O^RN!RLS9FR=_{X3eym#J;Tz{#umt*rfokf?;J|un3fCtbgl6PQ3B4!#+(Isnv-|HzPv`+m)E{ZduXkTJ(_@0&U`eQ zmq#*Y=3;x+cjnQ?9jslN2>y|DGE)Un6oO`>FReUu6bd z=*$2uTu&Kh+sLyZaV{?%oKKv^{h{6Pf)nV1vMxs)X$u`|ly&(uL1co!54SECQ%7|K zrX_s@re(wl1S__;J1=tq!e}**M1`Z1ZVf@Ww2{_MUB%0X<)+$D+~<<)BcX`;aWBNsYx- zXc)H`l*4S;)T;wfD4G@i!b)ylN<@U5)#D9rF0jDxLh&QRs7zCfO=LjkxvK^!%xoyk z^HiiL%&*fFM#2XTP?%@6wtj#&KwjzM0;page_op+clT<>y&`L_4#-v`+&)GKLs`b53-%L#}pWd~NGEKCVc@*vx3aOe8CY^h&0FHt3sW3T1)* zZy>`bY5T254IHQ0w%>AWzffOs=mfUk8?pUHQDobGkB9bo&8C&usEO%!p15COi|WJ` zEwJS=^I!xKhah_vA&VtjTIj%UQq+$v=mFuSZ% zKB2sgUZ8xf1W#99Sb~L_2r(HdFZlX=Pvj%un#($}bRpOnM5U6Lj7 z7@bQ)Qa1I(?b;L?TqdWKQT!y`V>5ev0^?HoFs(J|`}QCAJ2C>Hr5h}AO<^xCZ$H~ znai!CSA&@0e$SFKU|DO{zMFEnWE>E)U(HzW3A&pjr-BI$Hx87QhN{32kB9h;l_;rc zcZW5GIkh&1md9^e1irNcL2yKy=25c}gZ_ehF}H2uS~ohBud9wE&#JpRM;@dnNo~c| zbfxJ`jGuR5WQV1|R^<^K_s%xo(I^e)$btCsx(Dl9G-P+e+|8F`ec)HU5q>vkv42@y zP)}du+Qs&e(|DEh<5q!@dZt+~jNu@4O$uCVt^n6Na@V*p8fh-|fqT?*x$L^p2n$ zw_l~kBo!=^I1b;C;R)e*iQP>~n^cTliFSy?$o&n)1{TcEH>P~2j@wWvL|JRqrB+m!u4wO+R>)J$ol7cMUnIM$i&3Y zq?`y*KH#03Bj-qy++i&xBe+KJCE~j%u~YJBk70D{YMyeIp+P9=O8py)PSclbe4(|9 z+w{)S0?~x%Ays1#v8u+j8xnIFS0Qz0jSU@IL!SGM`mROA3Nx^WsXJ>_=#bc~s>Y(= z$64Y!*~eg(V;x|7iRigNue$}^rj#qJrXyh0{>=20gW^j5kk4xxcwH!XJ_%A_md)#DI zD;FnxGP04S7g-$$XHfSq6qFW%B{X@17&*^p`N7LMes1e|4hRL_7SOKVASMmv)_);# zk;N%A!TE3^Q>-S4wfHR%qU5^mcMU?+4Uq@V zmO~5k6nX!!-kFunhM|1sF2%iNr~s0I#`Ra=Q@E*)KEKO_qW#zPt=?9j&{Ef&$GTYy5jnTwWuQ41ZHi%1|*U;uK_ny zXYF8lo)W54RceplThpus`djYp%@qd9x5kOU*H9O-gn@dMPu5tsdldsk;(;_*wZ{6i zO03i#m!L39Ka{ceFkWzBxT&16`$EhWp8mDJIUYY4`b-u-2w#KS?7 zewk2Kyq)_H*EYohW>Z}NGiP}Aav`+Z)f?qZ()G+AMONY5?9Xaf_zv{#Ix|&q?;FWV zMOF6@@34O3;!%`Yo0Q++Oz0}qoA^??c}zxP5Q2HLC`-)hpP`0<#C{<+n1HZ}dqpMM z!;qeNix`D_%A3qZRUZz|22IKl9vnPO%OuRVRp=J-cOg-ScGwq3hl zU6XSlJZpRjd`EIA@8VVw{)5Nx`aB4H@@2`M6Ff^`S%?KhctME^AF&wgD`&z7!VAV9 zlkaoo?vT9YgCEDp8Nx5|7Rz&iVaK;vCQ=Z^XY9ZP#u6r)k{;lM9V3-KQU`TD z8F|LgZl9pfKSfbz_xZG;eO9YVa>?*sznInQQnq|fuYuvo^|}DvOS;#qk=@w6mN+!` z+r4hl9{=#21_<^%WscqfRa{uU+{kwV2X6KYKl6h1Glc8rtnq;b-FaS6?Hp?bl)DW^Pul?TZkCs0sP+ z3hg+`brw~MH>(V{u+T>?nec;9Mc#tXtY{+SaAGOTst2BL4EBxD!$Mycp!fy793-k1Y(+!6AYOC zGV1}riEu+&AFQ`IKC$DklUSHtsnTEJ{tQZfuEGK6M5^>Bb_!;(z|WXMR(h1o#WtJa zA3?G-Xn3>E`>J6bME_hUOG>$H%q8yaA29JSHzt0-JX1R^TM#82!s)WLgS|!|EBiY3bN*%U z9I5*kk5;87eF2jb_*X!(@5`8iPcRCU=BfJeY_cnGZ(d!GWmoK0x-+>jy2A^E1(ib^i9Pa;GaGVp7 zLxgtp_sS#|tDu) zx?M74THq6zT>CmYF8oXC^mBw{Am1a{x)1m?NrBaZbnn39kD)|%A22T!=0yi|3iyyf10rHit+F=yHRQxb&qHs%8f5Qg;; zx}@YK*WARw4DF^GD4%cWKs|(o<$Dj*9q^9B2I@MM_`wHiSo`fU3Qu2g=~pICyjU0Y;@ZM%3rAghPd0OT}8I<-0-$(~CrA|8J{eGP2Uy z{sp4pHutldLYnSF1+l}APWfWQ4#MIsz%dV0Nsgkma3#Phayr(&ZB`LE*nwXP22U2- zo(61%x5!N$A~1ZY+{QrzoFgFt32jWnF1r@dkB6s!;Rc~TSBftD3@h(KvHp|w z&U*9g!zuQl=wHI9*I5vQdmZLs3EVR3^h?h>EJt6}efZFoC#h@71fWQR_( zzV)$8b@!#KOMX%6devCQguf`MW;-A#peVvhqHBMF;J$S(R!@Z6<&JLK;YK(&MkgBHmx?icR?yZIFMC5& zdqxxoX}Hc=StmyYHy9CU+=3^6!5d%gn*sAjYq%qHjyK{12X`Bhxg~_x&Szg+f~wSS zZn7>w@`oxmIVQ|`zK35Heqh0`V|>-tCwZRtn_Dfn%5#7`$H*g^MX&i}m(-y&0;bz* zE-gYnln*DNj``IeLlemmiz|V@dsJ>xIrkd~vdeUHTdFj<$qw80x0FOvriAY;%f0Jk zkc4x*b$@eCaH6;FjvNl+uNXTu|E@7pjU4SkF)BbIpX;rw3hh;P7>O(8FyyiFjs4)-3gcANu* z2?dMPdA7*h?(1}KrO@OALeN_~C)jiXDp1hrdhtc+W=Dx+yFRONg3;xQy#apKy%b3P zNsx#tMnXl*EN7J0XPSQ_IRXoMnZbwxXB}8JMG6k(S>Hd+4g%CvW7IxlJzP!Q(JvSS z2iq|-WV{VG5(}NKb{S`GGAg=)PZ-M%tIpw`Sf_LGB?ZQsOvj~j>D49!C!8ZB)CjEU%%E4-X%9VCW zQGvgdbSdCz;Q{9McW~~?q9Ul(KK%VwvhA#V1$&61b~i;wN=?2DA_glqUTj|{HemQpoVj3VnY^9Tqvv7 zQfT7*lcI^ujBh@R$vh>pY_8{MiJV}t)vPmUr|d%O^mTGFLQiXgYqiJO1R=6(;e$nI z5l0mz%h)q=Tza2Z&&`38d~8$lV(qb>a@h+dKcPK7r*b|Kv9~X}Kzpp6{4brJ z$zP&9hFH;A560&wiB7*gIm7u>_IR}t19u_LI3+NNYe2VGF5;f~c)hlEu=uGem>+p^ zvk>?g4t#1H_-Kz~qOg8m$A?6^+U<#hvSw!FeaDTp>V3blR)55TJ|x!a#yKa7wOVp2 zR?l{<)$ftSI@m{q*~dwR&+Kg2DfxSgY?1@AnA*s4e!Zhd>`<(W81z80tXblui~5(PX3Zt2)Q`v*tSnGN?Ddx$Z|fq z;I_x()!~d#{p=<<(1L@yX<0|7*-MiMpia$1_N~bQFB1RAe6<~av2Wbwjb4+JDm@Et zf2>8Pq)H27xh@Pm2}0V&J}UXFnCYOWRKZWVBG=#}_#E5i`(_}jQ9*N~7~?zd+<-QD({-9>##k>b#{wOQ>Eu;TKq4fM4)@0a)w!YC(D_zUNV9n^$jY(WmpfXK|XirAn(Nsmm^G4 z1N{qy5krRY{q{@g8;CqkbZmkl)1Xx8-P8k$PDqvBPNQsq@4LjFddPQGtyD8yW#Fv+ zLuE+e>FZ`eX-AYt{2JbRu;A$5PG$$c``i(B@at8gEshYwtM_TmyLD>j$L+_# zYmV2CH*ugjxF1hAa+MRxhsKT6k3ZwUB`yE@VEvdu-6!hDg~#p3q+$KQIO!zhLxyVe z5J6XMR!0!{zV8u9jDC;t_`Lsk<8kw4L&xKGXFN`9C*H!IZJ222%PR4M%efLsWQFPR z5a-q9N{7az!-&8vu2 zZly_z3@UyZ15GNe^G9c5kU7(8iq0xqBgDHYI@9t;uPcYB&GtuUm2jPB71)ia8_sp6 zdG9Lgr$uTfikm=~ZF}p+zM#gMjJk`352&yq;KYR3#|`O_Y8CVLNf5<>Z#pilz2+nc zCiDQvj$Wt9?1Hnwxwb!kgeWve4D(Ncs3$hd^gieMq(KX+C6#>|&-+b3o%8J-Nk|&y#J8V_GC|BnDMPq9{rk4H% zXszyW1#e;%55Gou=)F1kYZaE57 z9Znv;_>T5?4!gFv?E;BW&gE%?JuN?eI(+3j7KmvA|>=S9>`jD7gRV44>x4M~mxKwgp15dxgJ8kK5@06)Z6PL>U z`s?!Is^z!ErX@cKY;LPuC}{FhFlKbNi{=rlm1v{eYArmRvR?03u6Rc1YA-!8M$N zwj3#z5S8)erzX$#*Kb-h2?`Y|fMO_BfXwq^KbsDBoZ0TLkKYwbY>+RJ5SByYm`pxf z^9!PGPLTe}~VeTIyY2&&S9s@$YmV zIRRS1Bc3IvGcE2K@2`GQcR!~+=5B2HO<8$8%U*CF@*4L{?WtDv4BLFFbvMg-r%N={ zvI!KAFsT?$0!OnryLTl&-AB8OU_Gt!(!{A?&RyeH6!MrJ>g9p{`tT8VXjtkrN~qqI zEIIUoz-9saj%}93(r4PzvFewY>&QPP5N<$xFxGBgD;j+3n=IgFx4r9Jg(ThVvVIEb zPu$EDuO_~3@vR3KHuK?x3|Gr-ho`@LXxACB%G`YK;psSd6t~bV^g>Nzap3qrLi`6$ z-@n+C;_W{f9p4yOuv-P-!3dz;k7VxlC)66PJzmlrK5|CzsI(Y)wPq~l1r@4>abvSh_RA#++2HVVXm-VNyf`h`BB_#5#xZ?UJuJzL! zplVuJ9a}Lm^G*5VZ;b*2Zr1JfG3Q+aKd@1^@jfA>OUk1)$_EZl+am(~&&Ws&Fc( zANZ^yHzQv|NP$*B#66<&Dz~)_!>R1?Ab8?*CstAR*}3_F1$&7-;4>{wc?n=!PqzX4 zT_%nL*gs>#DuDeRS8x5K*HBGsVTp6?hcAy#FKAF8wK*mZs!!mZc!&%t4C(FMJd&%m-O9BIMd9|Vw5M)5 zIHh*aHKzAqmH2pq5Y%~>f4A}neCLhcgWJolV6C_}JYP3A9O|aN&{@`_WrtJemRXzO zza7=-f4iUx--aCO=9^9Ck>vg9+(Br~n>}yp^>5)%>n&Kv+y2~-QU&F-wenrLvm#sq z=2204o@p&nMHW%H6`+z%9COnCPf)N3OSZyPoQ6bm`&BEwg;DB@v}%@E>^MM{e(il%}wt9)H5g>u3A3l zz*JxBp5S#L<>tl}fdlpW)XhQQ7t}e=hr`%@d7-jP-g@8EU7-uod8bL<)5%+E=RG_q z?=<>g{VU2`VbmU^K_U}rU>2Q5BMkV7#+I)isB_)>73H={SzxA0Yk#WN%g?s_MvY2t z2-AObOo8abm7-s@msxy>_q^#fH>65m{fT4`O-z;U<3lL+VF*1|NMfjUHo!;4Bv#Lm ze)&2&?dqhChgO5?hZRbBl$$F3M^&WODn3-aQ~pzZs6F&5PwwB?Z9u9>Hzv=XF5O^X zhw&GdM|3d5ZSN&l=QYQ8Lg_qAaV7!y{&Y;s#LI-(%T2h{a-@H5+qgzj@?S z(W1tt`kqB|bwz90TQ-LepAoF*w>WerBDCD5`uL(#;GfGvMZ{0uqT8NaN7=`b{ce~s zEfBprmu<5!C{HD^gHX*39H`6nS06EYQtnh@H#AFm6_R0E^A4vqZ>L3e|HJ)x;O9>G z340P-|A}g`Q+zVH6913y!u@}vwS9w|+EhZEs&UTuOlvuLgsA>t;IrkRJF7diXnscX zdGr4gYkOki_P_i#vv%3`;5BOJy<3bnF5cM4sm(?uv^FBM4;befmVNrK7L^vtXMrz^ zrI@E9tHlPIQxugs!O_-v=Og{yYpu>vVw0URB_=a~Xc)PhdQ>Jya>IM{J0s6ssGLk> zwQG_zM(jgWdtzCwq+RuPyOMKg4w{g-Rm?e#>DIRn2?MpoJYanv#E@pJkadmC>Q3v^ z?4CHQnMd~IsTlrOiBhk?n%7Up@PaC4+7@f}Byy{>3k@QTce?x@T^RKGxH8L6TzNbh z*_4S{GBWHcV%F-QLs zVeMb85EaBvu<^tZ%Ap$vkU0H=II+~V-PWWd)G`xSDT6=E@uO-K6j9os3)q&Kz zxlU7s)>*lBp@0{@MCz#v^EZ+69@hVZ$D_V6RuhZ@)b_pVz;;}D&t{7@2j%@*q3ry- zA1>agh^HNaH_SBZyLE99z%p@KI`sfY^5cu|!(=A$dLOfIEkuKV2WF7Gs9LN`J}*1$ z(+pWs&`(v;8VAcp8ND)OEtU!bD6i;KT!FA)%_`72#~G3hz^;(?cK*j&`C zB}*$*S;^uvxgvq_E>=}+KB#Lq6vb&|4}T(>*+c0-`0NGb<62y;t~b1JP`hC>f9=vs zV0d<|N}pGJRJHX6(o~)rd{UgC+vH7@>=s%(5a zIVVlAbG*iv>-l?*KWhCdAZHrQ>mc}HR{TRgD6LW-+>}?NuJgKSBF(sk>PseFWOrk- zmn-Q9XwushxQY87?&WVEfBQ+Bbin?8a=!W|^KQG7k31!%58o;+o%eg1PXkM?xRYnf zV(|BzZGV4L2k(1H>)>yzQ$8KL;aUD(;+=FV&L8gwI>iY6tt$Ga(l4rO$$p9~edZR5 z2c78CqUSDe){ab0@)oT5Q{ruiZ1c*{IkckqDzbUay!+{ZHJ2@2(n!Zgkhg~Y_6zd% zHHzzhS>Eep8jO=j=bpb?>5gayIP!?Ix+KYs2n6lV*^YZzdh$TkU~I9qitazz4FF z_I9#(I#-amc@dBA+_ZUpd=c19LLPnJ@XihK4M$7Pj!534C6lk^x_;l=KR){o=Vo$> zS^-$EN^MlxZs4J3ZP)sJd)IEIfZ{t<^GhcGkn8$=n|?Zg!~cD|gTot=^Pc0?+PsA- z@4WU6hcn~6l8Q^0s`Q)kTI8CX*S+EBEt^T7)Z#SkJ9f=)Z+K_kChF{2zc2CQN!O`H zCVo8mOY$~(L(hgiH|*oOUES}vVgH6b^M1c!&rPoZdW#vc~j|5x%MpDe))#Pp3(|qJ2j%>uUCWbK7Rz z?xK!yV#;Mdwry@!@3hD5m)Y-B89S_s_H=p9y_a}7@o;a69=CE)ALJ9byD%2smutr3 z`v_2;uhI))`!@Ah;k};19zDD_$Gu&TbKkBPI;|KC3+?fqwPF&BYf!U&k_btp6mLbG zqRsY-xKpONnbc)_U68fHxIDO*?QMZ>6~?(8iJkD$G5$A)dr?@0d(mOVdvnd6W{PbN z@2inllEQmWb9isQa>FIhh4JQiue-UhT`nUO%!g}T^Ifirc(8K1s~qX~Y13T|TndP~ za>^R*n#nKi>lhj{T;;$N_urEOQx41`)80Vi<8yR@l>HF^-HT;~3wYH^Nv}Y__p1eQmDT45&J`rk@L)_vveM zq5Xc0t#;p1Q*}sKeZ%7h-rA?%oNRQQ>5Gd~cauujEUmX2d{~NiJ7R6U0d8 zj3>&-YUk7b3(+$yc>dZLy7cCXG*V{LsYohN&ui>FU6Oy&44MJ97PbpNto;|9ccvlf z{F0BF!o9J=_z1Z~*@;`Zh8EDBl92AS*KTiSqx7`Q0377Tnn9v`eXR?zVe<6ma6d{M zo|qKLLX?`aq4H{8?8n*_4(d+`>VSzKvoY}u8xzOY$MG`And$NS+EXhI=z_ug@ z4BD}lr2sY6;`?(Y^wZ`-!UGW_1|NsH70N^VwQMoaqch zF~i`7gsqVw=vdQ0gZP#E?5`F1=$%0an5Z&K+nJ?VQ?#jYIApUSb>e$jT%mGhY0%j;2||PUs#+hj*WS&t_U;v$ zoolv3u;Y8(YRP0l(|fGKF7VsEDZbC+Eo3QW(#I(H1XwGwC)-q2nPkY2LO_`}j9h$w z8AOUk)b zaZaf{eyq80n*xY>_dM@5%VSA!^ctF=zTJp(&G5c*$^DXu8q1msw}_Or1nz+2e;A)C z!mq&J>|@q@D`J@?04mWnB6UCU*q-cLz`nl>P)nP04(&4A&)h^m!+XmQ?NaR_a#C+e zVVCNzIMrq3?WcVE$zwm2DDe%#ANpC?b?61jn9D0!pnAcZ8SkeHM)*90S@ue4gwI7! z)5VcJCAbz1e})#MZIx`(4y3qwjX7vhYVnSTBu)Ga{($V5mHb0>u7qBog^)0usNinp6MBv)i~#@Ozp5=|fyN|Mix3f+PA zfrd4YuXWSX)0DdcUt}x~h`u<4)sd(Wlv@$6?41@PUfwTqljq3OfoZ++0?Xjf4{w<8xo3xqRlIPgXqn6mT7OgEp21XCor5Czi*o{%B zzk0o>a&`vlpILO4RIgvSyIGGkdbGzn%$;X)U`;JevmHdSt?(7yN|Ql%r_RSV8O|M0LcuL>%&~j^cweC>ge?^ z(N5QQMCavvJy(3}+&1`RHGV8aVs1W<`gOT9$9#raUL{A?T2$*mN$blLAuXGqb)K4| z)F*N3K($jW#2WDQQ-UbnD~^9mb_>O&V<0M2UXD+UYrlbFxE}%YovG3%qZk|Xj|zQ` zJZ}@?-3T9kcgd(!Y4l+`zlisX=R-L7w#uce)34~byfnKUGURGVm43;|T26Pm0_Lm| zFR(YvQ;kU8_bD+|x|cdc$Hoyo&GMcg z3uHOme+-|bAZ(2{I@8S+_nE~PP{$BxO|uJbQw8^@ptqRE0+ZvZX=pR}Q9M`Wx5wt~ z6{=AK7TOt|r0pL-VSo{yzYA4+KbEiNK^P%%eam@rv$&9wQl(7{nz;)c_)@BLElm;} zxRtkWj*_zNdLpVG2V6JJIuW>H4&)(>a1KGFYlXyRUv1Y zFtrflS6u5^$KFAqwJSN+S)9f63Bx2)vtBqR`n8j$5ht>#pT#;vX9q?MnbQev>H}cA zjdR%4UrR&8w*H0}xMEvxnAhSfu6W;>*qJWKZxV00s+Y(fW*BshF2v})2xg5!uB4EY0pIY95(eVX!NOaFUPU!mn*}R{8XtwlItSuW$a`@tA^d7!R#>{ z*Oy?=7h?E${nly6Ti3n`%bYn|qx96Nq`jn_P|y48H%C~}exMRRgq|1MEp=oVdtxX8 zp{y_t+t^q~w61F|&qBRK6o9sES~}lbpZ5$a_M+?ka=xncPp30S_hPzDWZr%Z?}|2o z#O-3mpM#I8sQ5F+-nc>NGVY#n-zRr9%KBEFj}UHBX;2qhPvP_{d6CqOG(oDzTQb-o z-&Z;K!Qn&NTW+;wtW`eH`QPJ?*}l@_joFLGa)ylAE!dd8r)@#b8zYR_8;tgcIuGTv zKkd5{V@d3*!RZ;YLdzjUPwk$hOp)u$PGX9T;j7FP`7`QknIcb7+yS|lDN=@(6_WfD z&i_3q1e14P7QRNEQG5qHhknVC5>9g9)lnVE-01D8Bk&}is9`F$Sc@k`EW zv`1%+550rsPhWRsPH3KF+W5S{tTR9P-|OZ9ndmh?wi1|N2v0lO`s#0`!}#Tm1#7}a znM98>Ol{o{H2B7FyvF(w_UqKGc-(T~CAU~l09hk)j<|I{p9JN`l@(YFgIIeTJ}@FU zP-d7D^Qb}|2ga4LUyoz#5yl=^YsJ@$HyZ~)aLoV+GDE_eHYV|egJ&Z16k!o^oqfo> zAmO6s(8FE%2&(XOj2sTdO?Z=Ml9K--YSO%22tC-aB9Gr}%cYP&Y2F@lb9htEB-tyd z=gnr1wr>Ba$WZLpX_drzw(zUW7Ji8+v}D<45#c2B^}_8*gje0jvKm?_CY)#po~HvH*dAk(ID@)7{)uhdK6Uer?uOq7k zCz`YAHYK(&f;?#J4xXBL+P+`gG7LpyZAtyuyba}!D_^oufh z3cJ#iMPZi>8D^5;mb|gYAJkIA-xs$B)&jL+$44#2Puj9k@&2jKEtPxCedca`*{c)X z`EF|zgifN0gShd88`S~ZxS0NwOn8LMw9HqrQCDM@p6m=6*lz1~6yoU>(mqLhLP-Q< zz9V_I^F3vg1P0^Oij7XTr)4Ddiq4=j=LZDdogvMc^rQ8{=aadG&+E(f*>irsn)Cb9 zbNm+R_!f8&J45!-=0SeCQXi+n{8}Wja9FD zDs$7Xkj+-+IB#|rzNBze^X}%eNrI!niu#SgGj)DS*l0FPm$cBSdg050q)COO$zpk< zD^&>^lYWJ#kS@8&4Qlp{8?0KF6kOdRxVlC9E1$JY|3g1*4_?{V(Ga|pb!9rCMw6Fq z%-bo+EGrG+SDq&Me3BKIoncepO%~WM$MDkJ!qC!xh>47-t_Fe!2Fj-2^wEB2({1{1 zzqQG>^ENYt(43PSyJfFPSHj7L;F-&kYTydPM@Jkt*%*tdFl*#&Ayc*h?*w?ArdR)e zyCMU)4w^9=b0AxoWbWqnVI^i-Co0*9(Zx}%N^ysTA!GygZ{rM$pLx3ik%n$-(yJ`t z@MPuIjqIY~LPs;e+c=g-DPF}o%s!roLV;okuPnZs4u)TuXddp1=Lg3VeDrQjF~3&X zE?Cr84kfQwC!!i!599A&Tld zGX!1@4s5YVHI#8`gY|0!^`wTDFaizXd+*N;jWc~uhkIY)edy=mE_cNDwAb|ADqFq= zDF`tWU*mc1tKt!a0h}$V<(8kFfHegC3}sk zy^3E6e)A}XdP&*4cdO%lfl5R5#LA`l=@vJ=C1USRVREZ}RoM*?Bxo!b9jCN-a{G%- zj}yTAbn89feJz|r8r}l#cWhJ^aKEFC1Ax|5bd}U$;NHu70e8;Hg8Sq90rzI63*goP z_jJ21;LQziMkogO)8N)V8`D0Ec_nSA(muO~8<}`h*q9&Wm4f{or0=3$aA5ynZ@)BD z2Hmt_KMO|uBZj@gcVTw;m+vwP5$hqvP$=L?r-WZiOpsL7xJ>H6@T+}73H*l$jq_e8 zL5anYV&N?QHR9p)P>HKdKCkFvfINsGir}Cws@ zreWpajZ>V-BbVh|l+Aj{2}#seGw&91;;$m_GhD;dXYuROeDO%$RVrQe7nw4r5?5b` zqqVhX(s6q_-7I(6!enTzxIZWKMQ@~Gmv%j-z2jzg!|Zcy=;~~Uol7~L4Qpgyot%sYtAYAm+VwGoTXlA9 zJMLi}MZI;NC*zU_w3`+>^^p9 z_3^9pu}iyt6LZgq(MPVc*K{`g!tUcE!}_S^u+vBG5qb^lBf|dKs;57o$K;`3($m@2 z)@L(4ozFNdJ;|P?@jA;MIs68OO=ne_o=VEe?+|3R4V@JCjm1jvH?5a7 zJa~?6<#UQ{<>R?5mYn#DoQBIflVuGnI+Le1w7wZEVriDI`hvN?%vs@xyAc-D$!ZC) z!66|1DnBVlzGl2HUXHy%9>7js_DDXrf{w`x9`SI?TyrJQQYo!*o?%+CR}jUqys7AN zW9&4180@~6%>B&uM)Zy!4=lK76Y|RTr5AvShI#M(vgme#>~sGEVej|3x%vBA)j>|T z^dX*LJ-zf?RytnYAO6By$5=7H@2sCqKj+~;SU$aom(=3}pI5W39ER!N5-`fAbF-QowQ3@-vo;~PS06#UC(63{ zcgTGL(eGCF(s2TTRq0yQq62>OmA`;%ltJ)%6nGt=4rbgg?PE)YNqMz54KrLiWWnqq z0JB7^dPl1|0>svDR}hJfw>&>l- zRZe`K38J`VZ|mORc)zyp_hS|nTievzqX~|WyPlGH=52jVYyGu=gd7F7Sw-}dqpg1@ zBZqF4yo<9=!TE+Q@tVQ4fok{sy`Gs2ePHy=i*Ju7wkN?4=U7zw+^g%W|zcxy1_3~0U-*W40dIz6WPOxCSWvQ8n z;N)4ncHK*TH*|WfYde*9c)qnG{O6`c*soj|eLx6z+jHP|p}m_Bui>zj)q zkP+M4?6Sjd7_)n?myg%UZFLXzU1aX6cq#H-b)q>~;A`viuGolxq_4-~>#By zv7pcT<5P;LPq2x4fg6f87yxY+gRPnYlp zD1~qd&=*9dzRh}Yv!L0#zSh@ma@rr5E3i>?-G+WCensam)mSE3#=DcMEOe_6;_$EQ!XzTIJAOVt%1KSXyon!^%-o zmg5jcH{Y(^{xl3wJf15h)>#e{m@y-<`Zb-IO1*pL3I^+0XbY zmG?P>Ka-pCKg(s=Ybi7+@z?T}l}~gXqnW;vF{&WL4Aq5=@|^I!4KAD~lfDk?_|&=h z#Upr!X^)u!K&9F9(Zc&m&YeA9F6P*XF*|7pB=j|}@QtaLqh<(qq-alVtSQI%tu6F5UY+d7|ptN4FyDiQCmjd*{3@JphG;#tpsM4+Xus~s)(0!Hq~ z$i2Xq`vSSoweJh%9@o;6US#Hkd)=s#*i%fDpRuy9s4|uny5_@(O_V&v{8W$Sv^n=< z<-QouEvra?dkiH`E@m zN>UsWV2WyP5D5^PQ58O%6D*DD#{le-GV3Ru{dkBtkI$2Z*7wxIxl&emn515K1-8}f z(#rXrgTF63r0Z;$kZHagm-u_cY9KbHBsg8iFJQE|?<$)SVHSKnfg!{$!HzmxOmky5 z3*r{*R5ZuXd_poXO0vh9jeq?GI2E+{6(i!?C91_v(^u{=T1|BkU$5z_jQCzPeN_>k zW%@3P_}&2dBfbNs@A8Q6kCB_Zt)tuMe6*?Cx{N+Kg2I1?VV24cB)|Ed&>fz^)+Jhh z6miY2@GCQ{i;!&$QS}Op2B~IWz-_J-mro9`$kv%#4)rYCbbm`KRnb*(v~U|sY)#Ab z$?OnZ!AX7bhG4n1g!U%S-Ke$=E|&0`@ZP7b&yy%}!6b)Jp0?)56B<*5MYh_Mtr&c72MRkdf#TB}6K)F3bXai28Y@{a)X72v#kAzFNnt=MBA%lTxykg41THX#UOPPA*MjbKc>wJU*I4FXT z>iXIkoSSV*6agZsAb;(F`>`}OV}2>x+ZNZ_eg?j()v`=@hV=d>?v868R@ePu64aLC}B{3eBk3_pR)N3@R2W2 zS;Fxd;HvJ+q?9tJl~?~{@kF^OI1k)U zR2fbhtPx7sp;8DtPRgh?>^xi@`kMax1%nXS?XTfLO*hA7x_L>p@=}mWrJQmoo}$|! z4^(HAa?msUq~37I1{Ubkz%^W^fwi0?Xc*54r+K5;g_Ysg$H#vB9CLP2pnm&Z1*Vbj z-W;g!xofPRBKk?J%2&VTu6;uf6Ar0D(O$>eV>ib25C4m>F59eMv8|w?=NZ*6W7;bz zCG3fXVrphXW!##0sGGwE1BN!oBNS_zK1=_nKz%5qRecl|m7A({r<4QD^fV(SDOI4e0O#FC57VR4X_92g1^0fM5y*r2K za7H{{(kv(w%IPrTn@SST{c>n=iDzu1k>kq8n#^nII4&^{VE!uMl+0)S=3(7D!-&7) z@w;CLL}z-e^VUN1eV)qZzFi8%&)k0K1$TGbb)Mijj9HQ3tDqv!Sj~?LW*|uwTN;Xe z-{P?Wo0-~8sZ#fRVd?PJd+=5<$o;K)>{>U*>yJSt&T+DNiTD zD;M9EPUJ&t1}%(k1f1b)^X#ErJ>j$9wXGR^X^kqV%AO|23;4CX>dB zSz|=T=kR#!6V&x@%!BOdcEWzi%K%GY8B1l!kg@K)In$X2r!&*3&nkC1BZFP(bS6F6 zzaj&jDYiRv-y!MDZT#AuxrICF49-{$*Wwb1b2^(v9=_KgRV9yITmbO!QA48yPjE~f z$@>J~Wq12Zp6NC?G(Lxq%jM&wd{<6xe&stN2bV88PtrtOlZxZBC|de%pZJDBB9A$1 z%!qh4Cy8WT+&P_I-H8nQLm>PP;9;<_i~QwG{`hqPnhAxKz4ri!;_4dyXB7k#W$oDF+EGEVqsR=1 z1r!uJ#w2tErK}W1qY>0Z3{f$$B}PSKAy#5EL8Asc8VhPvY!OQoqe%c8_WwEep1V7& znB@81=X;;`d;fc3=ge=;x$VrIJF|1|%=+5(IuquT*02TMKk{`w6JIABX2?iIzH^pJ z@M~NihbrRMM0lwv#D!iG`lth1en=W}QLntQ&-P9mRZgGHdg>%N1Ei^X>OKu}JRaxw zu9(yNLr>G*y5DAKJ^zK?`c4L%7GAaZ@NIBti&<S0W6Sw$`59X-WXr{D z`8iuIWy@u3xq>ZMvgKE7xrQy*vE|onxq&S$M`6BO*!nkY`7K*+XUp%|atB-fz?Qq& z@<+DZ%a;4u@*rCtX3HaN`4d|nXUmgpd5SI1u;p2{JkORF*zyuvUSZ3tYZ?NUB zY-6XUjCUoXVE5Y#GFsL)o$qTXtj1)@<2; zEvvHStC5&mF153wfy<+c8!9ZhOjmMyYjN(?@%)5^9B~f2`?YQ9aSo>(yTG zSGlk)@eg=n2Hv(>F|jee)60(Q;Wvm;pI8j96WR~Yh33E7pAJS961w3WVpm9EG~5%h z_HylA-8#_+R^bQidRNyby1}YFuG+)HK{NL1yk8wjJnlWC0Pg&=OcIug`0%pxz3@}R zM-u-4wbk7jh=xy^ZDlXJTrayL@O_`>UZ!^c6pYup@L&*hgN2`EmcDxAX%U`SHN`a~ zJ{q3xgj*MIznC32Gw`c#VHdau3_m2TD|BQlNe+eX5UKne@i)p~GG9$db|ob)pV@NWAU`0}RD#Q|!71Q>46pMpi~Q6y`4>leHW?EI-_d5KNDVUz_G zWC`yYVdmTbrix#++jZKzVqR~T8a^;f3~rD7MOVWL3-679vO!V8;WbgL5G-?eprQrd z5A<>?g5|_!_dV=lp?F}G2xUox_js`^_rlkmM%mc)-K`$(0rz2Az;m?L2@SLH+Q+A2 z&fV|rcIEoO`^-S+3-e;JK+sYk^}j0@+b8%1Cv7kM1h*&t;vEb_c+I$8U2tb--<>s3oEdKC4``$cc60E3Q?N@g z9sG&v{Jqz#y=UAgssb~G3+!OlBzOWQgTgHa;~uF9dE~R~_>O`1_?qdh#Y zgr^9YLcB+E-G>hINQU1ky$wIH4fhf35^qDXaX&$NJwhb+_^Li3M|>;h5+?kJt>fVD^C717;7HJz(~L*#l+|m_1VD^C717;7HJz(~L*#l+|m_1VD^C717;7HJz(~L z*#l+|m_1;ba} z%pNd%!0Z9D2h1KYd%)}gvj_ecdBA-*ye&)zzYu^g3Q9YbW?dLO3x7Tp-p*ru*D@F} zgHA_MTrA<`-*yZ3rtLMT-G^ct@c!c8yk`5tJK}tulc)Mi2~l3~W?y_W^=x0z^>IjX zVXpv!r206_NV2y`9Kg0F>2#K#)q`K$LX#w269jx^IYLu_#O8(7r{lY}AeGr(P*P0P z-@5R53VU&oL!mYh%6qtv4&Fv1rS;K4$sOMPhp#0&<~8SIJw&@R`3ZaHkii-7;x%-@ zoxvZ8cM(A)>Ah-LOF#H{6;8q;q|Hf&6rgB&ue9Aua5XK!y6`<-I(XSyA20L)ymYLv zKi?JsRq;9muS*)DX4wpe&+8oVFdJqdpB3}5r-ZfLIDM8}(}zt0?KGHDC3 z28FqgpBP%cs!_w6uM4L}!&{Z7>ZC;2o6FFcUTD>Q#{1BcJEgqOTX79oVJ+AOR#@w` z_evY!P+u!IHl&_BvjU}NRy=os1 zFHa5cCC4)soLjs8wYqLO>SXMJn|g)deuAIWDTSY@ukHG|Mw)R=@tR|M#4F8WUvg-! z%S$-H7QX+!v0Es6u+m8a&j34&#aS2ox-;32BJt9umZMf5coF63#Z`olL1$?3Le=4Q zl{(cL2DR#7!55$NLfwyfz0Ao|^-@9=_UmVbXFzXqDOYYf8_G!sPv(ZhWvc({8NnsX z5-5pi3}cLG81pETh>J-g*zGcd83&x-y;Hw@t$(2g6j%vkuWRt4+ErLM;yuAO#ibEk#3xvE%DHPPE+OA^;(=cM zUx=nUv>;-cuM5o8rsqx51JlfA512h*_JG*~W)GM>VD^C717;7HJz(~L*#l+|m_6|S z7Z1Q)C3E->d0^&5i486Ohq5iuq|GX1H0o3ia? zU;DCLrB+!klb9LI9x!{Lj0et{96vXkn2#T|gEqA_`$O#y^SapsW)J*x4xN8sMs;F?esBY*cOb>;(}RJlrA(f zK1i<*3yKr*B`Mj%xDLNKZW4q}=URS0=3Z#UuCJ`g(2p1=_FxD!(d&tAxLQgku1uV6 z!WqQ2q|Y*mzl*pM>2po=`6gUw!llHbyw-PkeMEWeiK|fh4#cATory^;xe()wIt=c_ zB7GlXoH>laj~IVw6vHqR_BXMA$3!1!!l5P{K`i!9f{8wfSd?dqi9XqcXPVfjn(!wk zoKB3BrZ6lp(JwLKFHJauSomkPi9XXrztKdWWuo6^qR%$rT_&7k690e+=bG>_6V5Z? zpG`R5gf9~de-)VUO%wY<6TWA{MZ}`LO26^;Em%t|+NX|Kv=?XMT736OekS@r;u@q+ zB5p{WK@2mVSjaWe7n$ho@AC4A`0m8bD88P!K5;s+jyRjRF>wKLOJeOkp1z3hObovc z%tCKs;eRh;cqxKrgQwq=*pJwOIF+~!aSm|<;zDB4KbI0$C%yJhp1$ZmJ5zfk zwWK4xuy-LA=?4-U+843#PX=*4O3*ZY)Ber0e= zdLSSmI4C|WR5Vv9ARr_(EF{WMhJXNlP<%*`VM9Pbd_pL&*boqq5D|$6v>_lMJSaXv z%@e{x5@O@T7DzuzKtMoPP;eyA3euez8J-Z(fpQky(S$o0Sf3ErwKI_f<&F!BPl$^Q z!HYZy0Rf3IK~a%oV!}ch3$3WAE+&j!^65guqQVlwn2j4OWm%GX_LQV1uE4~q+edZ3{b*x>Qp7CH$hC-~qxe6WvnlG{k_L1KRc$w)mRKA1}~NJo$kttIIL zknh1~3Vd2Zq$#k{2J~&=;{>1f@M!@b86x$B1X{xS6!^RcpTG&>2|>Y8VXYu8hQJBI zCXAjITF@s<(uc){8#V++#e#t@J|QR}GDJ5fF(@w7pkwKw6Jy30wn6&PKEO+`JrQ># zX#)9fwwxlW?EX;^14ClL2x z7a2ercx>S@gMshRFo9BFY;;Vd4%=vaq_LGj`bKB+BhsXiyrv)hu89TDFEBbNCTL7p z=s(&C5XIE~FLwso8~595o-VI}sqDr6Guc1o#e#f7C&dIs!yy_O6PXYRJ=x^2I9+&b zoKCbep$~#Dwvh?ycCNC5bPSF0A7yK>|Cb6|jvxP#b1+_+{wN_LE-WatoNmd`|LU4H z)j>2Phr|X1O$>^pZr`xIryKUV(Ef%&|EKF679SE9sW*0ClCBqaYo1X-@$o9H4!-P* zGX#rX#?B)yE@%?@pQ3t2Le~=)5-~}Yh`Jk+be^%%dOXAE1_h6Wu14nr{jaJVfk82` zF_WTW6XSKTzr*77(4~k3JV*4Anl++?BTvC((Pvmy(+DQY4`}p8`3pm9Z%fWIo zDWxjk5Old|EmV4_TSRQ=YX&iiQBiQl$Lyr2py=SxAW51K8_7@Zu+5miA!}wkwUthq ziuIcSPRBkwEa`nz7?=@oQ0Umic(4&%rd_Ifg@~{yxD*h($e6D{|*;lI#|d3gc8GqSZKwOQDHhpMka*%g!bq`J3D|U%T#5z3v0N(3X6)0)W=80 z^TS(JG>0e#=8qmd`#2Ew4kgji7!yokpm(E&HYH75qVQrCeD2$vL!P#W#HtDN0DpwVg+sT; zEW%$`3V9tWWCT@SEBe$PgpUa>QT=wX~rLfN?d;98qd-YaaPIu$-V-tI? z%{={T)lAF+j}zr7pZ{$WEd_h`9{ zCn?hZCsKTOmtaL>2(VsugF!k9m47rCcVH6lOt^UW$ZooY7J|EGNQx49E~ER*I9tU@aWB1jAY! z(?>}iU>pC46uA7mbmFB+kaCC=0r7b%9bwJ6Y$8D8SY9!(jFLJ@#(uAC`emaDU*Oih zQSly8aIRHbnCSb)g+b@53MTq~VF@FGq7scZCiD4ZUl zAM2B($`QtOUcPz(pXVf>31z(+^{T+ff~44NkkIue8;&2tR!I`~OY!9~s?Go7R{viu ze<}5YZasOwcfe#`(r|v-)$xl0*x%&&# zBJ?K-&^tv#U!jxwKo1qidaWi>W%%=BGzOMIV9^6C%7&iM@1ec0&_QZwiD_ZVq4Sld(s;6<^kH8A-u`n{SEdN*x3lKH(wgh zSMNY-7E&da=CCr`+Z*x`@e)*e)V?Wyzq~h>7weM_dJ&M90E@HAKdE2A8`8(~p*RbM z!5$BVea9}=DKpR5xIS>7#4j#3BrHB&lmISJDpa(vtYl?vQ@M(5)oOOy>NRTCs$Hk9 zeZBe(8a8^Xv93weX3bl)Y~|3pOJG!#mz9!!fPV~KG80q~< z_H*F+D|EiAM)P$i)F`|EGRb}cZJ%b(^*8DJN^Wh=d+GbbNz!jM`F=^!(T;9JeOG-lB!@` zL8@pCYHP_#f}LN{s-jd;va|vVD>SNr*ORE@!Mc)E2|w%)H(6O*;fMV(J8p~i*6a_B zC~cmDAuZJWr$Z%HNL*@o%LkuTv_`IEUBOz?SfJ;)53McnkGl?iWDToehtc2zezanK zv|{N%{mGMPMg9X{!m2fXsNUpF$cz_6vI0+9fk*MfJ&2b7(FIN&`k zSjF~N2R`^61V7l;P~tVCJ$$g;RfP{WSiFY9W`fsV=ns^*4JBU5pboD+g$~ojxG3@a z1*WTo4{pQx0X67@+nc}#w|9XLvIjBtfyjRF!8k+UgLXqnjs%J6V_%GUN5Kd6(eTm1 zM-QKd@QH&DmNgkZSk@Gh(?R0)8Sue$X2J*K!*#9H8a~U3SAxWHtcDNfvkpFJ_dR^D zTqodz`t$HX{U~rCj>+1CQ_w&Eu8?ZQ&x1=yW|GV%De@T$*MUw_f95ybHko~M_Jp$+ z598qK(n%V?{Att=lhB{)(69>6Pe-yjNe7aSB%MiiCh0=boun5@f07X-6G$eL{DfpW z$ps{rko=Nl2FcYVGf8eFnMHCN$!wB2B=bmKCV7*jNdF%31Cq~4THA7e*pqZ1=|ZwM zNiULqBm+q%k<^frQ;C<5%p{pjGM8jN$wHE)B(1Abc}O~w^dcEZQcp6KKhj+4TZbU>%kWNShY=^WWv7d#s!q5!TV-X-t7_!1G&_Bb_1{-wZ zi220A5EPMwd8*Zzzkxk`p}&U@24COyp`q<38445%!BOW6L5C}oATT>GuO89SJ&fO^ zhO%$rOvM(y(BH)v5w749;k&vqj06fbBIqN)!WjC(86?t(aQ+E`@8-t9^9zNoygWQV zBlG;?ArE1}ckqD(TZo`!OLq6*I_JtgRjm3p;A$Xs_ z7(Ceh3?rl7;B?sB-^8ED*ak%K03IU% ze!S;V_HG8RM;zoSLq_lJ4l^@%i;k(b}N$9egUHRR<_1b_2V^71D@siNurHBXn< zBeu*o)bRS4T8nzUzTE@%00uvjz98GfJ`9EBB$elJ3;sF6)ePF;pU$uaE!EcWB1`z| z0cFN}R`KvBLKw6LC-`=X*G=YN^neb$S@zEXzCZK7vfIliFSw%ptG}6WMQQq1);FINk$UB7Yj*ITy>@BDW6-tT|> zSyWtd|G~pYk4v9CefIpt%UA#98!T2e_CU1XKMe?YHPI8!cE$;e;Uody-EE=f;t`l z9^416IERCsiwOssaH@(uz&?|BAdG+X0?twC@m^a#@!RZ566TAj*c&ms~IMot75!&SW4^% z@v%P6Erq{^vh)H~jQUg+WBIaFJP0^n#aJKfR>t&t1AD2sFR)(4eSkAmjQb-`#a_Ur zD#mYIItOF=SRXGHqkocAjQ-A0F}9Cf6{EijRgC-JzO^y^QNZph9s#T;9txxSSf3@t zVt-{C><3D$eW@7J&o*J$^uH>g&($H9>Wkl8QCC3R4_Y7kzmypJ8{D7PZMgqErMKBQ zt39!>cQ#>vV(fpgz3GX);NCd;Kh>ar8!X`dzX@j%i~Ms#=A_yPHcCASa=_D49pMWQY29}z7yQJ!I?>V zR(702S@!Pa>*=CBri=3&`P@s9GMA?5Cx8!mEpZMMmIeJ}454s`ErHe2>5aZZ>#}>v z2~sJ$e?*F}+u{B(22(xXKantQrS|6Q`IT)&#40(|EYwa8E}<3&s7XgZqCvNC)po2EqQ1 zHA%oUej>Cyb$DH`-Yc)?k9#dhl>n9;)4=xiS1qNi-J6awc*dbjdQsq`BuF3c!J@z7 zpoV2bS^Ic416h6Fa}30eV|xtme+EGsc!w8#Shg*cwZk3*YlQcIV_1wZ=5=Gf^wZv4$3*?u$+B(SQ6{DLc+)YBvE= z#jA(OV2%6s_5Fj#I9{#rz5}lnVwhbFY&8bcenOlF#97$1UoU$eH>QI}H1C5jA7c>L z7ovP2?97c@c@TXX9_#9I;r!_^s1?q0epA|*0=7GxL2DXcTu(WfTv4IVCPEK{*AKj1 z8}n74n{gJmj`j6eA5nVj&*C7qX{~U(aX&jTU*IfXV~B?`;>czY^^kveo>%Mfnvi=# zou0T(z_S;g?aKBw#`xR=rtx3DUT6vRee?AK&Rxg-i){*1M6Zm2b?gzOJivs>#df3{rU&b@oWL8%G zZ9<)XhyN?-;}tKqeyk08NS&ke8*}`-`tYYZLLfc7ro!uUenf==i5$@PZ}QpSr7x~N z@u*U#XIkRFPiGR82#?Ni@PSAP_h$Lt{=4*e%fs`RNDFIeTB^TqUrEesyv<@tyhP=t z#CK8o<-&4^rzf1Cj(A;(SCrT%^O9nZg#EkmiNe>*iaC^@KBk4&Q~X>u3DUvm3vu7z zbx=5H@EeWzW?Xj9m!FSlaCp^&KE&rgL|IL1!0#>KkuwI`a4f|5`+EE<>8m{?dgii6 zW%>J-`zw^4z3{0{_4AXs4@{q7;r8V{|A}7LgAe$%T@=(0uXc>jTdC_?{*fg1wkE(Xd*~zMJq8YCci5QH5|*eJ0bhF&6c;v>y-i5tc ziif#t_+pHxuz0e?Im0zXVj$rmPY-x5b3)ii_1ikRfjT{~>kaQa=o=ds9h9KT*9J^Y z?E1vuiC_hNP4f4F7hCZ%_{HiI^*nFW`au4?BHl6Kv8w#5 zzMdXEi^MC0g%D36T7fO3!`(70GCIsJE-WN6KFlK?U5^`h-ePG|FEn_q{^gW&czjq~ zZ~k^BUgUxBViA#MIpsxr{t^?c8~PUtEaoqlputds8Wt88 z9T~&+jxT$e3b*F-=GFGY*xPmt`LP)Ix|}!J4~>YO*gI@OSQNett#@S5n3&jjcw}0b zzg8aJvf(vTzOnF5CvIi|LcQPN;cQ+EH~>P%^@FLeLGV5ZLlM~A{%VFCV4frEEBYqJ zu!pprJ9Sm*aCKuhemy8;7O{}qh=t517Ba^~pJ$>kFwqy8=uL`K2E7ONh4+huO9MRy zN-;tF+Z?Pr424B&vV`pp@vsn#dhda~1!6o0=m8mrwRLtjJv(YB9Y=5O2W;mUIuqmZ zfuScc?hg!J#FiW-e_}jNF$5B0--IE8ShP<)u?<&CNyONXV@M{(XEiXS660}$A)Ofe z9Slo|#lFuV7Hub!Sj)|&EMj~%1Vc8l=)-e}YjU-eOI(XMkGM8*J~2L{f}wyIpV7fk zNL-JjR76~#xRkg7vDBaM4}3NTgEcWcFV2FN_$^|4;>N@}VjZyqaT8)^;-_^;+*q>N5#6V(v<_1Fqaa)d(p4gE%iP(uanYcZ1DzP}8(}}y0 zehIPoW}89Wo%ET+;ypT9#NwgAY+`q^&mrc$GmJA6dy+nnSeyv*iE+#jLjiF=j#449 zH*pa$&UwI4N<4t0Bn{y0VIZ+J@gQO?u^+KLF^*|t&=HICuLCiTnPYGv7CosK@ieZM zh7rT_do1`9S0Iicu1K6jY(XrZf3hS_C4D90CB#<5nZ(v2KCz9kx8we(LYzx_TjG4; zs>FrF)rd=p?TD>?czRl5d*bTE;<>IG#NxTGn#2xdUyIm+RfxD~NKacklT;x@!d#BGUFi5-cT5IYfP6SpVMCGJR^Pu!WfkhlwRDREa~>w&z! z-H7dpU5FisyA!(*_aOEnb|v;FmWd;X72+gfcj8oH58@@np2V5Ny@_*)`w-_7_a!bQ z?nhio>`iPvh}XA2u|4qsVh3U$Vi)3p#9qXMi2aHEh$D!H5GN6jAWkJ7NxX#kZQ@Mg zFyd_Dam2aAQN;PgDa3`u^iZ-?N^C(FB;t8Z{;)BeZ~eGGY)EfUT$$K`*p}FZSWE0h zT$9+JxE65)aUJ3$;`+p?#NuvhCb1*wvx!}a^ND5RLSj$iQsQyM_Jeu-G;~4bKx{$m zLTp9sMQlUtPh6Qeg4mWgiMT#-DzPhZCh<7pY+{&L%0e!&1#v#H6>%Z44RI-PWn$|g zyneRC_Qdsx9f)0tU5GVwf#*eRLF`X#MI1qFL!3lhnK+f$mUszqed0`FSK?e^4P7wi z6Wb6M5?3ZJCAKBD9?I)mpV*$*mDq(?Ll=}@#5TnK#FdF7i0cz45xWvEA=c>l{>mh_ zArIq+!7EXbd>^f&u5TVZix* z7;yX?1CHroz*#I@at^0*;(Q+r5io9p0cROu2!oU{MAP^?j+tW^NAYm941<`xiQ_aF z#*zIvN)P8tU`V8N6R12mUjzfrLBW7CfVkx4$M?Qrh&K3x>!WEq&S=Geejdlx_yWhD zxJNkS7!j{IXKX7@GzS{DV4HD*Ind(!KDHevn)8o(Y%fkQmM*@3W4m#J8P4MSKDHm^ zK4=U9+mREbHiRR14d3e7m(N*-ZP<>Gg&y0J6KH+N9@~`@%)uT`jO`2cLk*0hV))bn z57@q(V8*tH9|JW)9z=R)S8MEddIZPW{YV0(3f($eV+a>w+B8Pdb{i{%sPVLQh9(diIMgZT|-bJnp+*uJs+ zqo{t^&M`l6e+Jt-?mv+~wtFWiow&ae#q>S~|KV|f`HA}B@!$m3;{FXD7g#@E$`6kZ z{^tFY zw=|gY=lu&l6~P0}|HAz*%7^DE%*~(lynpFs*gtq)!v0Id=lz9IAH&i!wg=un;8RIF z#54a5g(I~5_Rf!YWB;Z;K0H}p97QRK^l<+f`v>0sdKvt$ZcpXK7yj%6b;7{?)yL32 z`S~87I^lu)58qG71NWbYp?~B4Gaj$pf1ZZpQ(gb^%EON*WBo<>#5)gp`Fsq=7cbvX zLwR}md{pJZ{cFshm#?3p{GxnffAaphm#Vzca1CNS1MvKN8`>AoAK$;I_K%OM|HS-_ z?UCp2Y3Lt${>Jj++#zh;9I4_T{p}c&5cpKU)&(F`G=lS{4-p1=1 zJf8nLKRm)ki{|+aGqf+BpRvE?`SmvVL!Ey4`y1!?n$~9!9D(Zg)nCQvpAm-op+9ho zXfeEeqYQdpK2MY58{f0Z1IEWaR5rfoeen7NwY?1cTliD-*F3-ehV-~SKJ_HZkEO%6 za`M3K`7^G#MfgvQPw@1`(I}3`0fzUVaeF^Q|HJJ)4c7}ieGgUrG5_I)8?O)Q`7@nH#;449Fn)jF9>Vs4L5#DAeprlaIr3;y zPB_00z^~rncPnVzkknEh>GNqr0r5rRBI0jEgfTq53}P+uJYpU3Nn&T>v&8Pir-}WD zza|bO-a)J|%Sd6P>5FaCb7V(e7ImEfdNi=TOnmCX2ONon!#}T`beG_7B z1ouY>u^0!}5bH=Ut|Og^;b$aRa3}trSd5!jAPywGIBxuD|5=b;PkM1(luSHJ#3y@8 z;&jp*`fbvSarg|-OuUiUo%jf`AMvNefy6tB^~48>lZm$xrxTwe&LGYs&LS4) z{T$*P(&rJMAr|u%Y={d;e~P$>_zJN!miy;Cv6lEKv5t5=@$^| ziPsP(6K@vriN$$6gZMkrXA$or7UT9}o2;(ZM69R$9EhDsKUOg58xy;eK8RS% z4RA<}mseFo{1 zh{e2(9>iIspH3|18C55C7{L9j2tC=)Ce9-sD)f|pN8$p~Pa^gweGB3u(vKnbBYksX zDVpcc@5;gR@5FOSpGx*^iFKrpCUz#CL2OU;!S|yQs zNcv^Odg6)1$;64o>BPf{#XPPW#2KVtM4UxDj5vpQF|nBURZ}qO=Mal|K3xTq{sZEC zYHziOi%360*pt3Cu@uAi$4Fu=@e*Pk@h8O2#4Cv1i8G1CJhVE*ex&y&7W2~T5(ko= z--UqoK>MpF>Gh=lkT{um9dSDG1mXgvVt3N-BMv0qO`J@;mNb7C#! z*MK;O^j{F?5x+~EOZJ_J3rIhi*oF3&J8==|KNd{!U5F(;_fIl$De1ctYe}C%Y)|@z z#5&TyN9;@-BlKk7h}fO<0mS*F??UWH`YFU>o}!L8ko3XC4ix__Vm;{tiStO`nK+sB z%ZW3H-zSbB`&Ps`q>m)dBaS65Ag)MUM0}lC8qfWkPOK$fNvtE@O6*L$p4gqZFR>r7 zp4cqR9{Atv0X}YlPcrhr@8bl){TMX|!{~>aLur&y+(*KaRjqmK>dc6Cuj&B?d;`&Ld`r;@6zdIgM&V6yN z;Y)lv+n5qhpO1S58}j4hmSV&k$HnlzpYd68eqR>fWrEL$y`CN)=ft~VJn(T&eA-+v zj{D$qbv*EK&rld05{&opFxpW_*6R&{5~SS zcSOy>hVpW~apYgHC_iUoeK_O$fYj-Yg}bY2Ha_9b?e&KC%2|wNi~FMDEdYXz?VsCE zHndNE9}-)M$Pe#B;!})j4uO4FmQD3#D180~9*?5^@^N%AD+K3<;QkP^ zRrq`r{$2*2J|8C(vsm~%7AF|F5!Wkx+!@~}!vh~D9%nfI_&BVw{9>F`Y(d8NAPE2Q zapiG_{+*A@GN@MV|nlT%WSobB?@tir5yua*bF4}6}Bv3z`74f|K#gBzJ2ae_sB&Jl+4amFX(dEgvx=ubE&7|yqRUX3yTH~o%Z zat#|v+;gy`w3)bBWmpBaq789+@9;R%x&QWiLf^bE9aq?*F6iNo4L`1aXMb_)5dOV6 zbo-0WmIqGH3jg#;ZP%#YEWV_@kRGn5Z(iFudvW+@9YuH8?JkL za7=V={N?CPcjGh|Veg61R;xme+OPhz#rvm@>;JquuCe^vvHP)wVpFCa6uc)Uut6e@eg%Z&)qWO z>lOVfb=^AP-GYG2$(7f?EONgvH#0A}{A2|d$QfsQ^}iX^^y>?5+Mc`P z?*BSJq4ubps%snFi@MN8d*&9Trv31((LsY^BHO%g-|)JhMcd9-+W*nYFXZ#_N7mN4 z(|@i*JL|f!G2ZoK>Y=yYJGOM+WZ@V0)|0cR7PS81_~`IO?Oaz~n))zT5rW=k-RFHgx$^I#=u4 zk9JI4Gdbwx_cg`_!N|bP>W$`%**`+pctMY}t~N`pBlWxYgiX-hJ<_9d?LMDl$Chs($}?iT)2KU&MwSnfWyQ( z1&^Zl&G#I9^2owg!#7+%*Xma0mutUqgLsmA|Gaw-ic*_RI~ZNrKi1+$&;9Q@m3moM z|D)lkjHeDo4~{Eq+SSV#e{R>T-jP!^F;BG1M%15_xO$!>UE8{&XJYE~&*~`0$Mx7Y z`BaodnqRGXFT%N1?`@y|;gRy){-YKAiw8$sSk+>})H&k^LJJCg zc5BAlC3c%eE~vgeSqk6YT6gmF!Shq2l{F20zd!zqe%VDgk2>EEJeoItNzI$*(|foN zx~^<^5zw0pb?xHgjUA^Dh?9{lQ&Slf0QzxE&eChZv13$`%7{2n|$gQ(`)@VMy z&r~hEp`u}{{&izUZVtY;es^FcuJvn{8F|DLJqzqEAZ;tiEw zZq~fN*0F!&!XMvi-SEKS^{3C~PdME5lR!KYnj11od;6!wg^}l5%5gWheY8G(bkpvgzD%^5JYfEveohmg#C&nvy-J+}rJver zivmijN9}LXEA7dVW%H}VZ<+GS@DR8&=g*A}qjxp)aTIX>W04K-TXMuU#Cta$fu;o10($F=$NH6}7)Uw|)DgYKvUr z=kN2rdu(yrfQ5>S-J@^k>uPmNI(4r-bQ^TL zS7k_7(q4Hm#HP=?*LrQ++^+MtU&VfPT#1?NuJ*doIsjebX&| zUrFC7OM(;T*)^$mY4dkqwcA?DZ~dGN-GA%VdC}spuU^%>Jahkaa)n75-Js~2rC<6L zZ@PTgag&=%H{V0?d1In~tCYEPaA`@!1FNnL$>`Bcd;aVA4}0&tP~&7p`&s&>JuVL^ z9J2M-fzRq%wO{MI=i2!Vl?VME{K@lWW&Z{HocW)ze3>I@Uf;+htnsWqYz~?#mq5(dWpfPRn=ge7SK# z$0k1QIv%enZ=3&8-}S;fKYX~jR<9TJkM%9R;&SWsEUU=6rz+HcS-f4|ykW=w*gvcr z?%^j<_x1bSQ!Y#_b#yy_ZTynzu-EaC`9$>TVXobrM=MKKrA$i39xtad$JNJ6aBCXc1KfbK_{FSBM zq>wQ$x}FW6;CF3Da3%0tP}Z3Gl{Kexu36@}#@D!{v|I7j^<`Uwu3rvmv&*98f~9Bm zL5o`4*ta9GO06c2jT#4zt(m>b_4Mrcsl|a;&mTS1_G)CMZnLtR|6b{{@VhbI^LT`L~dElBD>&%tQ`^-zo9X9v*$U_Ooe%_zm zD<nDN1NATMT)2JNz~YsDx1U@dKP|+n?TYrlENhDSN!r=F-|IP| z+r%3#U;X4ZX!+?B$K{V#CmepVfAQ^xV_j|rZ2U6qzSYxvsb@FteOo?pY|DpwrSY;e z(N2Z7_EYP|E{J^Zn&aG1ukI@sRxhyY?BBEQwgr#8TJ0X$a!R|4X^9!>$*wiOyX2Ja zbu#(`i<`|q_hWgQ7ymmwPyr6jif~>Hq)OFKN>)06H;->yy@Fx30uoq)>|HR(fzWnr|NDzv| zGy{%?Wzj3cDqAU|O~ z4fa1D+6m>GZQvDyi>;b@2OGHP)w{W!lY1H%)4?=Fdgv}Z6`M2zq5f}^II|h&Y7d7Q z$j!^oHGTQ+(O3`t&s)Z!3|zP)0cFO71@ANI+c^cLpY_t2D09ZYoP{zu{k=4lMPq-M zi!x(I<@qQJwr~FwrQe`{1t_JVR*O*P?ccN*Wzp&(pQF@0dH4lN{r<&YqRgn|vK(dB z!E-AZYj$R!)Lomk5@k+>;j5S&)8s3Z>D7N{GFg+o8o9t_`Wlql9Rt>)be~ac9m<>~ zmzm6a`c)?5^<%$AnfJBxdX!KOCZ#WSZa_|-^T9@x+Or;;P-cv`*o;yidWgxa&9k;3 z=QuQH?XRfiOeWJ$-(b?&(eoSByLVp2WZ+$CE3$S-0Fwm~yP5QJZtyK`FUU+{()r9; zCNs8l+=kopq@onk)>LZOa^N9 zGwHmxVK&=daRQUh_9vNiztw67ZcmR+W-?=QK9k^|owz+CAeBjd-c=^Eo_GBLx98oQ z!=&@R3`tqYTWpS;Ipy8lcj-K(r;Qos5n=jIQY%=@_hASjwcXPQzS`mtNhS$()BF zOcv~$#iTT81C!AHn9Rs1VNzeC4m%%YMR#X1dFwk&O4p__>Gxz6llo@|nasLf$Yjy( zDn~KDWX^B9qSY3oauY|Ag_~r+F}`PYz+SDC$Ed zvwE-NY;}amobP^P(s{7$F^uPT-ib@^K}@=@(=+K@JfCx`Z<$Q?{+UUw|3fCFp>>X9 z{Jk%;+_m$>a-@nbg1c1(WHgb}(7g@dA?>(@UB3 zE2xsk@}JOvNoR|;OloKMVA9>PKa&MXqnIqZ5y7OsZxWNq8MBzwmMmh@*>x?GMelEC z(r?=VCIfGt;dMM?A z((hstlkQ*7Vlq&_h{=rhYnX)ofytaj`Kz?yTI)D2n6WX9~TnJn1xJ(t%H zGMQ!ZGn0OeuQQp`v4}~X@{&n?Z(DZ#m({C2lLg%!nAEoE%4C`ALnt>3^K@IA?y9`i z?dPiPIz`%j<2Lg22ZdD^o^Xqd4tDK*|BTy6x$BzW-hSX#<;QD1BRmhdRbO)`@c8T} zZY$a~*2M%UcHvWd$-l?dHP23?H%JMF2CAX4y;sp z-H)xTWnPXt^62-*Y9Dp0Bo7FlQe1Ov4Y@~f@`vSaHxdwYoe#uTtQF>UHH(>kd8J*|e8?Tx)ydV6D3H7lYzo ztoxy*JY#0T_IVFpxGk*Wdw6O4W^zs2NnVBVPuybs4_WUz_LjV)|BxqlYB!OyJ9HT3 zUbns6#U->w+Q|lT^6zPlG6NdRH!rk);@iKuyuh|;zHUhk+2)4DXI@p>$S=dzZW!U) zSPmK7wO+by6S-@vQ7@D1O5Kh&%x#f6L@SR?h@LuhVSyX>kG5@#0E$bJ?QC=AaLz*OXV--SK|^ z6GyqxsKvF5erqjveZND@+V%D1;g#ZSM#Qy~hi#nvyi>!L@{mg3g$Rx@ooSC-FBnzw!U-1_nt%ijC4iPIgou`i}oy%nO!wL%78sJ677 zY}+NcUV5|Ea>{#2E~&8{3LxDmR=k_wv}LMQ*>>@6q9W|DJN)Iq_2pLu@o7YJWpD^*^@=x95?2I`@u3p{cmj3JisCLCw-r23fs4EA$%ZHENEx2>PzPzz& ztLZ~ebdh)NXfrfnP2b+(d=2HdD3y=_bTv6Wo<$?w}*NG;@y(%TpeO0-IduGiKrnQydn%!i7jB_X1FEI^IpK@rU^PhCdlI4U2A2!XM z&_llQ(Jw;|RdbWK_t%E3fstAn$#&el+{KKAAKbu?JZ|{!LT3h#p;}7>DZvSv~5Lht*-}FX*@%bx9qYy zu(*Dy+xqW+Y8d4p%b!(l>RlzoL4L<^)!y1wUb*$PX?VNOurBh4(UnS_Z@J3dqb?L( z{k(;ok~Qy}507<~b2HzPqWg808=tAOJXPr?&uTNNs&-^2`H?1Q^Q2R*^7TjiM`*vY zm7iIE8LW43la(>2lU;W9kk?La{Zpr|j&gL!nyA>Y@2-(Ie%4c!@&+Fh>y$(Fo`q0ijLx1Q4=@{=x5j_9Ug3tqY{mXt~# z_;-@+SJbF*+rBFuM_uLqfz~tES}AgqVGC~l*tw@%#o41;(Kjw~NP}}TdwD8y*M#ox z*@X0vf2p@)#7Dh4%WE%e)qHxitK9IjHa(`hw33}aty?X%dQbV~kmxy=-8#s1?=+o# z_77;MSH{i!bX03OtyQ}K-%C~H16?Y$DPB|T*14x+YEiGg@_YRrty}s>8~J8n{~6N; zw3ORT^1R-wYHL|DsHU~9m5)67p^8Nv zTyy=dC+~ctldnuT8KN8ALH263{{F2Qt>p!GUOfo)QDnQf3#aVd(^t-3JMcy1m#*@L z)d4fsjBP8Q`rU5Q{$rkU!65eoJ~^%BW%-Gd2gJL}HR==`u;|@DUf^|NU)Vu+`FNKL z9<>g4k_Wnu8~*9)I5*GB9u;k#>f{F(ZrJGOwUhgNY?1b;!2o&0*H5nw`9qd>huxHH z#`U58!B-Bv-tD7RFHM6&XEVJ>d!gLm3J4`h&s|+uHEd$XZ0N26(Z9 zX~W{_Z6loIDXTA~7F+d@AI0r;>iooAe#8ACaamxNW)GM>@b?~Y*A+B|zgJ3;)pO0X zoL5SXr<(N*SH4nor74X|Q(h_CFJ)}hhP+b7_v*hqtT%AwX1yP^c%@i3o>H{e>XlMq zZlBV_cU~$v_cY&H9eb(V)$E*{y!oXv=KG=z9p=AOZu%`=Q$OLQlJKkMNRN>(mH7IX zC(ZBiQhAF7kOdm}f2n-@QR$6yzrIk8Hp;lHIr>7ml(J(&;N};~$J5?wR`Tf!rL$x9 zuFjM5mp`}pDOiNd%*uwC8OcNS#2DjDisDyesZP`Y|qfZ|5N2cC+)(y z_ns(D5##EvIR8Ycu=3`>Q~RDM7q!EGYrgr3!tZB4QC{WDt=j&>CrVtlZRt(@6J_(n z8&!UI=ZR8q=iKuwuP4ea$EDK_b$+6>zMkj(O!q`No35!bsOl5tsr{Gp_C6_9ly1e7 zhukVv&e%K8(VQt&dc1-!9zT{U>+g@V+p)1!`Es`AQO@V3O8=}4MZbPjs_ghQXIHC) zQpNtGAowp;YE??wCk-l9uI$-5d2!EDC1dq;P5(BaXQ5Q7WFMHUsZ^@CPt&}xeDGLl zH0bTYEv`RS9#~HG2*`V^OwqLa^xHj;mHqb$teb9ntfY1SZru8%kCoijNhv-bKUS(9 z`l7n^q{qrPUw6KFdCX%aI#ILl=!nNk-@5N6oa*yfne)=)U{UAC%C2AfPIGAfSh1P% zWpq-_$BI6s$~y%W9xHVNOX>ucJW>vK^Bnj1+9M?>H>Ks;Q;(FoQG4q|?R})U)&Hup z_cxD}^thp?dait=5y$3HN|@{#h~sdeYjM-P?T zwezw^-+rj9xqff|nEZ#zNbP5BQ;$4U=0ELsXxGk%O3vGwah4k&D(jCmD-K%rQ2E_I z#rgEyhf1KOzh*@8L#4+!zn;I3f2dp^GG*uDkcSE%zj&y;oc_bD7X2P7ckLc{*>r!X z46w``@v6;3rFQA{->e!vR1O}feyyn;u%8D0A1X_It_07!|3K+(*?wKYuMZR-$IE*> z^B*WNTUyM@KKekpHgD|}dG`Zl^p8U_&TV<1^w&(-G;P%bWlY}I8{HQ^P?EhgO)XO& zDDT(W-0#}t2TFM0sLm&%A1Gg(e0cb$zz53F35Ty=82UhYb|E;dwC@AO_m2(Et$I9A zW;H(BBHZbLGI-Q`Ew}3)D79FC_+iyfO}7I3npukG*?q-o%bH&E{UpRYTxxL~2)eDc@SBAH4b|G;0eWjM`H#J?qxvwQ@xJ0^^~?P^k@uC-HY);7ynA2So7DDM!y)&TzBLOr zPU?GK*}7}w=$k$6D^DAZ{r#Qx_mv;DZTsJ7c3=7K?j8S$_V<%y$9-0!)XYk)k(FAa_?}ql@^os6(xp{O zwqJaS(n@n~%C`|EO7W-3`lj!dC|f7a|6tkB66Mq8-tb?dj1H{3_wT0AaRe6pwY zd~mN=Nyt`Q|GZwT?C#%g%)|U*rBTYNO_fd-E29b;K5u%kSZV!xU-$k$6e~A&mW-M5 zO|i1*{rW*W))gzus~6PMEH75RT=hxv&;`ZHrMBravOX?WYS^b#w@)cnW}a(M@8gNZ z%B1*Svn$0EE1Hha{pN%gD^*)12D~-8SUGa`#aBB97b~vED_0BfDps2J>pZ8LQmj>7Gz0?-HEK*jr`1a}V z4~vxaFK>-|c&|vQ9yon?rJF^{qQ3Job(e~i9?QFo=zY3KalN=}(D)-o%6N~okJjZB zDY?s9+`ILCk+S_>ySVmSij;NQh{`EziNs%)1 z|6}iL;G(MX|Np(iJb|E~sGz8*R8&-C)Vi&$sAyDVq?A;Ypo3zeOfVJ}6%`c~73;bi zySXkEZL~{8X2lj26%`c~85Nlo6_phg6%`fL|9$S<3*$JT?Y0m9-^$C6pU*w_+;hI? zdmiqY`*3dfT<6p>wm)px|Ig?5%zonQqeJ#B>Y4rB=yeuKV$bZyUE^AhIi_cJxOEQyhwi77OGUF-ojvNhAAcr$xAy-3-|2z;f|VYi zDA=og%=O+Mo;}at$9#6_GSUdhulByjYCcHeHn!E1tm-dxlXt)Q9&@;{J;l3QJVyL6 z#&(IZJ=NGQGq&}|p9rfkw!@758;ou9$$^c=wt1(!#@IHWk*G7a&G&-07~AS`W%bu! zY{%+bB8|qj{`@szO~y7)_v(Kw#`aiayUo}(--GTjwxf;xoyNAg&chC4JIdJKV{Du6 z<@Xue=6m>Zqt~C_$Fo?U-q@aQ93N_IoAtF8A(OnzznfKq@PUpweDZXzX8?C`;EJ3f9O{I>IuwlfR{F za*I7VD?GU>@uB}pja?=in>`m9!l1q%&24Xg`qXc~*;>t5QfjL3yS(*%{&-3DeFUZH z)L?x(`!p|`@lD<-vKja@@XW-(`AMfYJl5b{vhp>4m!1Efo1Icu<9(>f+^5DBHI_Q>c8c>Bp9h`@+xxfI1A9HN*8_V!u-5~7 zJ+RjU|4Sb5oh~NN4wkk$r&NR8{i)-2_{8h;(dt;0miedV;(8eWsq_Q=`Pz}kv6;6! zB_8bVPtEz#TTuk4XK2Gfi}2eL<{ zY3AW;kIE;|pBY!}Yv9;o(oOZrC(tn}OxaWE6R&m%dsLcc9=`Udd;vrzQ-$j>V4w1paa>X z(lqn%wMXR>=+BI+_J#jCSmNtRcZj&Y$E)L#iEI9)`)C!W(lY;i?NI3l`t!A;^Qd5{ zCtm3gaea?herfTE*NOJGMa5TXntAxzqw)##XU0|gX5!Q2yPU#r??6#^3RA~r`ozog z(JG=!%lz}TL#4m>Z_hliXmQG7%M~BTYfm13T;sz<_FpFNm!kYW@5n6mZTX_C<8$&0 zvQi3`uU(zH##5BV_smxo=B)O9Xg+J+fd>*{d0|1?s%4p3p4=i&RtEna>~<|PvTubI z)StQjqjziX|9d^K*8_V!u-5}Wmj^UHd>iQsk;sf-iA+K-3RjouMT-iNDAy>7$`~n8 zNnsLI7}+zr)7WR##5$KaCi5}fF-c=(%;wOZkWQ!Dk!?@c(=hj&Y`2Jgh9yx8u}Vmi zT|#Eqy?L48W;}y~N7-eRD_BNh*QiA!+`ZhSQS*&=&lUNw7;%?F=gBOgl&F?bGPYIT z>QD2gn?7KtU;4)W#9$RZO+=-y&SP(0z9NL&cyT;mNY|{NQR%;ON5!meS z@7-4CmD)Oa&g_-LDqUN+Jl zmK~Zt!t`yRut5IsFORt$C~knT=&`hiLQ7&SV}to_f1ofez_A0qH}f2d{p-ws`yWX= z&@pOZ>S+|uJ2|4XuFK=8YQC{hemH!sT*Y+IRAu5NTK12i6JtvD?%oE!et`oyonq$ zk;Q-XW7NL9AkLAYjO8O3%Q;sT8sk~GRl>0={BvV$Rz9S?nB~;j+z!P0*d8Kbg~sty zMo`|vDQ}WY(GHd|J*?8w7S`mo9{Z<<$@J!EneK^_>8|lIJ!zaw$A5!f5sBU(dp%<* zMqq%ETNQ}E=vaK?8I5luWc1b%>Aw54sUu`+Qi4p?;$&>kn9hi{QB7g) z(Ch&l%<)IJJygQh`;=Yz)<0a;gJ%SJg~;eazk1N)j%1uL($M3E5jRvuuQ%fE7bg38 z4wd~}hsb_O2g`nZSUjd@LT6OlxF&B68FlUPJI-kl=Xz_Rrs|KfPIOVfN!0IVT1k_) zmFR86gAWK-eo(&g#`kFl>%IQd_XV;~^#{+c{Xvhf>dO;DT}`B}CQw(A-nvp}M6;dx zw*kHHhB2;(%Bc0mxNi1My`560zUA3!v{SvGhDykKqfMLTH+iV>N0o{GHJWxj`g5QB zR9*TXGu|QNXe9Gu_jJ{#&h;G2iCO~uQz z>@+{rk2m8@amtiH`_1<2&wk_FK-vAn$2w)K2e=%}v+OcSO+7m3%E~i8@uZ^bs(KE(+%dh`l;5P%mBceF3M9uK|y)Y?M zCNTy~;&;X*_D^E}q#4mY<2%PT>AutFdCVOdUt<_2VrC36ZyXzp@0s7atTHwu2>)Be zn>+qj^|=gI?E?FDnRlCI2vojtAu=u_RK_KZka06c_k?$jY~qZRt!#^q36haoj6U~Q z<7Ar(4ZKC3>^rPqTfRcKdIe;r{ifmp_d1bH1WH z1LrC|Jc96W!beHuX74#HILabXTO$+A-#*K;G`SRf!Q4%;URI}7oP}1mIlJ{g=DX80 znMmAtj!_)w7)@_GVU#tLvW}pvw539$ti$ZHSgaDnyxEeixxFdld$a7OPyBsg?jNqb z1ZoH7aYMBsHP%x{lV?omiRv8J7TGk~9g%IEOZ4>o#12o*@(0K&hH)qG)V^LwjRiThX2wBc&PFkHb#eY?R~5M+rG`- zL_5f~=r&kLYt=29TnoOq+o7}Cw*N(ws4atYf0ge*UVgumq7S4k|Mpf*=GSV{g6)dc_9O7uMp@?ErpeL3+;481`%N1Z4^>_xeCTT+ ze)bOhcJmMS-`2;_Fvd{E(LiJ95Oo}(`p`{-zun&YlO_jj(xi?0H2-v)3-RS}^Yd_T(h_|D=SS_( zfN{(LQkxJW6G(f)=5amxZ=xpe?`Pe%eMZPWNz-K?jo)9pjAGb6%&}hk_6wMIykXx! zdo{;qKh|vs;D0^b925OnA4f+qCmuOCCmyNE$hp`%M7#E0zYJwQGJ^RC^O8k_e%3-P z>UVIWX>0UEb)Dl_{W^y_$0w^s$)BcQ*9?_0i~O!@4i#?NZI;>GHhHMyh6>-^yva=0 zWOcslVt(Xde&jOdM?FSa%s3{SHV(lNVcz-Fr92EqK)ZoJd}DE!8|oY#uggC6ZG~P;Cj2i zokRF+z)sVLqrBH`l<$gv7#y?Dc;E1cX{*U*`Hk)9$yVkxp%Sq^BweLZYouY;_0#Wq zJ9e;&&u=<&oP6OO&J$gltl%8H7S{WVH_i0uQM3cvhf1%*NU!s4uRReyjAODHZnA$`W;}n^`{Ag;>ni4cGabF3Gw$-6bEoS8 zLxt<<`CNzf-yZFh(ahoW>t&1dE2G)EFO|LYsptdLZ{!&2dUQaam8!`6?c^(UEyg%L z;58RjCgMaya-Yf=kJWuZvyYwoi6(b~Zv*tPK>hho-I~;a`}Z)u_9^FbFd;xc2$cTE zq}}(iCffp~ug>i=>;vP}QKY*792p?(0UwRF=+`DA#%MAEAFFXIPxC$xWR8PrQ!HM; z>ivQ_MFw*U#-p9CbC_+zWV4M7b8WO8ejk~3nE9COA0BR# zaBZ9nj>e?1hhfnNavwswNk;SpcMi_B8Na4si1C7=Hr^@Yx!yXS>&N4{PCS0A@q2%F z_b2pg#eUb8_t36D_W#>$_4oHQEB9IK>i)fZr+V_nb5FIYb1LVx(}QFbXz1|vpQ$Rc zU)V7B%LdYEJ1I!s1oG-&I{snad8R}4cdt$UZP6^lc#B?d+8(mk*MAJyE}GPZ0{-?S zj@Le)u|C``;f$~0%qhbcg?eq)e;W@m-yH57the2#HQKJvFGX+LO*UT6_1ZXmoPqvk z`f8Z5YTz8=-v`ZO2hLsG@9{l%`JdzT?cl+Ck^bBIoP=wajIoi7u>;SfsC*fpqYvWV zpoe>cF762?MaY!(1M>>~w{o&xL&jL5&V8nRdb(Wu%os_!Tq9j?+{g2?FM6_i?u6f( z#8LNP^xuTOY0j`DMjxi`KiN|b}}$`F>NsUpYii>ZN^OB zdiySY zM)woXA2BD2;(GQ@zvGQEM$h1$rE4SiEpOnyG58EZz-^y%hk0M!d{#ik_x&BK?C~Az^m|$(xu+E-;}#9{ zh-@{CdHdKfx~{@Xr``=i_^<$C2Lt`|*O+u=djaeOzzbCf$2|^|A)>419Q2lA)GrwMlk13r%atOsb^wm^iE^k zKsz07?AP1FFmtv&ZG(FI`47x9hN^p`ZS2W>e^25J_}y%CKi4>;#;LvM1N|JhC+CBI zSv>?A|5RQ3o||_!-VfE6%r;}PdA{A#zNM%89~j?v)3-ErPk^=?;(JY=-+4oZ4>zU{ zw@*Kp`^>5IX9L5y9~;WO*by?(dykNrFnRx@`*a@%I4}C={ZqI9QG13v?x)(Imo31( ztN&EEzx~6N^&j2mpT|$#{zvm2?zo?7!+)xN{(s5$r~30J#t(E&zVKk~`+>_F2JhJ# z^Q`nh@vl9|B2{4e9>(97v=c$@9>(8B+Fc-J597}zZW^%cVf?QWEF#2zE6_cNq0SEh z{p|C*RNwEjt+%&f=Ai!t*A0h#zF>Fu@9BB|zjO|*&$;GuZdLOZ#W92TGKYQFz>Gii zys1q;X9sLAKIi*?^?tqn{srg$f3@BJ*VF&6JP!qECquQLK=%^&hI!xd^7!3j4dfSd z{4hCCoPQ=vfA)6h=UjI89L#RV!QG6L`q-y_vzX;Gd8pr_+`k&;9&F%!#&Z?kYsWs< zW{qbj2Ckc$&pfF2l-KjjaF|8H7TJB?S2mvI@r|dREjDd7f7|-AK1TWE8=!1~=1pe@ z+vH+!>mJTi!a{5^9lXDX@pFm$JK*^Hp3UPP!ItO2lL6A#eV~5#Dqona&XcAu3?D@w z%sVu$X08)ICX=*>c6xuZ(|m4Ws4*{~AN{Vk>2ZAStDE@;@VU1=gbm)u(C<@(OW0Q9 zoxa`G>u_lY%5SJK^5+U4%HE;EP5b@X>@VhVfy!bYqvBjbJ?nn=c`w!6?_XzTxXJ(M zapOaHriEu)*84xj$31ra8NX#bTuVF&GPAShIj{PsQU9S`%v+A zGX{IF&F0C@Pu6?yc_y0AD-MouNR>1yOx^%H0#vh=mQ-x!IR1J z{7ZONDMNqfQom1Y#y8uSd7SBMy(|IVSq{_=%`{B*ODlRG^?qCg_Y%WpT;broL}iEh zUc5d=6>?tj^HsE--{AOSKKu1lwoRgPY;tsfaZ}qTSoU!(<~@Z)yr-~Gcu&wh@UE{) zkNY?~t$SdcOT517#aCb8tDXU0xs9ROdwvL!QH9>MMAUO+`(&H!7sw9(ex;XX z1bKVY(A&Q~NbE^m-_`G!&>#MhHtz3t)Boze7(O?id1&)KB@yDiKDnFrK5#xAs!f}D z>h=!tPN)71E6=X;%+lB-o^M@bJi|U*UpH+x+04h>{;6ypZ*YWO2lyX*%r#+DJr-PP zle(@v1`KM<*&jF3&IiRsT2NbD4U+jJB z!EDn*v=O6Tq7Mz@d8|n?B_oDsvLq&&u4db z`1{wi!({*cL;1l!p8vM#`-8#`SL75*2i(RuT$Sc zT6&upJb&r&1FQ?POP;Yj$6vVflf^3CL^Ivtp8xalxt^b1<^w46{**b+JKxXtmce{4 zaF_h`GRITq{U~$XK$(Y(zke{#IPWjxGvaAO`|(ajoT#TGmCXaknC&-!PXhT#Q_lo* zUvHp4n(bU~b3B8|dm)j$7c%f1ranIUJ)5b=4KR<{DXjqaq)c0fI^NI6{{9>G_wkVS zb4`b5DRx;)%|EX|nGL==W~j%W*Ra=7i;YTUO_&o6}8<+_n}X)%r)iw_P0=C;uk%>F)bO()vN zFXsIJiV(Xz2W|^sgIT6Pb$1?qs03FAI!={+8DqA7EzfW5r=jXI)FPpUwsgI}>+ctv zZ?ch&*{02FRsL+&Z-93ie~k^dg761+Jx4|;`N_iqp^bL*)w>a9Y6a%)2^3ixN%5tCjrh)${yAei}vjFPJfS{p5ET};5zi4#*1S8 z9NtlgVw`2&%}%w-$Y4Hx?OIRMFHHB{5buua zBaaMpvCp>ho%++$R{84fd+_>Zbi9*mEUcHn{CNWN=Lw&O>+g{;{n7uTC)o~HzxhWT z#_DeA-Z_zZ-9w){YFCN9)7oZfGUiLhyB|~ILnOZUGKuwE&RU6ANO(rMIFqiFo@251 zIJ-22dDkLW?@0NFY2)q8#dtq6^j(=Fd zd5nMm9$}LatQRnX>loe@z?c*BE~ND)Z+Vh+FW^7@IG^j2dOwfgw|KaW+Uh+r`k=6r zcKR){c-P+|nPz%sTQqs7zNd$?ZV_uFMKVU4YZqzydU^cTbVc)fFiQW;X+G1fvWV8N zw@nCmy{*Zx0ek09Vg0s=tY@g!H5)T;f$Q?-7^du2=bQhQZPSk3jrnT) z-IF-Ojgw|x!^JV{Rgc4X#(dux({^1;SRd0zabII3&%pD0k+E-5q0ck$!{wv5j{tM$ z;f^tF^Y05zO`K+(s{3Ta%p(t9$9xEE@gLh}3^BGv^6cfK{;Ruq8<)P$K{M;-a(;>7 zoegvCTyt*FQ*M_-uCz=G*D|d4PAO)!!b)Ih6GSGJbEFlC;4x zMZ4BActzPe-eenTdB>Z<=Qq4_WAF1mreC&RW0&-6?b74#7gYzUjjB2{>w4%pN0YLB z$hBnjac<}9Lf-oc{k~(1z8Zw`MVm3@8_3_ZW2kG1*9Xh>NhuPp{aS*19G$kNplt8T z5+YO8`i-6iQu?4>7CmH_{xO4Ny?>bgdz)uyHHTUgdbUhe>yvtZ%{eDodbZeQ|9k9` zMjKRrdb+MTdf3r~XPDvaQ}K2V!5+I%E{Twn*yHNb!pKdemsp$E%U(Po{?6Tl4 z&Ut1&W2`c!w?v#>7wF-KY_>~>xepsuT>mitG`#ny9%bBb2zZaG-n1z7$3uZ7wq^lfuhDBa9qo`F#7yZWtb+BL-5p}IXg z&tIeCLM4uM31d0us<)028|Gf06;UE3nwbR-{YTa6|UHTY3#BU?Bjp;t|yH}-$ z8S7|mHs)*ljW{WKaU?6q?|NQRV_B)UnTZyxN$^dKk%8LoKNB|8x!aguM630G0-P7k z>j+st*yRQ=s?qOvHs{6N9ozb&T}FsQ4h(SY?w`{PFy9E(Bvj2El&|K(!^|C~IvjEc zINCpN&RgEO0MABxc3ShO%{=G55y9HCqaCs`z_I!{Y_re(d}E{=I5$M9-)PLG7x~1= zHlEc`>pZHyzQ}h)AIdRGzt=XnCY`a${T{akt~L3udk~?{O-ZbUz&Z$KxiX_1k_#^N zFPEC*n0-&eeetik)nf+DqGBbUj-&lLvxAeZf^BhG}bJ?5BG<}|( z8m3(ydW1vH1vmQF0qru{@V(jhI)3Glpji%iBtTqmxy^Tte7=7%RQ(x#2sXz9+6M2R zs@0_i?$cf}&mmWXPV!T%*QGbTbWP2Z)Oz0m{1Ck_V|yO=8kh&O(hFBKZHd-&?_9IV zsMkG-qqo7))aeL*E9cq8@wWHif!~E@9qRjeChXC``&FoZj0GNUzRi7~XzU)#y{WO- z9^wwpcKX}R`l*wOd8Q_BB=M#bZ*stR1MO_uNSRg~#G3Y2#(^>F-izM~UWRR#_%PS} zy=z#GCU?RoI%T4V-vYc-JCXC{#2LmKGs42M*MbdFcN)A7b}`gdCBtOMm$_73A?y^qW#PJ|{A%Y2SgW4PMZ?eKZN z&0GtaHE@0M_x{EhJ$znzd}WVM+4L}d?HuD~qzc&kx7P!EJ+RjUdp+#AjwvF-nqk62D+Z==EcmFj09ovb&@Y-3KIB4%YGB)eRtUuG1 z&wb`2Dy-co=ToP6kN;=+BIB>aNVnBU_ouRH?@;VpKL-;@;Rm1g?R%US>$~;yX$$F^ ze*XDVWu8d7-Z|;dnd<*WTH0>@EPj7M#^2B79n}WapV=_}7475avi1Lmbn0*1d3-&1 z_MDTK<+zsSHmrt`mtwSHX3lonsr}&p|gjl&cZ@f-ZCdoD8<3 zQ{hvAi({?liyQ@N(P?lg=s{P)w}2h!I=CG;?{`Wk{3QrS_rqBwJS#^W4_pKK(DiUL z5aP7LV=ti0gvY~ogBElL?7mQ>1YHF;f_iid{26FM_rphA#A9pdJoqAzk1m5h1@WXG zT1wg=3Y~T_&qRVmbPfFJB_gTlluJb}1T)c9@CP6n9aSb$1hUW-a0|#scfgUCVH>&( zeh6$px56KS3Uuw|BHw|H==3Y7w{pslZoiUms9#O_(Ww=b5pNnIEdM3OQxX^X*==GEfod90}%FxyDW{{6=fS(2)bQ}COC_(RlKL;7;Uic5c z#h>U-xCeBiWrIlh_1J{2HVk zIPle=1ib-%2;`$%;P*imx(7b$25dv8!>d3%+6^DFk#>U4hHnQc=qA|lCwzpCf{z5T z=oI)WP=;=VzW^2J*iBqN0I`qJe&AM+irx+{{4?#X*(v#O9f&8q5k9z@`Xam>{t)yM zZoN@t1&AcP6n-1D6W$M>aTD!?@M3ry=pwuq{@u;^5#0ozR6~D3m%tIXh{O?p7W@=Q zC%hXz_b-$e-40)RE53RV|HH2V7rGywSc~7#aqumm6disWV-BcAcfxspr8?0~e-n8R z%z6m>>qMr56m$Z76G%g6+>YNsHo6Ml2Hfaw`0zVOADs%H4cbVv1il4ypzGmRK_|Kk z4!e`F2pt8_0X^tE_&wkx9cMlHfFyJ=+y(lGBX^1X7DN%=0EcZBNkGTJC7=r32~W72 zc0&AFa5?CH)F~U`>mFshiE-vhd;`jf-vt-7P)83_E;#LJY#@Fk>}Vz5N1T!ce+9aT z6Z5RdOQ0ETeNN=KHpVRCY=^hLz_>^H;ajP@4v|d4H@u43+enl8>VqR*!{?+Q1*dPv zKg6$wo8P5e#1G#gax6$kXTqyKpj{EC9{zndb%)LAAEQ5^%-E3ismNMTL7F8>e@36; z*j{+V=d>kd4?Oz|#zb@le9f2CwaV)&>IxKdtb9$o?Zbzp*#!4~k57n`@*|%M0vm}_ z1wR7Zl%*9`UsPCD7}Cm@-+NU-o-Vh}@|_#nQM%(Hpn#7P;Y z$uD`Kxffjw{|;mmXCr(s$U`^69`*hU_QXYM(lb_*8nkO1$3|&Vj;@EF1a9KD!he~d zNgO(6q9*B}o3dxa(XpB&l2__fzDGNaedu=h)ajb!qf6j>K|05F!E56*X~h1}eaH(G zQ{EK#I#7k)0e`u#Chf#`??<^nE9vyY$?=+WQC}Hw!2#HV4Sn#H2T>Mu;=!6+c$g-s z=yskHpLGN_psV1QK_+QN{(|pCAE`+#;f=rIyKG0{E5cpyFMmzB$jc4C3t9=c&er5y z;39kj{9>{uThMWHs29*koMgqI8ND5TcOL#k=cQo7(WHsZDaT+7$fJzK@I#;!-490` zNBt5%Ax)FTpoZ}?3%>SvzB7m34*zd-J`QsXtH!AZ4X@yKb%LKL+72P$xR>;d+On!d`)Jequ>KTI64uY3u4i! za5jiS=fR~Q9$f`bUQJoh$?%ULTj@3Q2@v%p{Rn=^L%GnU=V)>(NJ7`cuYxpmFMPLStv8_}Vq)GtVD zrC(f3y9MRwm`kYB%jr|-_;O9AUqe~Yu4^^9pb|f$t-s-$=)a}?pzAki^6~G`|AZar4*0N5)HQL^;3vQi?60Wi+v7k8mm6u%V8>JHT(8Oa zoA4Fk&G7h}HK`ze0(=bUL1)7kf--a~JhFyoLx~>?F9SWKvjM*FFOO!ekWM#zWCJ#%%i)v%jz5W00nfT0f1;b>u1 ztU<>;$v1IZ7!%M@PigYX)7bMI{pcA@K5W$_1-3)l%4PdcqJ%D7sC&LN^}=I<1PGv zPKAFDiqVbm_dwdHm$x-p0>aTAxDM<cbn*0f5qU+)FyELgrZ->7J*=Xmx zv_}w+j)Ok{#psy#G+7AT=sfs-kce)B<$dZ49SWZhW}AXZcgr5Lq zgm=NQpW+8}B76!+C5{WeO6eCFui*PZHo6)95agkI;R!vAQ|M&)T9AaU_>3_eWRhk- zJpOZRBRm%V6-Y;?z)L|nIuEV~*~E|hg7Y1yBD@9u1SFuP7Y1?YGWfsbe)9UaOVQ5#u5qZggbIhy2>6Et%eszpR;?bFr z7Wp%XMc2c>WF4g)*qH^NFpj(luYf1=oz6bOli}My1G*VLAj%?b=rZ_D;GsQq!~5}V z+o+crL*OEiiY|ly3fhUY1%3zgp?fCqj{8K5G^3;7mKclFqBACu-eikxN4LQ5fL3%Q z-~C+z%FtDCCn!OO##-bMP(@zJa5|_)XTg5}wdi`d2h^iwszpu%+tGEfeHwYAW8hOk z1G+{rC`UKJZJ-j}4hQpn++uVT91lv-Dewvq{t9zHcq4G4YvHY+i#Yx88FBcW@M8EC z5QUE1$0BEfcytGA^N&4<@_xd&0q1~?Xg7R22t_x--++9ylkW=52eZ%_@NdBOkEwUK z1$4fN&2T^Hc#Zgn@GSz6`VQv;*aa%zAbq$Bl)pvU;a1>!9eZGVqDA69z)pBB2t}vE zT_FEe{C_C^1|D<^oHc`bL6^Z%hf!bXWVjtP@eKMItk7p^{<^grXA2)~$$4?m~8$I$+dMH8L{=N^asgxA7% zrSW|R!d=HxcMC1jO?Vx=`2;lKy>Ndz{vka1MEt!7I|=WGzgWyZ!jm#A@~e~3gqOgV zos8cIZ-HM}f`14v%e2T9r%)f%X$$M)>Aj>Wla(E3kQ`MG}Z#0axasiPH{m zTgBLdjycmJ)6TNU29-YiR6gynoAg(c{ugh!r79i4BHB*L@c zeWAPIFDfjuh4>q;A>V6B zhq~JizjGaRgpRAU$U(ospJ+F{Zar-P-Sj()xU1-Q92@fo@~viU@4-Jc`vWd*GLDCl0oy-(ivS>M09lx87xu4>t2&9`RjwGtS?GPe`W~?!V6> z*@Txjkk|dhQR%?1H4=w(G9P4Yc$jv8uOgfH9{MAsPnsoZRQ5cNJ#Dl@WzP%P^CCV`_Q3rw;Rj{U%h=OF9F-3I+BV`S zdtSqy*YTUO=MC(6lk}B6o!Ij>b)@Wp?e8+~kxnJN_I=ukN(X-F1L7!qKE$4G`iZjV zW9<2a{)={fianpv-<3UZ{}=RkWlt~md_^3>d*Ijlh@0z9VfoFqi#`aYBEKvMDb6WU%u!VH0;m3f7b3rToDTvw5 zI1EpmA0!*PXrJ)WAe(g3;UbX9IidvqGpNOeTKE~z`6=TA{58lUFIf;I(?K5TB)}(t zdd^3g@cAH$e9PclK@#@Y!!LsEwDaxokDwQyIFAmJ13?w#N`jYw)J}W_UkWncV~m3D z1ijeS0KW#hu%Qcfqy|YN+UgN&1R^0b5G1XXy#}7)#z&Mr6MhdQyv=xic98rLWa9HCcwu3XSgC6d zY$+mr>N+027c@~9+u=3mQeW7U!F!VHN`fREd&({dlJJYMlRE8%%PynuF#pNBoVI)w ze#V~StMU1@?8Bbz*9FPL>uIalQ~X=n$nS|y+1szDPyG?wuqXKj+WaQ`tJ*Mp!c9Ta zjZYG94w5f!36dJ@vECjeC*486z@9odzCK9uv8Nn<^)A{i_9SkmZQqUGNv927a1Zul zPYwL(z4#M*QtqP-fM)DzfM+()@9ig}PW`4F~| zR|S0g!?a=Y>Vu;n36cu(a>189O1+R*8=UYM^+H}La5ab{uLd}>8Gn+O`*GUp6XZ=^ zWpMVBq(fd+u%`uIkyjmj#Z$CH@@j%_c$%`1S37*?GxRU=s(Lm^-Uf{voAF$bYyz#s ziF}^E2GYoPJG@^THc{7Zxc3G8M!uO_;TQ1<$0oPKFJUL`E&gT7@k$W)I_L`>`2JPe z6>0XtC9l!P$+r`}>UDfV8GGSPZ_;PU%h?$uo8Jl&H)V`@o3ZyD{7idG>cR!U>xWsP3)=qI7r_54EwRC_j7Fi8k?~vsV|5dok5%*2!~%5t8B-f zHq9y9S2+GqC>1= zrEPa4q7Nkx+Hmp=tNa}#GG2ASYYxL!j@Qk9&m#V>t>VHz-S81}NFV>Sz$qzKNl@c3eDKlONx7Qf*ki4d zk39|WvB%>>?CF8i)2-5jJv-pk#iWBhop9mFR%yhZs3rLC6su%nkNZ@s9Cn&jLb1mM zug=2f_^KW*I^8N6*i!?qJi{s#*i!}HxD@{=d*EBM@elTNz<+L21 z9dPOS*oi&0a8`*`>anK+j=R7rE%+x5?gAd{3B8bZ3o5av2QI$|o3JOm)GC*OOwy@= zqc7%I(wPb04z`m{D?H~Cj#1@;UjntH(+jV<6dOnJ;>TQOm8&kN z{gD0+_~ddcHr=*_-J8G;_O8iv#fLq8LdtC5>zhE2ol)|oCv4Qy2a9J%rBz_xw=56GQ&lBp% z7nG`V8N3bbP<{4xtGos32=9Rt@4(OaFd25;NgKfCdbquw{zCe(cM-OkKF+a~@T$8R zCuz^s@VYJZ8S<@%ue=A1&zs=hduj8OG37qSlLo8w(+*n{|DEv{U!~n|mBkN`4t2T# zzM&ES(+;=8?>vaj_@wM1tL*nM?OD|+{3R$R{n#d}d<4p|KlTyQ1U;(nKWdeZ$7m*a# zy7?{U{J|<00xRikgwuY+PINJRfY@XMIunl6Y*LF(fqwvr=md*Rwu2P3Gsq^7f=qM| ze3R8C`RF#d!e*0FbR(Q^w@D+q3Ql#{qz&zX_jTH&3+;wK2Fds;gYQlK7NmSlJBQx_ z?dTr(aK2sTL8rpEf*N!a{2tiBu|4oO)(34u$HEIh4>}z_2ehEWS(ofU5U$dJOF<{$ zp=FxuA^jV)(dmHpxJj!qdjvBoCbiM@HGijZTH_ z(fArY6FwWHsQBp?NP4i1YUO%)D%Kn=PA zet(ip63}^*ZE^{SLzlzT`6fXNIt`u}Ym;kmfh|8P3=jf1)?Qzu1rViOz;X^@{euQ3ufW(Dm@wpaJbXknfp*CUg><0jkkia0w_!m%$H%dUP8+BEcqA z=ot89P>XiKn?NPH4xV}tzCx$L<)97S0?#>wyuNixHGJTq^b2%7{MljD0lF-S`khHS z==@*WyKAlTC=(-fXT{Isbl9wA^51jq< zefS}eMw%_~haeK&3m>`wzo<0f3&2KnBm5RFbD%;?N$5MCXRSvH>j=q3yfVY8gZ0>^lKnL*?)2J^H zPn`JUDKDr)$1SwU6JQqU%L()aU`20-!_vtQ9RnW^63}(<<0sN?Nk4s&O)dhd%0F-` zNJe+SpMsg_nTu(k8TbcX0~hj5CfE0zBjAxs$QPXs_he!ly8aZK9CRx6OZ+Uj7qp;b zPP0kS>GWCRl)xV?rH`P?v&l1uG7_g)F(^Y@moct@5_B?r9@u~`hi?ZJ=mvOgF7<_u zTVa#Gfjo38JbNX5ne?mjZ1O$WfUY>pCcn(5PSN@BHNg4<<$@mvq3AaFEznP#_|-N! zVh#4AOW>#i+88<+t}3Mc5Z_&7lNZln+(Xx$Ym?s;lNY)beqbGSgzkeUorllS@$m7$ zjn0H$1)1o6_?q(>m(Y+m2LMN2l4mHM_fz4Lr21gfKc>IcqQoNSPy(N z=ttMXZ-Z`h4?N{M+6g)tzVUaoXLS1YHaQEVkxnUm1IR$vz;{&9w$VNCv`w5Z(Di>N z|7yyDo(WI589$)iH8!~#Y)99@Z-8!e54`#oe2cDtpRT3-plffl$zz}k-3qt=6(6Fb z{$`UcpbWho4y~gsDjYrC*zW7o4 zwbHQTF~&4>6MV$uv^jJ${4J# zjqZlap2nXl9NzjYZ2(>I9CMiG@fErrUe`vN=sI}R3-|;b5C0i7p&Q|ow$k>eu?wL%glSM!Lkwl4!F^guQ0y?HRxnGtONfj4ZjSM(Fw0&!)w$Z+PR&+^*a3* z-2kt60~^rIaKW3{fZhmC?4(a&&n)=FCgRZL$=kqPM`> zd*q95`H=DdBkI~7EV12`syN?Z8*rm5;P*i(TD~O=RH|_JQ&59;erIED&-oo)2UqpuXLLJ! z==by&bSiuo=tj4~NB@8yC`%sv4v0cqf8^W>64BZ4pTJCX9n36JlF>169&n>e;157C z+N#-Q1}H}-!)rj5iUYrF;TtFDgdo;S2G!{8@QO|(v9weXY$RH*bwRnUIS_fFNUi@9l8!~2OH5F`DVhg*Bf1*Sn_`y=6$kDBHRwKg|5(a`o(Zo8jp!2icCZEA z2!95e(UH^m2G2g&If8oGm;L*(-YU8merbQ!Mkh}C0e0EvK>SR27JOHNUGmY+gY0tZ z!T1hc51(|1U3L(^6s`xIDld3zqFoY*6MLv#Y)N)$CAU$rZ3u%`e ztM~`dkG7`Um;{HPOIQ*;sS2b}`H4Jy&$i)kAtlPOM?XRr!}C_*XQkm2&t%L(m&2ce6twd!yPORw&=v3(AP*gy zZ89$g7P0us<|@Mj_-x=tm%`tIVsz9xYy;Kk7WflTrNYmn|AI<%9emXJj1OoR z+y)}~)<8FWPAU10X57A*y10Zm=nVKvFbf@fsa>X(;b*i9zTh(2B)S<+x&mLJYv5Vs zq^r`0ue_3S5#A1WRRF>puCdFiYpHkgt%Y}h40Ip7oM_0f{R?^4OdGLq7v5O0x zw%#t6-AvuFet+k!todAvZwXI;PX{%G=fkC-4qXX947L-;cb$Lr4S<91z;DD+ybe^N z+wP{eZNEC`<(*yy@HqTrVa5O1I2HEP>xmn9f(Eyeuu&LI}7T23+sWKV-+`o zaj#yf$$xLO!(VvjG1WHYqZbT@eexw4ZB?Ord^uQ z9q`sp{D2OBi+Tic=-9XI@-CQ(j(Ugr3`j%I?6S+NpagAw*DfpHqpzZy;7i}9-Hd1M z3K#F-9Ez@kZ~B0GM|Z;8KIB+*{6}`V5hS6T;7hylKY9yX{4xGl8t(Xn@jr@w_bFkY zQC`BU;rXBAJG2|#_Y3L(odJIWYSEFsgnz9mIAc1t!zQPY66rP+!r^Nq)4;3UNpVx*o3698!tyhJR;a8{Gu24su8z z$5z4ZAe`_nxWwv^TEgq#6q`fZ&>ncC-64(WS@6rC3vFfX`4q67V>96MKs&k_{t+~z z!<`N}4z!|O@XNstDVq>1Ng)my5$ceQXbE%3i=!Nphb|9iZD-b|&qmLJPhySwQ1nLl zy>SjnMfZ(&$l0v%-h-}$lcKQ!oelSa7If?chctjK=uUXvM2Eyqqz%I*ARb)?w}C`- z7n~I1keTS@Ne=mFnnRM&67P_wK|b2bchuhl>FA9K4tePyhh(BV4|d4k6CF~HPCV2h zF8~j^A6_{Ff1=Ca5r<(DIstweIAfUGv-b5oAm}vs3eZEGD)>XthL*z}5(E0saq!!q z10Bg4>sJF0$JWBnfqZn{FR&A2p`9}wQVpWeE%24Uq-~%Z6(8x41at{}%&#afdLw)v z*nw_>$FVkh4LT2AbQJcWtKhpq4?1f${sDdHzGTvyLs=#<4#Vf9P)2n8e1}{ElF_yB zvIW#5x)Q$cXor-d`Eexbu?g*j%Rno-27U}Ur(h@iIuLX=Ym(m% z!qLv9_yi=Qli|}rI@$$43{ufO@W^c1AvzAe4P>EPVadT?=y3RLP>GIO#(cYKR>z*9jhdOvs$ zsNg#D(Qr1fqSd$NF9PvghrA5l1S+{+S_8ieGSKRq@+0rZ2I8o1fFA^!xDKYir+Yjo z<+_3Tw(Tk){FYbWtt|tIX!YIJo53u8N2_nYJ_@X8^$pn%Kr3<7cWFZ&ARV;&e(Hgs zi#Y1Ls0%?9zdhAAPu(CDt-dXJE$HUAoB9Ui9l*tJEA?Hr=RgZ{OZDBfk3bT0PW7#@ zV7?)d#{5TpH)da@ImfB*z{~~ZX!Tu|9AM=fq`tFqAxK86Zao8yP>< zH!!w=7PR_4Md*XHImRgUt%G@>k8wkNx4^B!=~H|E_IhBi2ljekuLt&eV6O-EdSI^y z{WU$NNVuPcM`q^M?R~vkmgl_XiZpm%gO4;g-QX;P^9=SFTyAic!GAS)i@{9>w;KGm!F>jgHvF4l@B)KR zHrQqGIR=*-TxIYb1~(hrX7C#Z|6lLDB~N+lugYluml(Xp;7o%T7<{n76ATuEKQz+W zX7JMn-*50=4c=t%wFbKl{&)MixW!v;mG2#tq53hdA2kn#{h<19)8MwheS60>uW$B_ zYhFL>9oPJO$bWYGe|22rE?Ryui)63zaC=?XYjV$BdhV(Ko5dQ2JXJ!-8P>M1ad3DWnta*I5L1?!A7BE7NKtX#TcRetVLB74)0_NMJA zT*WSxxs3OQklTuaHJ+tK%X9K`)k>PmhUNLWIfZ66!aF*InfaKWuA8g~3JO=}tXZBruVC#OPi~ z4)F=i$ScgvaS9CQpdv??cm)p@y#(^eIEQaMCE zurBiC&&zRp))tZ<*%f=_GZmIbU9EL5Si5GqT2X)g8c*RmR#a7cPF_{$S(}r8(i&AR zk?VtwDN4y*wsz&p+`{z2+#*$R9k!F!$KQn~U;eh$@U+Z(E$}8FKdyRVvnT zCkyv6EW5r$Hj%zj>Vm=rxvcPBm}}-!p<*9j;98rXo2qBGgjHSVFIqT1?XVfTQ{`)A zvDei3#c~Bczz9Aoa8|A>eQi;mUM}4ma+&YG1^MjshI>>VX*orn`GtiA*uO;C@3TEe zBaz&~d4)Ka7O^;2cbLe_L20=;=j84ZK2b}_&Cm7hvf~1u`tdtx&KlQZ_o_8|dyp1e zMt;#8^=SkaFH{=yPR_|+n=8+#EsXPSJ*Bo56z1m2gPNkWRm%!eOe0UUPTFzqs=>@Cw7I?mOQO>HO+=04e?PcZH^yL`^s(q=JMAd#Z z=xh1VTaPYpwUDBH2@c9tv88;l*3`E8vH*D=ph9J=n7q2qgyxeQc$SqvGYE6!Z z2B3EX)}9_r%bS&M{|-&1Rj`_FM7h@F&SAZ-okNz$!9MwU`wuHKTTfW)p|9)hd9mL0 zv21w|1$28|zEan^TjdIE0X<+|enC;LT%+p+tM~w&DwA%-COvE+T}lNlks4Yub+gJf zPq|i&U(L#@IrGw4`&wCZ!u;cveo?nIT{VB6Pd$EZzGv0kb)MXef+ee5x%2qIg6wZM zWk$ikemPF1F@McDs|pL&tfm`!3s6J}8ub8f_a8Za_-&u0bh&z;o#XrO-@E;v^}r&&bFmPd295z`;QzIE{-Bc^ zR~%Q0fJ&v4J2eh!0)h}wsUsK!X+%PDautOX7KEH-JBGCz3j$}QNKj+nf}0u5NE(g) zx(KK{RYr|LjbR~;NTpJx8smI-?{|c_x}-S>yYN9PSUqXJZ@zDu*{45&$KWj>!81U> zUqB2Z@GI~L{Npq9&j(+FufTKgcTfWgo`Eku$GZT)U%^xG3HT8F0sIa;27i8rKL6lD z@C3XA0`NBYCHMt+mCxUvpzra!=)a8Pci>}u|1I#qg7ZJ(_%rZhFyQ>>IBH@I&y=56~AGd<~w1F98Fe zflt9l;QqNQ@Y)qvu6wTVZY1h(FAs{Sh>NtCs-;?`=%;?^*M7(QN|Y6Qp{@^0G-42o zIK(3XiAYRRLdZZSvXGVRM4=irs6`#>(SSxYrYR+Kpc7r_N_VPcT4rQc=44(LWKkAp zX-2Xko3bTavprLo#tddLhj}bu5sO*M2pibM7PhjTDO}?Qx46SS9`K0AJmrKBeBujV z`OcMG%Z=R1o!rZVJj&xd%}GAwQ@-SDzUNAz6-HqdPT>{7!)Qq{6jOn*?byeLgOQtv zVBcc+h!Wo7B#3mr#TpT9zQx-R@wmm*5!FQ8xJ*k@4&_o_%C*#Mqc&@=_UoXwI=2hE ztD47EPX+(4zm@=^LQx%>no!k-t}c}Ip>0T(n_>qvQ=ys;-OS8}axS#e7&=w4^N^=}J%fGLWH+Cikds{GDtD>W8Z@?Q2Py}3RL6B%lX|G9da2iXua!n?jK*r5#%qEmYT_ns zNHa83vove7H%hCuMr*ZB>$O4abwL+(ahG Date: Sat, 9 Dec 2023 13:24:40 +0100 Subject: [PATCH 11/14] adding build readme for xmake, fixing windows workflow --- .github/workflows/windows.yml | 4 +-- README.md | 6 ++++ XMAKE_BUILD.md | 47 ++++++++++++++++++++++++++++++++ res/screenshot_test_windows.png | Bin 0 -> 13375 bytes 4 files changed, 55 insertions(+), 2 deletions(-) create mode 100644 XMAKE_BUILD.md create mode 100644 res/screenshot_test_windows.png diff --git a/.github/workflows/windows.yml b/.github/workflows/windows.yml index f5d2000..e82f86c 100644 --- a/.github/workflows/windows.yml +++ b/.github/workflows/windows.yml @@ -68,8 +68,8 @@ jobs: # Build the mlx - name: Build MacroLibX - run: xmake --yes -v + run: xmake --yes # Build the test - name: Build Test - run: xmake build --yes -v Test + run: xmake build --yes Test diff --git a/README.md b/README.md index b46ab02..cfdd314 100644 --- a/README.md +++ b/README.md @@ -4,6 +4,8 @@ + +
@@ -46,6 +48,10 @@ brew install molten-vk brew install SDL2 ``` +### 🪟 Windows + +To build on Windows you may need to use the [xmake](https://xmake.io) build. [Here's](./XMAKE_BUILD.md) how you can use it. + ### Clone and Build Finally, you can clone the Git repository. When inside it, run the GNU `make` command to compile MacroLibX. diff --git a/XMAKE_BUILD.md b/XMAKE_BUILD.md new file mode 100644 index 0000000..b0e5218 --- /dev/null +++ b/XMAKE_BUILD.md @@ -0,0 +1,47 @@ +# 🏗️ xmake build +To build on Windows (if you don't use [WSL](https://learn.microsoft.com/en-us/windows/wsl/install)) or on other OS, the MacroLibX uses [xmake](https://xmake.io), a build system which will download and compile all dependencies it won't find on your computer. + +## 💾 Install xmake +You can find how to install it on your system [here](https://xmake.io/#/guide/installation). Note that you can also download a [portable version](https://github.com/xmake-io/xmake/releases) of xmake if you wish not to install it. + +## ⚙️ Configure the MacroLibX build +Just as the Makfile build system, you can configure how xmake should build the MacroLibX. The base command to configure it is `xmake config [opts...]` or `xmake f [opts...]`. + +### 📦 Compile mode +You can configure xmake to build the mlx in debug mode or in release mode (release mode is enabled by default). To do so you can use `xmake config --mode=debug` or `xmake config --mode=release`. + +### 🛠️ Set the toolchain +To change the compilation toolchain using `xmake config --toolchain=[gcc|clang|...]` + +### 🖼️ Image optimisations +If you run into glitches when writing or reading pixels from images you can turn off image optimisations using `xmake config --images_optimized=n`. + +### 🖥️ Force the use of the integrated GPU (not recommended) +You can force the mlx to use your integrated GPU using `xmake config --force_integrated_gpu=y`. Note that there are a lot of chances that your application crashes using that. + +### 💽 Dump the graphics memory +The mlx can dump it's graphics memory use to json files every two seconds by enabling this option `xmake config --graphics_memory_dump=y`. + +### 🪛 A possible build configuration +As a configuration example here's how the command can look like `xmake config --mode=debug --toolchain=clang --graphics_memory_dump=y --images_optimized=n` + +## 🚧 Build the lib + +### Compile using command-line (first method) +Once you're ready to compile the lib, run `xmake` (or `xmake -jX` if you wish not to use all your computer threads, with X being the number of threads you wish to use) and watch as the lib compiles. + +### Generate a project (second method) +xmake can also generate a project file for another tool: +* Visual Studio : `xmake project -k vs` +* CMakeLists.txt (which you can open in CLion and more) : `xmake project -k cmake` +* Makefile : `xmake project -k make` +* Ninja : `xmake project -k ninja` +* XCode : `xmake project -k xcode` + +You should now be able to open the project file with the tool of your choice. + +## 😋 Enjoy +Enjoy you project built with the mlx +

+ drawing +

\ No newline at end of file diff --git a/res/screenshot_test_windows.png b/res/screenshot_test_windows.png new file mode 100644 index 0000000000000000000000000000000000000000..65f5771d72a2d26f678264b649a2583df2431786 GIT binary patch literal 13375 zcmch;WmuHo6EM6Wv673Zl)zFVARr+~NV}APbc52}-O?%uEF~@7pro`)mq<&aNOw2; zoK=7S>$$G?%k$~=64?7b=giERnKNf#gg99mh3O*wu+|q91 zTM8+2S=6D7%vCt@_nxBV}bE+KG4>WiSEgx;Cja~Rbh-{qv9tz$m0Rq7>l9!eOf5E>~ z$p(M$=emQ8wlf5RPm2D*fF!4qgO|82vI78BZUz z#Z1)hb}WU&?HlwQHf!Y$Ew)1>_3?Cpa| z1DlT_)}yqTbgVfRQUzk|a8@k(KoY_i*I!(xGn3%<^z$dUj$wxE_A)zdG%Rm~^K{=I z5O5ap{C2<7Wo@LpD5=Eus2meQ|Bfq9R+LsU90DmVEsS&^rGtp+;;_8aR(Yz*5eLJ7 zOd8!-uq(yKgus8iO%>F2B85W&NF9r4bI2vIAP&h5buHvnRK;;|H{09WSwut(>}rMX zZ#~GwhP_HYQ(3Edrmmj*`Zb=XFim_y!rG6I#^M8Sr~4@lTEmP!h;{Wm#ESN`AXkj+P52FvLfb{oL#c z3kwV7L#vw&OAv@S6|Y5fS=|z)>(+GLPjc+@wTe%l9_8le^He|r?ye5!NB#Qsi!y@( zn*ng5u&^+K74lwIMOF0{E$!U=0M_LaymqQ|w#l3SgeQg1elW8&EX7AsRgl?Q4CVLw z)vFhU7-GSzGYz$ZE-T*!x$rvP2Bw`Q;(N*BRjm&c9QkTL@g|n(bSK%GZIE0}n^M)U zcR??~!aK{IVQ+%Vt~nuIpB>ApK2VZ8Y`WK<$jspT;Yd)+PS;4Is56Ri^V2WMrL{?X z^|6^VQ9Yv9>VU~|ZS0}8bX0;o@`ezT)oyY*qihqUPp(Hz-aD#;q2G%Y&e9noR4F`q ztHZeyQ{!tdtHzRl^$+eGg!EYKnVMO@_C)yV?$PDqtPn$+z)mr$GH<5+?lg*oBU2+wj z8LF>^TC;;IdxGjWt}b&!dKC+mk5rm?JuB|+Ye52T<8~Lqs=XqtY-eia4XJ0dTSvpx zGr6gGq@ywxi4{>R7p$Y{_FfFLbYPO z)9Q8Kj=-ejknExVU0v0_9a5e$YG+;_xg(Z*S`;dkrI~o22hqB&H0ahhxKlr@G*PRw zEo`i)XYWu84lKWnVn{*1(QoBC!8XlqYE35hPFB}&Aq{?>BElF(-{q41_=F*$E_v!w z$5_Lmp~=mIx28G;1d)YP@dF-Js6U@d_9yR53D+#|p^PWOP6(93V$j9?p5^@ zCOA=*w_noBkg)gst2>4Ke%!89Xq7{fn?+axdmMMi ziFcO8JF{_v?_f!Zu7ObeJSJwa82` z9T?=flE@zP@^DK}PpXs@S`yA~jNp>PccBofsOIIAG)6=zht^n~Tk@3h-NXYjp%Yvb z$P(kUg0_%TWcT#o5sDPomdVJDfBuc{YH38Pe`8K5KK@qzCAQkaVUMora4?(9@HM4_ z@dK(n`6~$q7Tc#_p9yBzsV{OY!N(ou>W^~6?;?cR)2biNo8mMJkQJfoSCd_RqNd&o z45a>0NOa3QE55R87w}rjolH_;o5g{=EiNk~@-R?WSJw(INKh5G8a<{M9nm_hTM^cG zn5A%~{rcQ!8fnF7y|@J{R!kEtoLr9|*JZGe)a2q)m_`Ymz38X8t53e-I&Mk4^6Cn~ zZ&7FSo|Yn(PQkDs;?&Z0ZW;YyQ=$K}MZdm?_7YBZA|qkSW8K*5oi@)Yb88Q;%}SG2 zUhi|ANV~%+$Y)u!8QR<1qr6OdW>h*lViYn7pK%?ZIdkefa;sCg%f-c2K>fk@ z{Ag5~)^}un;C{E4Zg+S0%lsEyT)Ze)!IqDUQ*nm_JE=FIG1-9HLNyH*Zo%osmWXS%cLFban{ufF6Z-B`zImb>mUVQN zhBsJ9wVpTKtU6%5K}^VOJejag3;RN6H4eDuqNQQpweoB|^!>+3{ggQ_KHg2f=E#1v zNu$%SvoqXa&u~UuA|X2$84dj`8*LqPbLO8SZl$gQ)rK$4Gzrs)VOd>C6lu^QaqTpg z>}$+ddp29ncfZ*D)^$3Kylie+Cq78@em~<{>WEr5M7*DQNBB5n=!dgYzwa!|yT#$} zo7OfqfssC{>F!n=dsMnt5IVdlG*x06=G_H3yOH9?RFTj5qHRx8l~uptANlbu*Hr(m zNNMH^OW5{Tk_%v;{^@9>^BjPY^U7(GNiGbivI$y5mlc9xi^LFR%B<*c zpfBweYdu~Nh%$LrG+KSmO-3URF(6s@rRZ)k7)BrU6bY?kL!^|$B{&ex@XZ)?;xS@K zI1(0O0yJily*Ryu83Mzm!<#^B8)LDvwjl)mRr2N#5P@Z4$v5LBi~uN+au*u0gm&7% z*)<3WW!48Y;<>IhL#-$X98>ZpA6mVvwe>%rVL?c4XMI4cxsd7Tn?pPZ{XMA{WPp%n zq&n+58AM7Z{3|yg zvKVUkYKvmP=#56&epc0JFJlu8X=oo>51Iy#tc`WlicWXp!ll~onedHO8!`u0J<+(- zHO=1G-qZCupFF$5tyc;Lv5`(=2?ZnqO2#p z;t-v8w!m;3ukI+5fdt>%Fdq4i^L;Lq=f@o3rRHC8Iiu%Aq>c4EY3@X9-IC~9nu4@&(*kkozUG(29=?coP zV!%M52TBu1pW$HsU9l>ut>69Mz@@52D>?L^xLhkJzo7><84Hx2hj$F{^60P?Z}(Ub zTFW*NctkLcccT#fmdAHQ`xnp8KWrI>De5+aAI89{`N;$^K3>#H#J9gxKaGx8>$BS|X)9rUgnE@+EZNS35F#P!1=1wBz8hnFyULYP?eA z2EEZu8mfW#3QA8OhSv$b&zDG5{w^3b+}9ZIxfk}uqB@C$C*%7k6k03$__72lD4DX| zDI#uLuGtBiiP(Ch$Uey3$ol?9nb+@30=UyUYqMM@X;}U09#k)(F_$P(ELwfN3OEFZJ&h`^OGW5g<~w^Ng2<>+@ft7ff|EvloBl_ImThVi3KhO>dMq zfRBZ<%C0?gFPont!VEpVbvFV^!X?3GV>1^wN^BC>{`{nUH$r0lFIFOzgp!VK3zi_q z$sZ2F3~$Y)!ox`>9kUzMG!{(bx}T@=a@-jRU!WkNHwt!}-7)J~yGz0T;=$Vg=H7u0 z-O!%7pWRLndg1$wm525p2+M1YS{kG#RpDReJrKV<5I~w=zQEa$qwL&X3`Lzk!)Ny% zA6eI8ye$y8x>cHWc|}T}ziS@7AnqlpK|z2e2FL(sMM7J_1dcut^Dfa>86|#QVrXUm zvI=kFD5m9tp^t=vpiFu9ng$Lg5HwT~cU4{c^4&`a*mB^o_*qKH74bE+)xydTI(S`T zXZ$~4ni{n{|E^UViEHP3wy-Kqz*9gCD?uE@*CtS z#R5bE3%w{G#h!HjzeT>{+{Zjba4D##52j?Bs9i>4-!)_!=@9?^L}AOprLBn(W1SC* zQd29Bp$#`4vhUHvInmoYv{dUxx05XYVVuH?d-;ZaJha%R|Cu>V^ zac(KqO^MAwV<(@YiEMtEd-AlV>Hr81#!xk};89~j6SuJ~xzn*&wHG>37>V-Uq-?2a zK()|G!4Vd{o%`EN`_U%;WGei<7DifqK9o}@RPiC*efb}Up(H@*E*vj~x-ax9P`4!b z*P0$Ao$?-eZ~q-1`-7u%;k<=$-=FC`gN~c02l^&S$yn6fMe658>iDa_AT}MZGLW8H z6_pZj#5PM~#!fj3Gt|NF8(W;)Fj|A};SJsI7N(zA{%XUoU$Aw=s`^ND+4WZyb}+OJ zx_SA@Uy(aX?x>coDurV@eW!dzfo!7~Q_^=y8ZCpa1yn6EiEbi^XdvS2;dRtIRWroT zQ-B*KbhzgabQB__${i(pBzh;AB4nTRs+uSJ_~y3(&$N?7wA2RSmtiI}i8klWtAkZ1 zOoN#pclk@Nmh|(tPfH3=L(7z5U{h%j3c zGvoPFp>GjiPp_j?-G@Wgoeio{{uux~om${Qgoz)^gui_ln{~MohsAoNf6~`ef$}5Y z3=%p_E{X3`Z~PPcVv)Y}k>-e>SHb>$EIipeKHrKj(Y%2%@On1vR+;!QO&AJ&O5qT8 z^TxhMmt<;iBC>`KVH|b(n3ID;v2Iqc{arrOdCu0S z1){~JrL)Tk%i+A$b~3{QZv$7?>b?E_Tco55=4Ll%J9%z&^3Y2?=cm>&TkMIa6!p81 z^)DQ8s?*!^5N_Vzh((^d$G>G8t+Aa_JeM~g%z7fHq%?kcJhy%9)o8G7S!qW~*U7^T z3>kVKryv*R+RI*hLa3~wf;`%q@!s=1O6=hs=-TvJ&w({vovi~5jUWI^{*>}|f#S&$ zdXM2GffH(4#f!a()?b6K`$@ViC7Bm}`0(uG$B+4G{C?A&MFwZqb^0yHYK^3%r25?s zsuWLodfzcDN{-IX^=x{nHMni6 zS zcLwfFqc1{0_3yH}+BrX=`Qjxj!;Zri=NWe;lhEVOefPNEnw!vH{nNUgjmiNW;ekabz>sF`#0K*LnlwOx>-bMjDdb3l z`!*?E(bQXo#J)Q-uFGcqX+pL$~>5G8TFUvP6NKyYiu_4IV*wJFm zaQE9s~U?GCGb-kqqP4(I>%ex+N z@7|H`s5^b(?yvxa5QY_S$Q-Y6>`V8ja6kL$C(J;K(aCdWu}OnIMLQp#e+dj2V5c-T zDIIklc)aX>XOTd0;4kzs&l0gdur`~NYPjX8>uNq~zv#+oU=yz;(JO2Y%)D5Z zrWCaKlWf}3pw`Nd)5$a%nx4L+9$3ks70F^Nzi3kQ&lo>1 ziGw4;XJ=dv`IGmzUky_GKS=i9K8pQT$%p805YA3Wui0w7Lr5j4(=VD%^4;lB)F+8N zQ&CSZm6eU{TDl=h-GSC;=cU)-S}x#At-Aa0=$ym1mhs$-i!T;eRlTOAgIW9u1sysH z7cUUuTSs_N3lycgqUx=o^&^5|)VS{`GTAl4;l!d_yB=!l>aIhU(or;{o3(RgO!5gU zl>;KfbEqr#$7d_q$)f(vI0WSHLD?jdT1Z2`!EN;QEwJb^cOUb_tFx@ZURC0I0s@+MJD9S|dcOHd&(Zn@5z%rClNoM& zXG+w|JJ!6EEzLA@cS4_oOJKu$ z18i*5`lCsL&AHkqkG<0KM-7{Dv4;_sLvI8o9ZqNJFJ6BsDtfK_;zbf`Gj(xplKsj? zWlKJTbm&^6bNTltbE|Bteqnr9nZCl=)wJ=JC(#^e{R!X$x@@6zDJLWIXw&-pdvT3s z;*wu%Qq8Fcpk(m_n8NyPVroGX&QJ50-pgt3leSYe6B$3f-8-4G}>Od4M8B_6$IEBmm&)L$ujJ~6Oyak@`U75m-5@O~6U^PNjdPz#!? z8F33sBGGC8@S>I1dFiR|`DShX`BsCvfk9dNV{fbTqfKy0Yf4B2643}3gwc4(fU1z! z&k(Y>l$7F;5jC{*1q1}V7UMM;Wry<=hQZ}NQmD!-I}}7LQgCwOak;s~S!K}^S$}{u zueO^J1eGwc<2nD9ii(P=7p*w)@$rQvB@rQxlp+T=GY1&&-c3JB;*?<| zZIiGhU6{`lne{!^2jYBqdQIDXd$zPpzhSJ2JgdH5hlz=4ZLCyxX21trSc0gFeJU+$ zlx9V3$ZSw|@GqPU7#%MGC9jNbjm`CwPcLw}Ce@>89xHmOr%!E)ut*^(iDG`^$9RT( zVU!Aow?X^4oqo&cJAA=*oip^mJY?nMOk|9td|0HNxO(U{+T!o8@a};)E-?+kiE~|D zotMK|C-PJ`C~-Vjo@{fj#Sl=KpXLsHjvMqqLpL;2-@S`cJQaOVs) zY&Ww-b!IE1@L8VjEh2M33C+~ZtSB!p6o%0T{b@B?q+Y*PRLm%w;j{ND-T%r{+xnsJ znTtLsT@@7;4uZV1>&ecG$5$r{pv+YcXwK9$^i_`%Ia`q(cnNBv=!ugRrf<@{)>r@% zh2t6b43M541sc$w{7_z7Tl?(l5Z`4#*f{x-W0stpoXeDLttD`jyv|nhT|uV2d;O3V z6t?imI7ZG6*MTIwhdw6`vO}PR=uAi>tYvCyde+YAmx*x=XJygz)}+%iXZ8BY#$9G+ z>6r%iM8@2loC4#{w`<@4f*Xz{u{Re~Vk@@1&JI?yGbO|1kVeMFuI;xp?{RU(z%Vu= zk12LVvd5ljX?aYd+_$DJMK2FjtxKyH7Z=?CdumEb`gE)}zXaiyj;~jb=`?umn>F~J zyMYhT(yvQsqDyld?-maB?d*|b=Ter}b15JZ#EnDNP zdE0sT3EnoKc4*6CmTqBQzCp6TFNwz$7=vQzfrrR`hu?gUj)&~bq@ccyRaD9^IwC06 z2D8IBrK0n@Dj|>?574~;OOY05vB5Apw9herbb7n{KD`tuDWuLSDn<7hNnpVkKCf;b z_9L|=!a>pDQPWJbEO$~c6k1EZi^ncy5Zxhf#zKcF;aDm%d&dkBj(q5sYEl6ufpPFK zz@35)u5~xc{#~fwqReei0!|o)qWxT_+>-4-*cUCbW)yUo;Ux11M}83|38a6g9NR}f z<@@*AzslrF@eh=lm)r7Y*neKTM3*J@2?ayph=5`7dPVMS^y$S=#I=kwae|VFML_a{ zTuM!58UE~sXh^2Jgz?`;Xm_L1A86D$+p=c2{(~0NXZ4pPxITN5KkP5GRn~4Fv44~O z!DJB?l8pN#tr&p8nXpk`AuaAY0(?Mrn1q`99=zM;xd)oxH?!(1%cJ``2}u7A z9UCXgn=!Ov|6O%?BG&Em^#ia94)>&7TilXNL`+ZqEi-IUE&00|Pm5BlX2`-pB6hm(kfr#5?9B2SU+AmIX|&$l2 z`CtqIFah66Z&@?uH^gmFxRm1D1wP~c!#5;py4PF{OjDBX(~e~T4`uue};U%&dft%AmpX7o2uZj2DPZ2qLj0Zi(gXHA&NQGttIVU4ZO zscK7UwN8~q4CwoCMO_}BH_?=j_d52$Zk#wnLCMR+%xtZGy=xm0l&A$=plcP1c*>jiMqOh1#Pz*5tNr|$K{f+~z`q_N z;0Up*&=n9IkNgRch0Di5hfM%Q_w_Laa9xRSCR@uG7^LG6-MMERFr0ex;qME(mpDXt!M zt8t4t5Nz{c(pedUBKjJLH7m`ygxt4ms;3-*U$I&}ZeTr+CnUG@&cs-oNjyRJ|HynyqmJfH>(8zII!>#H5IE>ZLkq8#EZIPzi#{*jaZMtB8_nudTY} zi*L<}-j$`B@Fc753Qu6s=p;zd5#-)4NBIsmZL**@ZeQ@p#lm6Fx#}2ITOS3Gzl42R zZNJ4p(fi+LGc6l90;G6n+R0X)kcz49V&Z@^1zMQ$dwM?GOO>KnKM{+Zh@rd4>Xy@| zj@}HOiCp*j9Dq?&R5Wz7Ii;-yj+VsDL4S6>ox+*JIe*~v{RzvqX&!r3ZS5>&_#P$s zolnilA(sX+%7Jc>X3ybL^lv8_u|5lM7&zf*r_gUNHp2pJhn0n8 z5NKgRwsh25B>!wQ7lPLBB$K0YM}l3aN~S`^N1_p!x5FN`@|CU_2AyV~IwEGuYz_3CX_V;|f|yj_ z<7Y@wS=m?s#cGJ>uSSuK)OCK1k5(prFQPB8#)-LIq?E?-O9vk_FI#+N5x6DB&=0 zlnz0RytdV_t>Nie=XJDE2#gTh;6pq=ia+lJQS z@82W+R(T33c_0ErAA4jD5X>`hP|v3N{fDzy-ngtXC0c=&5J89efUOpkA7Ha3KnP-e zRc(r}N74>Yjf}G5DgD)-w)kCwc&s=4B@DZMnW(v9W5#_>T}MYJRy5l6cxz^Dvf6s) z4P8-jvAT*%mfcMK=w%=OoKN=tfN0Ch(yrZh8Y?RPR$8e{6A-Tg$>H-b!01!UK=99O z51ZbKm0&FV2^%%sXzZb4|LhD@n&kQKu9*7yK>W4l7LbPp!6Jt&Xfaf)QP zp_7~-U?ksJ1{dJr`~fbN{sn0E8@#$a2XuK&dYY$u-o=jrH~YN}+Ac0G=FJ2z5Dbr$ z>hh0{jNAkMHWD2jq6L9G*zKh4)hPywg|?W;I1mo>^vD7Boy;(`xUOq}T;oR7FtcK6 z!9=Bb@0eD%%o{RJ4PcXnX`(<_Rj{|`gzm-!7cEFbQwq8ifWRm&Ev*zCEC5621!9&( z5KVy$0=r?e9#Tz9tDvv%>FCJLsR!C#y|DiOB}keZ?3Ug%qCvSPxSY_cnAy`5F=+Xm?15L`{qjEszCA}j$IN&%;w+xNBJ|Nd=))>GiA zh*;*CMkoV2A4)($4_ZEdwuZ?g{jT;itas+W00kW8^xMTJB!3{rIpD3WyEUDqKbZ?+ zOCXd2@8d0G4mg9rw@^+KavuX}iAAS67my$r(^tw6@#S?{c_yo3V^dQ0=@%Z;-MbYJ zvc-WOD?EK#1E*$&k}bIX(K(oqkdT_9qMog} zmN^;$r#1~WwI7mUL=z9K$3|w#@{H05O3THAa3203H<%SJM%mc(Peb~I(L z8I}I{j(0pY=Oz(5h@66mE zK=R!#bMntt*Nw1fb|J;g;UrNm0i!qDpu%4N)wOp_>EaI21m@3;D7K6BHxw4*6J6J_{?zgxhpQ$ubAr}CWFXdN;7_5BQ|Pd zAenywq63a)DuFC|L9vkY$sfD{Xys=iB1%Zt<^X%$%Si}ee<&pq639v!|@R#Hy^bo99 z;CjWty51HJ!+^`6FKoCB929II;`G2ALBuh+K&T15@&ATGD*XROjwazh)C$< z1G3>VgH(Vt$WNM_2T=f6fDBZHyc0|l%fVuKipC5_2Hp%sLxx$3zm8$FZp}>xAnCbe zUhsnQ9t2h>ju(rD7ycU_B910b$}3tz7>zuOPKNFd8u;Li92lC?01G@7D4G(nDr}ZE zw20x9K{qA-053%YH%@&EK~E!6f%g3Y^tbq}I3 z!)4y0fdYQ>qR~Q;*=UGj(Ra`|{~woHEs(2&o^274bO0#%W)8?zg4WV%#RzacV4`IT z!Nf(Er$Dl#l#~G^(LkvSP+*}FedERr;ECxlBf^MjHRR-8BauizDd_J9#+QYO=?O>z zerfM|7uxEy@q-I|YoG{J5doFoEuxDQs?qMj(2xr7ph{fL5J(r`j8GVZ3Qsa9o>16A z0t`XaQ-AM}p2FA#nA(no_;>HLYMlorI}DS}Ba{<4^j$z9fO zTkTjpDI*LK(5d3=&m4+-7xLM%^r&z~iU9KNR<%_G6d&^b@wMB-8e{~J=NdQfyX(%~ iGxz~|PV>1?v~g0p56lB5>%mt`AhJ&srOG6p2mT+9O?Acq literal 0 HcmV?d00001 From 9db5515fb5e50f253eed7f303c8c56f9baa9d974 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sat, 9 Dec 2023 15:46:32 +0100 Subject: [PATCH 12/14] adding vsupp file --- valgrind.supp | 339 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 339 insertions(+) create mode 100644 valgrind.supp diff --git a/valgrind.supp b/valgrind.supp new file mode 100644 index 0000000..515a8f6 --- /dev/null +++ b/valgrind.supp @@ -0,0 +1,339 @@ +{ + name + Memcheck:ReallocZero + fun:realloc + obj:/usr/lib/libnvidia-glcore.so.545.29.06 + obj:/usr/lib/libGLX_nvidia.so.545.29.06 + obj:/usr/lib/libGLX_nvidia.so.545.29.06 + obj:/usr/lib/libGLX_nvidia.so.545.29.06 +} +{ + name + Memcheck:BadSize + fun:posix_memalign + obj:/usr/lib/libnvidia-glcore.so.545.29.06 + obj:/usr/lib/libGLX_nvidia.so.545.29.06 + obj:/usr/lib/libGLX_nvidia.so.545.29.06 + obj:/usr/lib/libGLX_nvidia.so.545.29.06 +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:realloc + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:calloc + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} From bc7ef4484f501d161aeceed7c27d38a90e4a70bb Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sat, 9 Dec 2023 16:23:38 +0100 Subject: [PATCH 13/14] improving vsupp file --- valgrind.supp | 2973 ++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 2925 insertions(+), 48 deletions(-) diff --git a/valgrind.supp b/valgrind.supp index 515a8f6..5f02aa8 100644 --- a/valgrind.supp +++ b/valgrind.supp @@ -16,6 +16,174 @@ obj:/usr/lib/libGLX_nvidia.so.545.29.06 obj:/usr/lib/libGLX_nvidia.so.545.29.06 } +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + fun:strdup + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + fun:strdup + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + fun:strdup + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + fun:strdup + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} { name Memcheck:Leak @@ -49,36 +217,11 @@ { name Memcheck:Leak - match-leak-kinds: definite + match-leak-kinds: indirect fun:malloc + fun:strdup obj:* obj:* - fun:SDL_DBus_Init_Spinlocked.lto_priv.0 - fun:UnknownInlinedFun - fun:SDL_InitSubSystem_REAL.part.0 - fun:_ZN3mlx4core11ApplicationC1Ev - fun:mlx_init - fun:main -} -{ - name - Memcheck:Leak - match-leak-kinds: definite - fun:malloc - obj:* - obj:* - fun:SDL_DBus_Init_Spinlocked.lto_priv.0 - fun:UnknownInlinedFun - fun:SDL_InitSubSystem_REAL.part.0 - fun:_ZN3mlx4core11ApplicationC1Ev - fun:mlx_init - fun:main -} -{ - name - Memcheck:Leak - match-leak-kinds: definite - fun:malloc obj:* obj:* fun:X11_InitKeyboard @@ -87,28 +230,14 @@ fun:SDL_InitSubSystem_REAL.part.0 fun:_ZN3mlx4core11ApplicationC1Ev fun:mlx_init - fun:main } { name Memcheck:Leak - match-leak-kinds: definite + match-leak-kinds: indirect fun:malloc obj:* obj:* - fun:SDL_DBus_Init_Spinlocked.lto_priv.0 - fun:UnknownInlinedFun - fun:SDL_InitSubSystem_REAL.part.0 - fun:_ZN3mlx4core11ApplicationC1Ev - fun:mlx_init - fun:main -} -{ - name - Memcheck:Leak - match-leak-kinds: definite - fun:malloc - obj:* obj:* obj:* fun:X11_InitKeyboard @@ -122,12 +251,29 @@ { name Memcheck:Leak - match-leak-kinds: definite + match-leak-kinds: indirect fun:malloc obj:* obj:* obj:* obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* obj:* obj:* obj:* @@ -139,10 +285,25 @@ { name Memcheck:Leak - match-leak-kinds: definite + match-leak-kinds: indirect fun:malloc obj:* obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* obj:* obj:* obj:* @@ -156,7 +317,137 @@ { name Memcheck:Leak - match-leak-kinds: definite + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect fun:calloc obj:* obj:* @@ -188,9 +479,7 @@ name Memcheck:Leak match-leak-kinds: definite - fun:calloc - obj:* - obj:* + fun:malloc obj:* obj:* fun:SDL_DBus_Init_Spinlocked.lto_priv.0 @@ -200,6 +489,1396 @@ fun:mlx_init fun:main } +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:realloc + fun:SDL_GetErrBuf + fun:SDL_SetError_REAL + fun:destroy + fun:_ZN3mlx10MLX_WindowD1Ev + fun:_M_release + fun:~__shared_count + fun:~__shared_ptr + fun:~pair + fun:destroy > > + fun:destroy > > + fun:_M_deallocate_node + fun:_M_deallocate_nodes + fun:clear + fun:_ZNSt10_HashtableIjSt4pairIKjSt10shared_ptrIN3mlx10MLX_WindowEEESaIS6_ENSt8__detail10_Select1stESt8equal_toIjESt4hashIjENS8_18_Mod_range_hashingENS8_20_Default_ranged_hashENS8_20_Prime_rehash_policyENS8_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev + fun:~unordered_map + fun:~Input + fun:operator() + fun:~unique_ptr + fun:_ZN3mlx4core11ApplicationD1Ev + fun:mlx_destroy_display + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:realloc + fun:SDL_SetError_REAL + fun:destroy + fun:_ZN3mlx10MLX_WindowD1Ev + fun:_M_release + fun:~__shared_count + fun:~__shared_ptr + fun:~pair + fun:destroy > > + fun:destroy > > + fun:_M_deallocate_node + fun:_M_deallocate_nodes + fun:clear + fun:_ZNSt10_HashtableIjSt4pairIKjSt10shared_ptrIN3mlx10MLX_WindowEEESaIS6_ENSt8__detail10_Select1stESt8equal_toIjESt4hashIjENS8_18_Mod_range_hashingENS8_20_Default_ranged_hashENS8_20_Prime_rehash_policyENS8_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev + fun:~unordered_map + fun:~Input + fun:operator() + fun:~unique_ptr + fun:_ZN3mlx4core11ApplicationD1Ev + fun:mlx_destroy_display + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:malloc + fun:UnknownInlinedFun + fun:SDL_strdup_REAL + fun:SDL_IBus_Init + fun:SDL_IME_Init.isra.0 + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev +} { name Memcheck:Leak @@ -217,6 +1896,1032 @@ fun:SDL_VideoInit_REAL fun:SDL_InitSubSystem_REAL.part.0 } +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:malloc + fun:malloc + fun:strdup + fun:_dl_load_cache_lookup + fun:_dl_map_object + fun:openaux + fun:_dl_catch_exception + fun:_dl_map_object_deps + fun:dl_open_worker_begin + fun:_dl_catch_exception + fun:dl_open_worker + fun:_dl_catch_exception + fun:_dl_open +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:malloc + fun:malloc + fun:_dl_new_object + fun:_dl_map_object_from_fd + fun:_dl_map_object + fun:openaux + fun:_dl_catch_exception + fun:_dl_map_object_deps + fun:dl_open_worker_begin + fun:_dl_catch_exception + fun:dl_open_worker + fun:_dl_catch_exception + fun:_dl_open +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:realloc + fun:SDL_realloc_REAL + fun:UnknownInlinedFun + fun:SDL_TLSSet_REAL + fun:SDL_GetErrBuf + fun:SDL_SetError_REAL + fun:destroy + fun:_ZN3mlx10MLX_WindowD1Ev + fun:_M_release + fun:~__shared_count + fun:~__shared_ptr + fun:~pair + fun:destroy > > + fun:destroy > > + fun:_M_deallocate_node + fun:_M_deallocate_nodes + fun:clear + fun:_ZNSt10_HashtableIjSt4pairIKjSt10shared_ptrIN3mlx10MLX_WindowEEESaIS6_ENSt8__detail10_Select1stESt8equal_toIjESt4hashIjENS8_18_Mod_range_hashingENS8_20_Default_ranged_hashENS8_20_Prime_rehash_policyENS8_17_Hashtable_traitsILb0ELb0ELb1EEEED2Ev + fun:~unordered_map + fun:~Input + fun:operator() + fun:~unique_ptr + fun:_ZN3mlx4core11ApplicationD1Ev + fun:mlx_destroy_display + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:malloc + fun:malloc + fun:strdup + fun:_dl_load_cache_lookup + fun:_dl_map_object + fun:dl_open_worker_begin + fun:_dl_catch_exception + fun:dl_open_worker + fun:_dl_catch_exception + fun:_dl_open + fun:dlopen_doit + fun:_dl_catch_exception + fun:_dl_catch_error +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:malloc + fun:malloc + fun:_dl_new_object + fun:_dl_map_object_from_fd + fun:_dl_map_object + fun:dl_open_worker_begin + fun:_dl_catch_exception + fun:dl_open_worker + fun:_dl_catch_exception + fun:_dl_open + fun:dlopen_doit + fun:_dl_catch_exception + fun:_dl_catch_error +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + fun:strdup + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_CallMethodInternal + fun:SDL_DBus_CallMethodOnConnection + fun:IBus_SetupConnection +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_CallMethodInternal + fun:SDL_DBus_CallMethod + fun:SDL_DBus_ScreensaverInhibit +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + fun:strdup + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_CallMethodInternal + fun:SDL_DBus_CallMethod + fun:SDL_DBus_ScreensaverInhibit + fun:X11_SuspendScreenSaver + fun:UnknownInlinedFun + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_CallMethodInternal + fun:SDL_DBus_CallMethodOnConnection + fun:IBus_SetupConnection +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_CallVoidMethodInternal + fun:SDL_DBus_CallVoidMethod + fun:X11_SuspendScreenSaver + fun:UnknownInlinedFun + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:malloc + fun:malloc + fun:_dl_close_worker + fun:_dl_close + fun:_dl_catch_exception + fun:_dl_catch_error + fun:_dlerror_run + fun:dlclose@@GLIBC_2.34 + fun:UnknownInlinedFun + fun:loader_scanned_icd_clear.constprop.0 + fun:UnknownInlinedFun + fun:UnknownInlinedFun + fun:vkDestroyInstance + fun:_ZN3mlx8Instance7destroyEv + fun:_ZN3mlx11Render_Core7destroyEv + fun:mlx_destroy_display +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:calloc + obj:* + obj:* + obj:* + obj:* + fun:SDL_DBus_Init_Spinlocked.lto_priv.0 + fun:UnknownInlinedFun + fun:SDL_InitSubSystem_REAL.part.0 + fun:_ZN3mlx4core11ApplicationC1Ev + fun:mlx_init + fun:main +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + fun:strdup + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: definite + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + fun:strdup + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:calloc + fun:calloc + fun:_dl_check_map_versions + fun:dl_open_worker_begin + fun:_dl_catch_exception + fun:dl_open_worker + fun:_dl_catch_exception + fun:_dl_open + fun:dlopen_doit + fun:_dl_catch_exception + fun:_dl_catch_error + fun:_dlerror_run + fun:dlopen_implementation + fun:dlopen@@GLIBC_2.34 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard +} { name Memcheck:Leak @@ -251,6 +2956,108 @@ fun:SDL_VideoInit_REAL fun:SDL_InitSubSystem_REAL.part.0 } +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:realloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL + fun:SDL_InitSubSystem_REAL.part.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:calloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 +} { name Memcheck:Leak @@ -268,6 +3075,42 @@ obj:* fun:X11_InitKeyboard } +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:calloc + fun:calloc + fun:_dl_new_object + fun:_dl_map_object_from_fd + fun:_dl_map_object + fun:openaux + fun:_dl_catch_exception + fun:_dl_map_object_deps + fun:dl_open_worker_begin + fun:_dl_catch_exception + fun:dl_open_worker + fun:_dl_catch_exception + fun:_dl_open +} +{ + name + Memcheck:Leak + match-leak-kinds: reachable + fun:calloc + fun:calloc + fun:_dl_new_object + fun:_dl_map_object_from_fd + fun:_dl_map_object + fun:dl_open_worker_begin + fun:_dl_catch_exception + fun:dl_open_worker + fun:_dl_catch_exception + fun:_dl_open + fun:dlopen_doit + fun:_dl_catch_exception + fun:_dl_catch_error +} { name Memcheck:Leak @@ -285,6 +3128,40 @@ fun:X11_VideoInit.lto_priv.0 fun:SDL_VideoInit_REAL } +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* +} +{ + name + Memcheck:Leak + match-leak-kinds: indirect + fun:malloc + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + obj:* + fun:X11_InitKeyboard + fun:X11_VideoInit.lto_priv.0 + fun:SDL_VideoInit_REAL +} { name Memcheck:Leak From b79b8da031c6281b78aa3098bd8845e1826d2388 Mon Sep 17 00:00:00 2001 From: Kbz-8 Date: Sat, 9 Dec 2023 18:02:30 +0100 Subject: [PATCH 14/14] improving vsupp file --- src/core/application.cpp | 5 +++-- src/core/graphics.cpp | 3 ++- src/platform/window.cpp | 19 ++++++++++------- src/platform/window.h | 4 ++-- valgrind.supp | 46 +++++++++++++++++++++++++++++++++------- 5 files changed, 56 insertions(+), 21 deletions(-) diff --git a/src/core/application.cpp b/src/core/application.cpp index f8ce592..a7c3749 100644 --- a/src/core/application.cpp +++ b/src/core/application.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 22:10:52 by maldavid #+# #+# */ -/* Updated: 2023/12/08 13:32:18 by kbz_8 ### ########.fr */ +/* Updated: 2023/12/09 17:44:13 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -35,7 +35,7 @@ namespace mlx::core if(_loop_hook) _loop_hook(_param); - + for(auto& gs : _graphics) gs->endRender(); } @@ -66,6 +66,7 @@ namespace mlx::core Application::~Application() { + SDL_QuitSubSystem(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_EVENTS); SDL_Quit(); } } diff --git a/src/core/graphics.cpp b/src/core/graphics.cpp index 0ef2dba..a66e140 100644 --- a/src/core/graphics.cpp +++ b/src/core/graphics.cpp @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/04/02 15:13:55 by maldavid #+# #+# */ -/* Updated: 2023/11/24 20:42:15 by maldavid ### ########.fr */ +/* Updated: 2023/12/09 16:52:08 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -77,5 +77,6 @@ namespace mlx _text_put_pipeline->destroy(); _pixel_put_pipeline.destroy(); _renderer->destroy(); + _window->destroy(); } } diff --git a/src/platform/window.cpp b/src/platform/window.cpp index ffbbbca..c3e712f 100644 --- a/src/platform/window.cpp +++ b/src/platform/window.cpp @@ -6,13 +6,14 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 17:36:44 by maldavid #+# #+# */ -/* Updated: 2023/11/25 11:48:26 by maldavid ### ########.fr */ +/* Updated: 2023/12/09 16:52:29 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ #include #include #include +#include namespace mlx { @@ -40,14 +41,16 @@ namespace mlx void MLX_Window::destroy() noexcept { - if(_win) + std::cout << "prout" << std::endl; + if(_win != nullptr) + { SDL_DestroyWindow(_win); - if(_icon) + _win = nullptr; + } + if(_icon != nullptr) + { SDL_FreeSurface(_icon); - } - - MLX_Window::~MLX_Window() - { - destroy(); + _icon = nullptr; + } } } diff --git a/src/platform/window.h b/src/platform/window.h index 8923564..f1c7f16 100644 --- a/src/platform/window.h +++ b/src/platform/window.h @@ -6,7 +6,7 @@ /* By: maldavid +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2022/10/04 21:53:12 by maldavid #+# #+# */ -/* Updated: 2023/12/08 19:05:31 by kbz_8 ### ########.fr */ +/* Updated: 2023/12/09 16:35:57 by kbz_8 ### ########.fr */ /* */ /* ************************************************************************** */ @@ -31,7 +31,7 @@ namespace mlx void destroy() noexcept; - ~MLX_Window(); + ~MLX_Window() = default; private: SDL_Surface* _icon = nullptr; diff --git a/valgrind.supp b/valgrind.supp index 5f02aa8..ed92da5 100644 --- a/valgrind.supp +++ b/valgrind.supp @@ -1,20 +1,50 @@ +{ + name + Memcheck:Leak + fun:*alloc + ... + obj:*libmlx* + ... +} +{ + name + Memcheck:Leak + fun:*alloc + ... + obj:*SDL* + ... +} +{ + name + Memcheck:Leak + fun:*alloc + ... + obj:*X11* + ... +} +{ + name + Memcheck:Leak + fun:*alloc + ... + obj:*libGLX_nvidia.so* + ... +} { name Memcheck:ReallocZero fun:realloc - obj:/usr/lib/libnvidia-glcore.so.545.29.06 - obj:/usr/lib/libGLX_nvidia.so.545.29.06 - obj:/usr/lib/libGLX_nvidia.so.545.29.06 - obj:/usr/lib/libGLX_nvidia.so.545.29.06 + ... + obj:*libGLX_nvidia.so* + ... } { name Memcheck:BadSize fun:posix_memalign - obj:/usr/lib/libnvidia-glcore.so.545.29.06 - obj:/usr/lib/libGLX_nvidia.so.545.29.06 - obj:/usr/lib/libGLX_nvidia.so.545.29.06 - obj:/usr/lib/libGLX_nvidia.so.545.29.06 + ... + obj:*libGLX_nvidia.so* + ... } { name